# Methoden und Objekte, die QOwnNotes bereitstellt

# Starten eines externen Programms im Hintergrund

# Methodenaufruf und Parameter

/**
 * QML-Wrapper um einen unabh├Ąngigen Prozess zu starten
 *
 * @param executablePath der Pfad der Programmdatei
 * @param parameters eine Liste von Parameterstrings
 * @param callbackIdentifier ein Identifier, der in der Funktion onDetachedProcessCallback() verwendet werden soll (optional)
 * @param callbackParameter ein zus├Ątzlicher Parameter f├╝r Schleifen oder ├Ąhnliches (optional)
 * @param processData in den Prozess geschriebene Daten, wenn der Callback verwendet wird (optional)
 * @param workingDirectory das Arbeitsverzeichnis, in dem der Prozess ausgef├╝hrt werden soll (optional, funktioniert nur ohne Callback)
 * @return true bei Erfolg, sonst false
 */
bool startDetachedProcess(QString executablePath, QStringList parameters,
                            QString callbackIdentifier, QVariant callbackParameter,
                            QByteArray processData, QString workingDirectory);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Beispiel

Einfaches Beispiel:

script.startDetachedProcess("/path/to/my/program", ["my parameter"]);
1

Viele Prozesse ausf├╝hren:

for (var i = 0; i < 100; i++) {
    var dur = Math.floor(Math.random() * 10) + 1;
    script.startDetachedProcess("sleep", [`${dur}s`], "my-callback", i);
}

function onDetachedProcessCallback(callbackIdentifier, resultSet, cmd, thread) {
    if (callbackIdentifier == "my-callback") {
        script.log(`#${thread[1]} i[${thread[0]}] t${cmd[1]}`);
    }
}
1
2
3
4
5
6
7
8
9
10

Schauen Sie sich dazu die Beispiele auf custom-actions.qml (opens new window), callback.qml (opens new window) oder execute-command-after-note-update.qml (opens new window) an.

Vielleicht m├Âchten Sie auch einen Blick auf den Hook onDetachedProcessCallback werfen.

# Ein externes Programm starten und auf eine Ausgabe warten

# Methodenaufruf und Parameter

/**
 * QML-Wrapper, um einen gleichlaufenden Prozess zu starten
 *
 * @param executablePath der Pfad der Programmdatei
 * @param parameters eine Liste von Parameter-strings
 * @param data die Daten, die an den Prozess geschrieben werden (optional)
 * @param workingDirectory das Arbeitsverzeichnis, in dem der Prozess ausgef├╝hrt werden soll (optional)
 * @return der Text, der durch den Prozess zur├╝ckgegeben wurde
QByteArray startSynchronousProcess(QString executablePath, QStringList parameters, QByteArray data, QString workingDirectory);
1
2
3
4
5
6
7
8
9

# Beispiel

var result = script.startSynchronousProcess("/path/to/my/program", ["my parameter"], "data", "/path/to/execute/in");
1

Schauen Sie sich dazu das Beispiel auf encryption-keybase.qml (opens new window) an.

# Abrufen des Pfads des aktuellen Notizordners

# Methodenaufruf und Parameter

/**
 * QML-Wrapper, um den aktuellen Pfad des Notizordners abzurufen
 *
 * @return der Pfad des aktuellen Notizordners
 */
QString currentNoteFolderPath();
1
2
3
4
5
6

# Beispiel

var path = script.currentNoteFolderPath();
1

Schauen Sie sich dazu das Beispiel auf absolute-media-links.qml (opens new window) an.

# Abrufen der aktuellen Notiz

# Methodenaufruf und Parameter

/**
 * QML-Wrapper, um die aktuelle Notiz zu erhalten
 *
 * @returns {NoteApi} das aktuelle Notizobjekt
 */
NoteApi currentNote();
1
2
3
4
5
6

# Beispiel

var note = script.currentNote();
1

Schauen Sie sich dazu das Beispiel auf custom-actions.qml (opens new window) an.

# Protokollierung auf das Protokoll-Widget

# Methodenaufruf und Parameter

/**
 * QML-Wrapper, um auf das Protokoll-Widget zu protokollieren
 *
 * @param text
 */
void log(QString text);
1
2
3
4
5
6

# Beispiel

script.log("my text");
1

# Herunterladen einer URL in eine Zeichenfolge

# Methodenaufruf und Parameter

/**
 * QML-Wrapper, um eine URL herunterzuladen und als Text zur├╝ckzugeben
 *
 * @param url
 * @return {QString} der Inhalt der heruntergeladenen URL
 */
QString downloadUrlToString(QUrl url);
1
2
3
4
5
6
7

# Beispiel

var html = script.downloadUrlToString("https://www.qownnotes.org");
1

Schauen Sie sich dazu das Beispiel auf insert-headline-with-link-from-github-url.qml (opens new window) an.

# Herunterladen einer URL in den Medienordner

# Methodenaufruf und Parameter

/**
 * QML-Wrapper, um eine URL in den Medienordner herunterzuladen und die Medien-URL oder
 * den Markdown-Bildtext der Medien relativ zur aktuellen Notiz zur├╝ckzugeben
 *
 * @param {QString} url
 * @param {bool} returnUrlOnly falls true, wird nur die Medien-URL zur├╝ckgeben (standardm├Ą├čig false)
 * @return {QString} Medien-Markdown oder -URL
 */
QString downloadUrlToMedia(QUrl url, bool returnUrlOnly);
1
2
3
4
5
6
7
8
9

# Beispiel

var markdown = script.downloadUrlToMedia("http://latex.codecogs.com/gif.latex?\frac{1}{1+sin(x)}");
1

Schauen Sie sich das Beispiel auf paste-latex-image.qml (opens new window) an.

# Einf├╝gen einer Mediendatei in den Medienordner

# Methodenaufruf und Parameter

/**
 * QML-Wrapper, um eine Mediendatei in den Medienordner einzuf├╝gen und die Medien-URL
 * oder den Markdown-Bildtext der Medien relativ zur aktuellen Notiz zur├╝ckzugeben
 *
 * @param {QString} mediaFilePath
 * @param {bool} returnUrlOnly falls true, wird nur die Medien-URL zur├╝ckgegeben (standardm├Ą├čig false)
 * @return {QString} Medien-Markdown oder -URL
 */
QString ScriptingService::insertMediaFile(QString mediaFilePath,
                                        bool returnUrlOnly);
1
2
3
4
5
6
7
8
9
10

# Beispiel

var markdown = script.insertMediaFile("/path/to/your/image.png");
1

Schauen Sie sich dazu das Beispiel auf scribble.qml (opens new window) an.

# Einf├╝gen einer Anhangsdatei in den Anhangsordner

# Methodenaufruf und Parameter

 * QML-Wrapper zum Einf├╝gen einer Anhangsdatei in den Ordner `attachments` und
 * R├╝ckgabe der Anhangs-URL oder des Markdown-Textes des Anhangs
 * bezogen auf die aktuelle Notiz
 *
 * @param {QString} attachmentFilePath
 * @param {QString} fileName f├╝r den Markdown
 * @param {bool} returnUrlOnly falss true, wird nur die Anhangs-URL zur├╝ckgegeben
 * (standardm├Ą├čig false)
 * @return {QString} das Markdown oder die URL des Anhangs
 */
QString ScriptingService::insertAttachmentFile(const QString &attachmentFilePath,
                                                const QString &fileName,
                                                bool returnUrlOnly);
1
2
3
4
5
6
7
8
9
10
11
12
13

# Beispiel

var markdown = script.insertAttachmentFile("/path/to/your/file.png");
1

# Die Notizvorschau erneuern

Aktualisiert die Notizvorschau.

# Methodenaufruf und Parameter

/**
 * Erzeugt die Notizvorschau neu
 */
QString ScriptingService::regenerateNotePreview();
1
2
3
4

# Beispiel

script.regenerateNotePreview();
1

Schauen Sie sich dazu das Beispiel auf scribble.qml (opens new window) an.

# Registrieren einer benutzerdefinierten Aktion

# Methodenaufruf und Parameter

/**
 * Registriert eine benutzerdefinierte Aktion
 *
 * @param identifier Der Identifier der Aktion
 * @param menuText Der Text, der im Men├╝ angezeigt wird
 * @param buttonText Der Text, der auf dem Button angezeigt wird
 *                   (falls leer, wird kein Button angezeigt)
 * @param icon Dateipfad des Icons, oder der Name eines freedesktop theme-Icons
 *             hier finden Sie eine Liste von Icons:
 *             https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
 * @param useInNoteEditContextMenu falls true, nutze die Aktion in der Notizbearbeitungs-
 *                                 Konextmen├╝ (standard: false)
 * @param hideButtonInToolbar falls true, wird der Button nicht in der Toolbar f├╝r
 *                            benutzerdefinierte Aktionen angezeigt (standard: false)
 * @param useInNoteListContextMenu falls true, wird die Aktion im Notizlisten-
 *                                 Kontextmen├╝ benutzt (standard: false)
 */
void ScriptingService::registerCustomAction(QString identifier,
                                            QString menuText,
                                            QString buttonText,
                                            QString icon,
                                            bool useInNoteEditContextMenu,
                                            bool hideButtonInToolbar,
                                            bool useInNoteListContextMenu);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

TIP

Sie k├Ânnen Ihren benutzerdefinierten Aktionen auch lokale und globale Verkn├╝pfungen in den Verkn├╝pfungseinstellungen zuweisen.

WARNING

Denken Sie daran, dass freedesktop theme Icons (opens new window) meist nur unter Linux verf├╝gbar sind. Wenn Sie also wirklich ein Icon unter macOS oder Windows verwenden m├Âchten, m├╝ssen Sie eines mit Ihrem Skript bereitstellen. Um den Pfad Ihres Skripts zu erhalten, um einen richtigen Pfad f├╝r Ihr Icon festzulegen, k├Ânnen Sie die scriptDirPath property verwenden.

# Beispiel

import QtQml 2.0
import QOwnNotesTypes 1.0

Script {
    /**
     * Initialisiert die benutzerdefinierten Funktionen
     */
    function init() {
        // f├╝ge eine benutzerdefinierte Funktion ohne Button hinzu
        script.registerCustomAction("mycustomaction1", "Menu text");

        // f├╝ge eine benutzerdefinierte Funktion mit einem Button hinzu
        script.registerCustomAction("mycustomaction2", "Menu text", "Button text");

        // f├╝ge eine benutzerdefinierte Funktion mit einem Button und freedesktop theme-Icon hinzu
        script.registerCustomAction("mycustomaction3", "Menu text", "Button text", "task-new");

        // f├╝ge eine benutzerdefinierte Funktion mit einem Button und Icon aus einer Datei hinzu
        script.registerCustomAction("mycustomaction4", "Menu text", "Button text", "/usr/share/icons/breeze/actions/24/view-calendar-tasks.svg");
    }

    /**
     * Diese Funktion wird aufgerufen, wenn eine benutzerdefinierte Funktion
     * im Men├╝ oder mit einem Button ausgel├Âst wird
     * 
     * @param identifier string Der Identifier, der in registerCustomAction definiert wurde
     */
    function customActionInvoked(identifier) {
        switch (identifier) {
            case "mycustomaction1":
                script.log("Action 1");
            break;
            case "mycustomaction2":
                script.log("Action 2");
            break;
            case "mycustomaction3":
                script.log("Action 3");
            break;
            case "mycustomaction4":
                script.log("Action 4");
            break;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

Weitere Beispiele finden Sie unter custom-actions.qml (opens new window).

TIP

Sie k├Ânnen eine benutzerdefinierte Aktion auch nach dem Start der Anwendung mit dem Parameter --action customAction_<identifier> ausl├Âsen. Weitere Informationen finden Sie unter Men├╝aktionen nach dem Start ausl├Âsen.

# Ein Label registrieren

# Methodenaufruf und Parameter

/**
 * Registriert ein Label, um etwas darauf zu schreiben
 *
 * @param identifier Der Identifier des Labels
 * @param text Der Text, der auf dem Label angezeigt wird (optional)
 */
void ScriptingService::registerLabel(QString identifier, QString text);
1
2
3
4
5
6
7

# Beispiel

script.registerLabel("html-label", "<strong>Strong</strong> HTML text<br />with three lines<br />and a <a href='https://www.qownnotes.org'>link to a website</a>.");

script.registerLabel ("long-label", "ein anderer sehr langer Text, ein anderer sehr langer Text, ein anderer sehr langer Text, ein anderer sehr langer Text, ein anderer sehr langer Text, ein anderer sehr langer Text, ein anderer sehr langer Text, ein anderer sehr langer Text, ein anderer sehr langer Text, ein anderer sehr langer Text, ein anderer sehr langer Text, der umbrochen wird ");

script.registerLabel ("counter-label");
1
2
3
4
5

Die Labels sind im Skript-Bedienfeld sichtbar, das Sie im Men├╝ Fenster / Bedienfelder aktivieren m├╝ssen.

Sie k├Ânnen sowohl einfachen Text als auch HTML in den Labels verwenden. Der Text kann ausgew├Ąhlt werden und Links k├Ânnen angeklickt werden.

Schauen Sie sich dazu das Beispielskript auf scripting-label-demo.qml (opens new window) an.

# Festlegen des Textes eines registrierten Labels

# Methodenaufruf und Parameter

/**
 * Legt den Text eines registrierten Labels fest
 *
 * @param identifier Der Identifier des Labels
 * @param text Der Text, der auf dem Label angezeigt wird
 */
void ScriptingService::setLabelText(QString identifier, QString text);
1
2
3
4
5
6
7

# Beispiel

script.setLabelText("counter-label", "counter text");
1

Sie k├Ânnen sowohl einfachen Text als auch HTML in den Labels verwenden. Der Text kann ausgew├Ąhlt werden und Links k├Ânnen angeklickt werden.

Schauen Sie sich das Beispielskript auf scripting-label-demo.qml (opens new window) an.

TIP

The scripting label also supports external links, as well as internal links to notes, tasks, deck cards and more. You might get a grasp of what's supported by taking a look at URL handling (opens new window).

# Neue Notiz erstellen

# Methodenaufruf und Parameter

/**
 * Erstellt eine neue Notiz
 **
 * @param text Der Notiztext
 */
void ScriptingService::createNote(QString-Text);
1
2
3
4
5
6

# Beispiel

script.createNote("My note headline\n===\n\nMy text");
1

Schauen Sie sich dazu das Beispiel auf custom-actions.qml (opens new window) an.

TIP

Falls Sie abgeschaltet haben, dass Ihre Notizkopfzeile den Notiz-Dateinamen festlegt, m├╝ssen Sie die Notizdatei nachher selbst so umbenennen:

var note = script.currentNote();
note.renameNoteFile('your-filename');
1
2

# Zugriff auf die Zwischenablage

# Methodenaufruf und Parameter

/**
 * Gibt den Inhalt der Zwischenablage als Text oder HTML zur├╝ck
 *
 * @param asHtml gibt den Inhalt der Zwischenablage als HTML anstelle von Text zur├╝ck
 */
QString ScriptingService::clipboard (bool asHtml);
1
2
3
4
5
6

# Beispiel

var clipboardText = script.clipboard();
var clipboardHtml = script.clipboard(true);
1
2

Schauen Sie sich dazu das Beispiel auf custom-actions.qml (opens new window) an.

# Text in das Notizbearbeitungsfeld schreiben

# Methodenaufruf und Parameter

/**
 * Schreibt Text an die aktuelle Cursorposition in der Notiztextbearbeitung
 *
 * @param text
 */
void ScriptingService::noteTextEditWrite(QString text);
1
2
3
4
5
6

# Beispiel

// schreibe Text in die Notiz Textbearbeitung
script.noteTextEditWrite("My custom text");
1
2

Schauen Sie sich die benutzerdefinierte Aktion transformTextRot13 in dem Beispiel auf custom-actions.qml (opens new window) an.

Sie k├Ânnen dies zusammen mit noteTextEditSelectAll verwenden, um den gesamten Text der aktuellen Notiz zu ├╝berschreiben.

# Den ausgew├Ąhlten Text in der Notizbearbeitung lesen

# Methodenaufruf und Parameter

/**
 * Liest den ausgew├Ąhlten Text in der Notiztextbearbeitung
 *
 * @return
 */
QString ScriptingService::noteTextEditSelectedText();
1
2
3
4
5
6

# Beispiel

// lese den ausgew├Ąhlten Text aus der Notiztextbearbeitung
var text = script.noteTextEditSelectedText();
1
2

Schauen Sie sich die benutzerdefinierte Aktion transformTextRot13 in dem Beispiel auf custom-actions.qml (opens new window) an.

# Den gesamten Text in der Notiztextbearbeitung ausw├Ąhlen

# Methodenaufruf und Parameter

/**
 * W├Ąhlt den gesamten Text in der Notiztextbearbeitung aus
 */
void ScriptingService::noteTextEditSelectAll();
1
2
3
4

# Beispiel

script.noteTextEditSelectAll();
1

Sie k├Ânnen dies zusammen mit noteTextEditWrite verwenden, um den gesamten Text der aktuellen Notiz zu ├╝berschreiben.

# W├Ąhlen Sie die aktuelle Zeile in der Notiztextbearbeitung aus

# Methodenaufruf und Parameter

/**
 * W├Ąhlt die aktuelle Zeile in der Notiztextbearbeitung aus
 */
void ScriptingService::noteTextEditSelectCurrentLine();
1
2
3
4

# Beispiel

script.noteTextEditSelectCurrentLine();
1

# Das aktuelle Wort in der Notiztextbearbeitung ausw├Ąhlen

# Methodenaufruf und Parameter

/**
  * W├Ąhlt das aktuelle Wort in der Notiztextbearbeitung aus
  */
void ScriptingService::noteTextEditSelectCurrentWord();
1
2
3
4

# Beispiel

script.noteTextEditSelectCurrentWord();
1

# Den aktuell ausgew├Ąhlten Text in der Notiztextbearbeitung festlegen

# Methodenaufruf und Parameter

/**
 * Legt den aktuell markierten Text in der Notiztextbearbeitung fest
 *
 * @param start
 * @param end
 */
void ScriptingService::noteTextEditSetSelection(int start, int end);
1
2
3
4
5
6
7

# Beispiel

// erweitert die aktuelle Auswahl um ein Zeichen
script.noteTextEditSetSelection(
    script.noteTextEditSelectionStart() - 1,
    script.noteTextEditSelectionEnd() + 1);
1
2
3
4

# Die Startposition der aktuellen Auswahl in der Notiztextbearbeitung erhalten

# Methodenaufruf und Parameter

/**
 * Gibt die Startposition der aktuellen Auswahl in der Notiztextbearbeitung zur├╝ck
 */
int ScriptingService::noteTextEditSelectionStart();
1
2
3
4

# Beispiel

script.log(script.noteTextEditSelectionStart());
1

# Die Endposition der aktuellen Auswahl in der Notiztextbearbeitung erhalten

# Methodenaufruf und Parameter

/**
 * Gibt die Endposition der aktuellen Auswahl in der Notiztextbearbeitung zur├╝ck
 */
int ScriptingService::noteTextEditSelectionEnd();
1
2
3
4

# Beispiel

script.log(script.noteTextEditSelectionEnd());
1

# Den Textcursor in der Notiztextbearbeitung auf eine bestimmte Position setzen

# Methodenaufruf und Parameter

/**
 * Setzt den Textcursor in der Notiztextbearbeitung auf eine bestimmte Position
 * 0 w├Ąre der Anfang der Notiz
 * Spezialfall: -1 w├Ąre das Ende der Notiz
 *
 * @param position
 */
void ScriptingService::noteTextEditSetCursorPosition(int position);
1
2
3
4
5
6
7
8

# Beispiel

// springe zum 11. Zeichen in der Notiz
script.noteTextEditSetCursorPosition(10);

// zum Ende der Notiz springen
script.noteTextEditSetCursorPosition(-1);
1
2
3
4
5

# Die aktuelle Position des Textcursors in der Notiztextbearbeitung abrufen

# Methodenaufruf und Parameter

/**
 * Gibt die aktuelle Position des Textcursors in der Notiztextbearbeitung zur├╝ck
 * 0 w├Ąre der Anfang der Notiz
 */
int ScriptingService::noteTextEditCursorPosition();
1
2
3
4
5

# Beispiel

script.log(script.noteTextEditCursorPosition());
1

# Das aktuelle Wort aus der Notiztextbearbeitung lesen

# Methodenaufruf und Parameter

/**
 * Liest das aktuelle Wort in der Notiztextbearbeitung
 *
 * @param withPreviousCharacters erh├Ąlt am Anfang auch mehrere Zeichen
 *                                    um Zeichen wie "@" zu erhalten, die nicht
 *                                    Wortzeichen sind
 * @return
 */
QString ScriptingService::noteTextEditCurrentWord(bool withPreviousCharacters);
1
2
3
4
5
6
7
8
9

# Beispiel

// Liest das aktuelle Wort in der Notiztextbearbeitung
var text = script.noteTextEditCurrentWord();
1
2

Schauen Sie sich dazu das Beispiel auf autocompletion.qml (opens new window) an.

# Read the current block from the note text edit

# Methodenaufruf und Parameter

/**
 * Reads the current block in the note text edit
 *
 * @return
 */
QString ScriptingService::noteTextEditCurrentBlock();
1
2
3
4
5
6

# Beispiel

// Read the current block in the note text edit
var text = script.noteTextEditCurrentBlock();
1
2

You may want to take a look at the example ai-autocompletion.qml (opens new window).

# Use a completion prompt on the currently selected AI model

The AI completion prompt is a feature that allows you to use a completion prompt on the currently selected AI model.

The AI system needs to be enabled in the AI toolbar or main menu for this to work.

# Methodenaufruf und Parameter

/**
 * QML wrapper to use the AI Completer
 *
 * @param prompt
 * @return {QString} the result of the completer
 */
QString ScriptingService::aiComplete(const QString& prompt);
1
2
3
4
5
6
7

# Beispiel

// Ask the currently selected AI model to complete the prompt
var text = script.aiComplete("Tell me how do you feel today?");
1
2

You may want to take a look at the example ai-autocompletion.qml (opens new window).

# Pr├╝fen, ob die Plattform Linux, OS X oder Windows ist

# Methodenaufruf und Parameter

bool ScriptingService::platformIsLinux();
bool ScriptingService::platformIsOSX();
bool ScriptingService::platformIsWindows();
1
2
3

# Beispiel

if (script.platformIsLinux()) {
    // Wird nur unter Linux ausgef├╝hrt
}
1
2
3

# Der aktuellen Notiz ein Schlagwort hinzuf├╝gen

# Methodenaufruf und Parameter

/**
 * Markiert die aktuelle Notiz mit einem Schlagwort namens tagName
 *
 * @param tagName
 */
void ScriptingService::tagCurrentNote(QString tagName);
1
2
3
4
5
6

# Beispiel

// f├╝gt der aktuellen Notiz ein "favorite"-Schlagwort hinzu
script.tagCurrentNote("favorite");
1
2

Schauen Sie sich dazu die benutzerdefinierte Aktion favoriteNote in dem Beispiel auf favorite-note.qml (opens new window) an.

# Ein Schlagwort anhand seiner Namen-Breadcrumb-Liste erstellen oder abrufen

# Methodenaufruf und Parameter

/**
 * Erstellt oder ruft ein Schlagwort anhand seiner "Breadcrumb-Liste" von Schlagwortnamen auf
 * Element nameList[0] w├Ąre das h├Âchste im Baum (mit parentId: 0)
 *
 * @param nameList
 * @param createMissing {bool} falls true (standard), werden alle fehlenden Schlagworte erstellt
 * @return TagApi Objekt des tiefsten Schlagworts in der Namen-Breadcrumb-Liste
 */
TagApi *ScriptingService::getTagByNameBreadcrumbList(
    const QStringList &nameList, bool createMissing);
1
2
3
4
5
6
7
8
9
10

# Beispiel

// erstellt alle Schlagworte bis zur 3. Ebene und gibt das Schlagwort-Objekt f├╝r
// Schlagwort "level3" zur├╝ck, das im Tag-Baum so aussehen w├╝rde:
// level1 > level2 > level3
var tag = script.getTagByNameBreadcrumbList(["level1", "level2", "level3"]);
1
2
3
4

# Schlagworte nach Namen suchen

# Methodenaufruf und Parameter

/**
 * Ruft alle Schlagworte ab, indem eine Teilstringsuche im Namensfeld durchgef├╝hrt wird
 *
 * @param name {QString} Name, nach dem gesucht werden soll
 * @return {QStringList} Liste der Schlagwort-Namen
 */
QStringList ScriptingService::searchTagsByName(QString name);
1
2
3
4
5
6
7

# Beispiel

// sucht nach allen Schlagworten mit dem Wort Spiel darin
var tags = script.searchTagsByName("Spiel");
1
2

Schauen Sie sich dazu das Beispiel auf autocompletion.qml (opens new window) an.

# Notizen nach Notiztext suchen

# Methodenaufruf und Parameter

/**
 * Gibt eine Liste der Notiz-IDs aller Notizen mit einem bestimmten Text im Notiztext zur├╝ck
 *
 * Leider gibt es keine einfache M├Âglichkeit, eine QList<NoteApi*> in QML zu verwenden,
 * weshalb wir nur die Notiz-IDs ├╝bertragen k├Ânnen
 *
 * @return {QList<int>} Liste der Notiz-IDs
 */
QList<int> ScriptingService::fetchNoteIdsByNoteTextPart(QString text);
1
2
3
4
5
6
7
8
9

# Beispiel

var noteIds = script.fetchNoteIdsByNoteTextPart("mytext");

noteIds.forEach(function(noteId){
    var note = script.fetchNoteById(noteId);

    // mach etwas mit der Notiz
});
1
2
3
4
5
6
7

Schauen Sie sich das Beispiel auf unique-note-id.qml (opens new window) an.

# Ein benutzerdefiniertes Stylesheet hinzuf├╝gen

# Methodenaufruf und Parameter

/**
 * F├╝gt der Anwendung ein benutzerdefiniertes Stylesheet hinzu
 *
 * @param Stylesheet
 */
void ScriptingService::addStyleSheet(QString stylesheet);
1
2
3
4
5
6

# Beispiel

// vergr├Â├čere den Text in der Notizliste
script.addStyleSheet("QTreeWidget#noteTreeWidget {font-size: 30px;}");
1
2

Schauen Sie sich das Beispiel auf custom-stylesheet.qml (opens new window) an.

Sie k├Ânnen die Widget-Namen aus den *.ui-Dateien erhalten; das Hauptfenster ist beispielsweise mainwindow.ui (opens new window).

Die Qt-Dokumentation (zum Beispiel QMainWindow (opens new window)) kann Ihnen helfen zu sehen, wie die Widgets miteinander verbunden sind (suchen Sie auf den Seiten nach Inherits).

Das Basis-Widget f├╝r fast alles ist QWidget (opens new window). Also einfach QWidget mit zum Beispiel QWidget {background-color: black; color: white;} w├╝rde bedeuten, dass alles eine schwarze Hintergrundfarbe und eine wei├če Vordergrundfarbe hat.

TIP

style.qss (opens new window) von qdarkstyle (opens new window) ist m├Âglicherweise auch eine gute Referenz f├╝r Styles, die Sie ├Ąndern k├Ânnen.

Sehen Sie sich die Stylesheet-Referenz (opens new window) an, um eine Referenz zu den verf├╝gbaren Stilen zu erhalten.

Wenn Sie Stile in die HTML-Vorschau einf├╝gen m├Âchten, um die Vorschau von Notizen zu ├Ąndern, sehen Sie sich bitte notetomarkdownhtmlhook an.

TIP

Wenn Sie tats├Ąchlich sehen m├Âchten, wie die Dialoge aussehen und wie sie hei├čen, k├Ânnen Sie Qt Creator (opens new window) herunterladen und die darin enthaltenen *.ui-Dateien ├Âffnen.

# Neuladen der Scripting-Engine

# Methodenaufruf und Parameter

/**
 * L├Ądt die Scripting-Engine neu
 */
void ScriptingService::reloadScriptingEngine();
1
2
3
4

# Beispiel

// l├Ądt die Scripting-Engine neu
script.reloadScriptingEngine();
1
2

# Abrufen einer Notiz anhand ihres Dateinamens

# Methodenaufruf und Parameter

/**
 * Ruft eine Notiz anhand ihres Dateinamens ab
 *
 * @param fileName string Der Dateinamen der Notiz (notwendig)
 * @param noteSubFolderId integer ID des Notizunterordners
 * @return NoteApi*
 */
NoteApi* ScriptingService::fetchNoteByFileName(QString fileName,
                                                int noteSubFolderId);
1
2
3
4
5
6
7
8
9

# Beispiel

// Notiz nach Dateiname abrufen
script.fetchNoteByFileName("my note.md");
1
2

# Abrufen einer Notiz anhand ihrer ID

# Methodenaufruf und Parameter

/**
 * Ruft eine Notiz anhand ihrer ID ab
 *
 * @param id int Die ID der Notiz
 * @return NoteApi*
 */
NoteApi* ScriptingService::fetchNoteById(int id);
1
2
3
4
5
6
7

# Beispiel

// Notiz nach ID abrufen
script.fetchNoteById(243);
1
2

Schauen Sie sich das Beispiel auf export-notes-as-one-html.qml (opens new window) an.

# Anhand des Dateinamens ├╝berpr├╝fen, ob eine Notiz vorhanden ist

# Methodenaufruf und Parameter

/**
 * ├ťberpr├╝ft anhand des Dateinamens, ob eine Notizdatei vorhanden ist
 *
 * @param fileName string Der Dateiname der Notiz (obligatorisch)
 * @param ignoreNoteId integer ID einer Notiz, die bei der Pr├╝fung ignoriert werden soll
 * @param noteSubFolderId integer ID des Notiz-Unterordners
 * @return bool
 */
bool ScriptingService::noteExistsByFileName(QString fileName,
                                            int ignoreNoteId,
                                            int noteSubFolderId);
1
2
3
4
5
6
7
8
9
10
11

# Beispiel

// pr├╝fe ob eine Notiz existiert, aber ignoriere die ID von "note"
script.noteExistsByFileName("my note.md", note.id);
1
2

Schauen Sie sich das Beispiel auf use-tag-names-in-filename.qml (opens new window) an.

# Kopieren von Text in die Zwischenablage

# Methodenaufruf und Parameter

/**
 * Kopiert Text als Klartext- oder HTML-MIME-Daten in die Zwischenablage
 *
 * @param text string Text, der in die Zwischenablage eingef├╝gt werden soll
 * @param asHtml bool Wenn true, wird der Text als HTML-MIME-Daten festgelegt
 */
void ScriptingService::setClipboardText(QString text, bool asHtml);
1
2
3
4
5
6
7

# Beispiel

// Text in die Zwischenablage kopieren
script.setClipboardText("zu kopierender Text");
1
2

Schauen Sie sich das Beispiel auf selected-markdown-to-bbcode.qml (opens new window) an.

# Zu einer Notiz springen

# Methodenaufruf und Parameter

/**
 * Legt die aktuelle Notiz fest, wenn die Notiz in der Notizliste sichtbar ist
 *
 * @param note NoteApi Notiz, in die gesprungen werden soll
 * @param asTab bool falls true, wird die Notiz in einem neuen Tab ge├Âffnet (falls nicht schon ge├Âffnet)
 */
void ScriptingService::setCurrentNote(NoteApi *note, bool asTab = false);
1
2
3
4
5
6
7

# Beispiel

// springt zur Notiz
script.setCurrentNote(note);

// ├Âffnet Notiz in neuem Tab (falls nicht schon ge├Âffnet)
script.setCurrentNote(note, true);
1
2
3
4
5

Schauen Sie sich das Beispiel auf journal-entry.qml (opens new window) an.

# Zu einem Notiz-Unterordner springen

# Methodenaufruf und Parameter

/**
 * Springt zu einem Notizunterordner
 *
 * @param noteSubFolderPath {QString} Pfad des Unterordners relativ zum Notizordner
 * @param separator {QString} Trennzeichen zwischen Teilen des Pfads, Standard "/"
 * @return true, wenn der Sprung erfolgreich war
 */
bool ScriptingService::jumpToNoteSubFolder(const QString &noteSubFolderPath,
                                            QString separator);
1
2
3
4
5
6
7
8
9

# Beispiel

// springe zum Notiz-Unterordner "ein Unterordner"
script.jumpToNoteSubFolder("ein Unterordner");

// springe zum Notiz-Unterordner "Sub" innerhalb von "einem Unterordner"
script.jumpToNoteSubFolder("ein Unterordner/Sub");
1
2
3
4
5

TIP

Sie k├Ânnen einen neuen Notizunterordner im aktuellen Unterordner erstellen, indem Sie mainWindow.createNewNoteSubFolder aufrufen.

# Anzeigen eines Informationsmeldungsfelds

# Methodenaufruf und Parameter

/ **
 * Zeigt ein Informationsmeldungsfeld an
 *
 * @param text
 * @param title (optional)
 */
void ScriptingService::informationMessageBox(QString text, QString title);
1
2
3
4
5
6
7

# Beispiel

// ein Informationsmeldungsfeld anzeigen
script.informationMessageBox("Der Text, den ich anzeigen m├Âchte", "Ein optionaler Titel");
1
2

# Anzeigen eines Fragenmeldungsfelds

# Methodenaufruf und Parameter

/ **
 * Zeigt ein Fragenmeldungsfeld an
 *
 * Informationen zu Schaltfl├Ąchen finden Sie unter:
 * https://doc.qt.io/qt-5/qmessagebox.html#StandardButton-enum
 *
 * @param text
 * @param title (optional)
 * @param buttons Schaltfl├Ąchen, die angezeigt werden sollen (optional)
 * @param defaultButton Standardschaltfl├Ąche, die ausgew├Ąhlt wird (optional)
 * @return ID der gedr├╝ckten Schaltfl├Ąche
 */
int ScriptingService::questionMessageBox(
        QString text, QString title, int buttons, int defaultButton);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Beispiel

// ein Fragenmeldungsfeld mit einer zum Anwenden-Schaltfl├Ąche und einer Hilfe-Schaltfl├Ąche anzeigen
// siehe: https://doc.qt.io/qt-5/qmessagebox.html#StandardButton-enum
var result = script.questionMessageBox(
    "Der Text, den ich anzeigen m├Âchte", "Ein optionaler Titel", 0x01000000|0x02000000, 0x02000000);
script.log(result);
1
2
3
4
5

Informationen zu Schaltfl├Ąchen finden Sie unter StandardButton (opens new window).

Schauen Sie sich dazu das Beispiel auf input-dialogs.qml (opens new window) an.

# Anzeigen eines Dialogs zum ├ľffnen von Dateien

# Methodenaufruf und Parameter

/**
 * Zeigt einen Dialog zum ├ľffnen von Dateien an
 *
 * @param caption (optional)
 * @param dir (optional)
 * @param filter (optional)
 * @return QString
 */
QString ScriptingService::getSaveFileName(QString caption, QString dir,
                                             QString filter);
1
2
3
4
5
6
7
8
9
10

# Example

// zeige einen Dialog zum ├ľffnen einer Datei
var fileName = script.getOpenFileName("Bitte w├Ąhlen Sie ein Bild aus", "/home/user/images", "Images (*.png *.xpm *.jpg)");
1
2

# Anzeigen eines Dialogfelds zum Speichern von Dateien

# Methodenaufruf und Parameter

/**
 * Zeigt einen Dialog zum Speichern von Dateien an
 *
 * @param caption (optional)
 * @param dir (optional)
 * @param filter (optional)
 * @return QString
 */
QString ScriptingService::getSaveFileName(QString caption, QString dir,
                                             QString filter);
1
2
3
4
5
6
7
8
9
10

# Beispiel

// zeige einen Dialog zum Speichern von Dateien
var fileName = script.getSaveFileName("Please select HTML file to save", "output.html", "HTML (*.html)");
1
2

Schauen Sie sich dazu das Beispiel auf export-notes-as-one-html.qml (opens new window) an.

# Registrieren von Skripteinstellungsvariablen

Sie m├╝ssen Ihre Einstellungsvariablen als Eigenschaften in Ihrem Skript definieren und in einer weiteren Eigenschaft mit dem Namen settingsVariables registrieren.

Der Benutzer kann diese Eigenschaften dann in den Skripteinstellungen festlegen.

# Beispiel

// Sie m├╝ssen Ihre registirerten Variablen definieren, damit Sie sp├Ąter auf sie zugreifen k├Ânnen
property string myString;
property bool myBoolean;
property string myText;
property int myInt;
property string myFile;
property string myDirectory;
property string mySelection;

// Registrieren Sie Ihre Einstellungsvariablen, sodass der Nutzer Sie in den Skripteinstellungen festlegen kann
//
// es gibt leider kein QVariantHash in Qt, wir k├Ânnen nur
// QVariantMap (was kein arbitr├Ąres sortieren hat) oder QVariantList (was immerhin
// arbitr├Ąr sortiert werden kann) verwenden
property variant settingsVariables: [
    {
        "identifier": "myString",
        "name": "I am a line edit",
        "description": "Please enter a valid string:",
        "type": "string",
        "default": "My default value",
    },
    {
        "identifier": "myBoolean",
        "name": "I am a checkbox",
        "description": "Some description",
        "text": "Check this checkbox",
        "type": "boolean",
        "default": true,
    },
    {
        "identifier": "myText",
        "name": "I am textbox",
        "description": "Please enter your text:",
        "type": "text",
        "default": "This can be a really long text\nwith multiple lines.",
    },
    {
        "identifier": "myInt",
        "name": "I am a number selector",
        "description": "Please enter a number:",
        "type": "integer",
        "default": 42,
    },
    {
        "identifier": "myFile",
        "name": "I am a file selector",
        "description": "Please select the file:",
        "type": "file",
        "default": "pandoc",
    },
    {
        "identifier": "myDirectory",
        "name": "I am a directory selector",
        "description": "Please select the directory:",
        "type": "directory",
        "default": "/home",
    },
    {
        "identifier": "mySelection",
        "name": "I am an item selector",
        "description": "Please select an item:",
        "type": "selection",
        "default": "option2",
        "items": {"option1": "Text for option 1", "option2": "Text for option 2", "option3": "Text for option 3"},
    }
];
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

Dar├╝ber hinaus k├Ânnen Sie die settingsVariables mit einer speziellen Funktion registerSettingsVariables() wie folgt ├╝berschreiben:

# Beispiel

/**
 * Registriert die Einstellungsvariablen erneut
 *
 * Verwenden Sie diese Methode, wenn Sie Code verwenden m├Âchten, um Ihre Variablen zu ├╝berschreiben, z.B.
 * um Standardwerte abh├Ąngig vom Betriebssystem festzulegen.
 */
function registerSettingsVariables() {
    if (script.platformIsWindows()) {
        // ├╝berschreibt den myFile-Standardwert
        settingsVariables[3].default = "pandoc.exe"
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

Schauen Sie sich dazu das Beispiel auf variables.qml (opens new window) an.

# Speichern und Laden persistenter Variablen

# Methodenaufruf und Parameter

/**
 * Speichert eine persistente Variable
 * Diese Variablen sind global ├╝ber alle Skripte zug├Ąnglich
 * Bitte verwenden Sie ein aussagekr├Ąftiges Pr├Ąfix in Ihrem Schl├╝ssel wie "PersistentVariablesTest/myVar"
 *
 * @param key {QString}
 * @param value {QVariant}
 */
void ScriptingService::setPersistentVariable(const QString &key,
                                                const QVariant &value);
/**
 * L├Ądt eine persistente Variable
 * Diese Variablen sind global ├╝ber alle Skripte zug├Ąnglich
 *
 * @param key {QString}
 * @param defaultValue {QVariant} R├╝ckgabewert, falls die Einstellung nicht existiert (optional)
 * @return
 */
QVariant ScriptingService::getPersistentVariable(const QString &key,
                                                    const QVariant &defaultValue);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# Beispiel

// persistente Variable speichern
script.setPersistentVariable("PersistentVariablesTest/myVar", result);

// persistente Variable laden und protokollieren
script.log(script.getPersistentVariable("PersistentVariablesTest/myVar", "nothing here yet"));
1
2
3
4
5

Stellen Sie sicher, dass Sie in Ihrem Schl├╝ssel ein aussagekr├Ąftiges Pr├Ąfix wie PersistentVariablesTest/myVar verwenden, da auf die Variablen von allen Skripten aus zugegriffen werden kann.

Schauen Sie sich dazu das Beispiel auf persistent-variables.qml (opens new window) an.

# Laden von Anwendungseinstellungsvariablen

# Methodenaufruf und Parameter

/**
 * L├Ądt eine Anwendungseinstellungsvariable
 *
 * @param key {QString}
 * @param defaultValue {QVariant} R├╝ckgabewert, wenn die Einstellung nicht vorhanden ist (optional)
 * @return
 */
QVariant ScriptingService::getApplicationSettingsVariable(const QString &key,
                                                             const QVariant &defaultValue);
1
2
3
4
5
6
7
8
9

# Beispiel

// Anwendungseinstellungsvariable laden und protokollieren script.log(script.getApplicationSettingsVariable("gitExecutablePath"));
1

Denken Sie daran, dass die Einstellungen tats├Ąchlich leer sein k├Ânnen und Sie sich selbst darum k├╝mmern m├╝ssen. defaultValue wird nur verwendet, wenn die Einstellung ├╝berhaupt nicht vorhanden ist.

# Erstellen eines Cache-Verzeichnisses

Sie k├Ânnen Dateien am Standard-Cache-Speicherort Ihres Systems zwischenspeichern.

# Methodenaufruf und Parameter

/**
 * Gibt ein Cache-Verzeichnis f├╝r ein Skript zur├╝ck
 *
 * @param {QString} subDir Der zu erstellende und zu verwendende Unterordner
 * @return {QString} Der Cache-Verzeichnispfad
 */
QString ScriptingService::cacheDir(const QString &subDir) const;
1
2
3
4
5
6
7

# Beispiel

// erstellt das Cache-Verzeichnis f├╝r my-script-id
var cacheDirForScript = script.cacheDir("my-script-id");
1
2

# L├Âschen eines Cache-Verzeichnisses

Sie k├Ânnen das Cache-Verzeichnis Ihres Skripts l├Âschen, indem Sie seinen Namen an clearCacheDir() ├╝bergeben.

# Methodenaufruf und Parameter

/**
 * L├Âscht das Cache-Verzeichnis f├╝r ein Skript
 *
 * @param {QString} subDir Der zu l├Âschende Unterordner
 * @return {bool} true bei Erfolg
 */
bool ScriptingService::clearCacheDir(const QString &subDir) const;
1
2
3
4
5
6
7

# Beispiel

// L├Âscht das Cache-Verzeichnis von my-script-id
script.clearCacheDir("my-script-id");
1
2

# Den Pfad zum Verzeichnis Ihres Skripts lesen

Wenn Sie den Pfad zu dem Verzeichnis abrufen m├╝ssen, in dem sich Ihr Skript befindet, um beispielsweise andere Dateien zu laden, m├╝ssen Sie eine property string scriptDirPath; registrieren. Diese Eigenschaft wird mit dem Pfad zum Verzeichnis des Skripts festgelegt.

# Beispiel

import QtQml 2.0
import QOwnNotesTypes 1.0

Script {
    // hier wird der Pfad zum Verzeichnis des Skripts gesetzt
    property string scriptDirPath;

    function init() {
        script.log(scriptDirPath);
    }
}
1
2
3
4
5
6
7
8
9
10
11

# Pfadtrennzeichen zu nativen konvertieren

# Methodenaufruf und Parameter

/**
 * Gibt den Pfad zur├╝ck, und konvertiert die "/" Trennzeichen zu Trennzeichen,
 * die f├╝r das zugrundeliegende Betriebssystem angemessen sind.
 *
 * Unter Windows, toNativeDirSeparators("c:/winnt/system32") gibt
 * "c:\winnt\system32" zur├╝ck.
 *
 * @param path
 * @return
 */
QString ScriptingService::toNativeDirSeparators(QString path);
1
2
3
4
5
6
7
8
9
10
11

# Beispiel

// gibt "c:\winnt\system32" unter Windows zur├╝ck
script.log(script.toNativeDirSeparators("c:/winnt/system32"));
1
2

# Pfadtrennzeichen von nativen konvertieren

# Methodenaufruf und Parameter

/**
 * Gibt den Pfad mit '/' als Dateitrennzeichen zur├╝ck.
 * Unter Windows gibt fromNativeDirSeparators("c:\\winnt\\system32")
 * beispielsweise "c:/winnt/system32" zur├╝ck.
 *
 * @param path
 * @return
 */
QString ScriptingService::toNativeDirSeparators(QString path);
1
2
3
4
5
6
7
8
9

# Beispiel

// gibt unter Windows "c:/winnt/system32" zur├╝ck
script.log(script.fromNativeDirSeparators("c:\\winnt\\system32"));
1
2

# Abrufen des nativen Verzeichnis-Trennzeichens

# Methodenaufruf und Parameter

/**
 * Gibt das native Verzeichnis-Trennzeichen "/" oder "\" unter Windows zur├╝ck
 *
 * @return
 */
QString ScriptingService::dirSeparator();
1
2
3
4
5
6

# Beispiel

// gibt unter Windows "\" zur├╝ck
script.log(script.dirSeparator());
1
2

# Abrufen einer Liste der Pfade aller ausgew├Ąhlten Notizen

# Methodenaufruf und Parameter

/**
 * Gibt eine Liste der Pfade aller ausgew├Ąhlten Notizen zur├╝ck
 *
 * @return {QStringList} Liste der ausgew├Ąhlten Notizpfade
 */
QStringList ScriptingService::selectedNotesPaths();
1
2
3
4
5
6

# Beispiel

// gibt eine Liste der Pfade aller ausgew├Ąhlten Notizen zur├╝ck
script.log(script.selectedNotesPaths());
1
2

Schauen Sie sich dazu das Beispiel auf external-note-diff.qml (opens new window) an.

# Abrufen einer Liste der IDs aller ausgew├Ąhlten Notizen

# Methodenaufruf und Parameter

/**
 * Gibt eine Liste der IDs aller ausgew├Ąhlten Notizen zur├╝ck
 *
 * @return {QList<int>} Liste der ausgew├Ąhlten Notiz-IDs
 */
QList<int> ScriptingService::selectedNotesIds();
1
2
3
4
5
6

# Beispiel

// gibt eine Liste der IDs aller ausgew├Ąhlten Notizen zur├╝ck
script.log(script.selectedNotesIds());
1
2

Schauen Sie sich dazu das Beispiel auf export-notes-as-one-html.qml (opens new window) an.

# Ausl├Âsen einer Men├╝aktion

# Methodenaufruf und Parameter

/**
 * L├Âst eine Men├╝aktion aus
 *
 * @param objectName {QString} Objektname der auszul├Âsenden Aktion
 * @param checked {QString} l├Âst die Aktion nur aus, wenn der check-state anders
 *                          als dieser Parameter ist (optional, kann 0 oder 1 sein)
 */
void ScriptingService::triggerMenuAction(QString objectName, QString checked);
1
2
3
4
5
6
7
8

# Beispiel

// wechsle in den Nur-Lesen-Modus
script.triggerMenuAction("actionAllow_note_editing");

// schalte den Nur-Lesen-Modus ab
script.triggerMenuAction("actionAllow_note_editing", 1);
1
2
3
4
5

Schauen Sie sich dazu das Beispiel auf disable-readonly-mode.qml (opens new window) an.

TIP

Sie k├Ânnen die Objektnamen der Men├╝aktion aus mainwindow.ui (opens new window) erhalten. Suchen Sie einfach nach dem englischen Men├╝titel. Beachten Sie, dass sich diese Texte im Laufe der Zeit ├Ąndern k├Ânnen.

# ├ľffnen eines Eingabedialogs mit einem Auswahlfeld

# Methodenaufruf und Parameter

/ **
 * ├ľffnet einen Eingabedialog mit einem Auswahlfeld
 *
 * @param title {QString} Titel des Dialogfelds
 * @param label {QString} Beschriftungstext des Dialogfelds
 * @param items {QStringList} Liste der auszuw├Ąhlenden Elemente
 * @param current {int} Index des Elements, das ausgew├Ąhlt werden soll (standard: 0)
 * @param editable {bool} Wenn true, kann der Text im Dialogfeld bearbeitet werden (standard: false).
 * @return {QString} Text des ausgew├Ąhlten Elements
 */
QString ScriptingService::inputDialogGetItem(
        const QString &title, const QString &label, const QStringList &items,
        int current, bool editable);
1
2
3
4
5
6
7
8
9
10
11
12
13

An empty string will be returned, if Cancel was clicked or Escape was pressed.

# Beispiel

var result = script.inputDialogGetItem(
    "Kombinationsfeld", "Bitte w├Ąhlen Sie einen Artikel aus", ["Artikel 1", "Artikel 2", "Artikel 3"]);
script.log(result);
1
2
3

Schauen Sie sich dazu das Beispiel auf input-dialogs.qml (opens new window) an.

# ├ľffnen eines Eingabedialogs mit einer Zeilenbearbeitung

# Methodenaufruf und Parameter

/**
 * ├ľffnet einen Eingabedialog mit einer Zeilenbearbeitung
 *
 * @param title {QString} Titel des Dialogfelds
 * @param label {QString} Beschriftungstext des Dialogfelds
 * @param text {QString} Text im Dialog (optional)
 * @return
 * /
QString ScriptingService::inputDialogGetText(
        const QString &title, const QString &label, const QString &text);
1
2
3
4
5
6
7
8
9
10

An empty string will be returned, if Cancel was clicked or Escape was pressed.

# Beispiel

var result = script.inputDialogGetText(
    "Zeilenbearbeitung", "Bitte geben Sie einen Namen ein", "aktueller Text");
script.log(result);
1
2
3

# Opening an input dialog with a multi-line text edit

# Methodenaufruf und Parameter

/**
 * Opens an input dialog with a multi-line text edit
 *
 * @param title {QString} title of the dialog
 * @param label {QString} label text of the dialog
 * @param text {QString} text in the dialog (optional)
 * @return
 */
QString ScriptingService::inputDialogGetMultiLineText(
        const QString &title, const QString &label, const QString &text);
1
2
3
4
5
6
7
8
9
10

An empty string will be returned, if Cancel was clicked or Escape was pressed.

# Beispiel

var result = script.inputDialogGetMultiLineText(
    "multi-line edit", "Please enter a text", "current text");
script.log(result);
1
2
3

# ├ťberpr├╝fen, ob eine Datei vorhanden ist

# Methodenaufruf und Parameter

/**
 * ├ťberpr├╝ft, ob eine Datei vorhanden ist
 * @param filePath
 * @return
 */
bool ScriptingService::fileExists(QString &filePath);
1
2
3
4
5
6

# Beispiel

var result = script.fileExists(filePath);
script.log(result);
1
2

# Text aus einer Datei lesen

# Method call and parameters

/**
 * Liest Text aus einer Datei
 *
 * @param filePath {QString} Pfad der zu ladenden Datei
 * @param codec {QString} Dateikodierung (Standard: UTF-8)
 * @return die Dateidaten oder null, wenn die Datei nicht existiert
 */
QString ScriptingService::readFromFile(const QString &filePath, const QString &codec)
1
2
3
4
5
6
7
8

# Example

if(script.fileExists(filePath)){
    var data = script.readFromFile(filePath);
    script.log(data);
}
1
2
3
4

# Text in eine Datei schreiben

# Method call and parameters

/**
 * Schreibt einen Text in eine Datei
 *
 * @param filePath {QString}
 * @param data {QString}
 * @param createParentDirs {bool} optional (Standard: false)
 * @return
 */
bool ScriptingService::writeToFile(const QString &filePath, const QString &data, bool createParentDirs);
1
2
3
4
5
6
7
8
9

# Example

var result = script.writeToFile(filePath, html);
script.log(return);
1
2

Schauen Sie sich dazu das Beispiel auf export-notes-as-one-html.qml (opens new window) an.

# Arbeiten mit Websockets

Sie k├Ânnen QOwnNotes mithilfe von WebSocketServer fernsteuern.

Schauen Sie sich dazu das Beispiel auf websocket-server.qml (opens new window) an. Du kannst den Socket Server testen, indem du dich mit Websocket test (opens new window) mit ihm verbindest.

Sie k├Ânnen Sockets auch mit WebSocket abh├Âren. Bitte schauen Sie sich das Beispiel auf websocket-client.qml (opens new window) an.

Beachten Sie, dass Sie die QML Websocket-Bibliothek von Qt installiert haben m├╝ssen, um dies zu verwenden. Unter Ubuntu Linux k├Ânnen Sie beispielsweise qml-module-qtwebsockets installieren.

# Hinzuf├╝gen einer Hervorhebungsregel f├╝r den Editor

Sie k├Ânnen Hervorhebungsregeln direkt in den Editor einf├╝gen, indem Sie regul├Ąre Ausdr├╝cke definieren und ihnen einen Hervorhebungszustand zuweisen.

# Method call and parameters

/**
 * F├╝gt dem Syntax-Highlighter des Editors eine Hervorhebungsregel hinzu
 *
 * @param pattern {QString} das hervorzuhebende regul├Ąre Ausdrucksmuster
 * @param shouldContain {QString} eine Zeichenfolge, die im hervorgehobenen Text enthalten sein muss, damit das Muster analysiert werden kann
 * @param state {int} der Zustand des zu verwendenden Syntax-Highlighters
 * @param capturingGroup {int} die Erfassungsgruppe f├╝r das Muster, das zum Hervorheben verwendet werden soll (Standard: 0)
 * @param maskedGroup {int} die Erfassungsgruppe f├╝r das Muster, das zum Maskieren verwendet werden soll (Standard: 0)
 */
void ScriptingService::addHighlightingRule(const QString &pattern,
                                            const QString &shouldContain,
                                            int state,
                                            int capturingGroup,
                                            int maskedGroup);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Hervorhebungsarten

Name Nr.
NoState -1
Link 0
Bild 3
CodeBlock 4
CodeBlockComment 5
Kursiv 7
Fett 8
Liste 9
Kommentar 11
H1 12
H2 13
H3 14
H4 15
H5 16
H6 17
BlockQuote 18
HorizontalRuler 21
Tabelle 22
InlineCodeBlock 23
MaskedSyntax 24
CurrentLineBackgroundColor 25
BrokenLink 26
FrontmatterBlock 27
TrailingSpace 28
CheckBoxUnChecked 29
CheckBoxChecked 30
StUnderline 31

# Example

// Hervorheben einer Textzeile wie "BLOCK: irgendein Text" als Blockzitat (Zustand 18)
script.addHighlightingRule("^BLOCK: (.+)", "BLOCK:", 18);

// Maskiere (Zustand 24) alle Zeichen nach 32 Zeichen in einer Zeile
// capturingGroup 1 bedeutet, dass der Ausdruck aus dem ersten eingeklammerten Teil des Musters hervorgehoben wird
// maskedGroup -1 bedeutet, dass keine Maskierung erfolgen soll
script.addHighlightingRule("^.{32}(.+)", "", 24, 1, -1);
1
2
3
4
5
6
7

Schauen Sie sich dazu auch die Beispiele auf highlighting.qml (opens new window) an.