# 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"]);

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");

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();

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();

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

# 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");

# 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");

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)}");

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");

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");

# Die Notizvorschau erneuern

Aktualisiert die Notizvorschau.

# Methodenaufruf und Parameter

/**
 * Erzeugt die Notizvorschau neu
 */
QString ScriptingService::regenerateNotePreview();

1
2
3
4

# Beispiel

script.regenerateNotePreview();

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");

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. Lesen Sie hier weiter, was alles unterstützt wird: URL-Unterstützung (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");

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();

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();

# 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();

# 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());

# 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());

# 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());

# 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.

# 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

// you have to define your registered variables so you can access them later
property string myString;
property string myStringSecret;
property bool myBoolean;
property string myText;
property int myInt;
property string myFile;
property string myDirectory;
property string mySelection;

// register your settings variables so the user can set them in the script settings
//
// unfortunately there is no QVariantHash in Qt, we only can use
// QVariantMap (that has no arbitrary ordering) or QVariantList (which at
// least can be ordered arbitrarily)
property variant settingsVariables: [
    {
        "identifier": "myString",
        "name": "I am a line edit",
        "description": "Please enter a valid string:",
        "type": "string",
        "default": "My default value",
    },
    {
        "identifier": "myStringSecret",
        "name": "I am a password field",
        "description": "Please enter a valid string:",
        "type": "string-secret",
    },
    {
        "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
68
69
70
71
72
73
74

In addition, you can override the settingsVariables with a special function registerSettingsVariables() like this:

# 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

/**
 * Stores a persistent variable
 * These variables are accessible globally over all scripts
 * Please use a meaningful prefix in your key like "PersistentVariablesTest/myVar"
 *
 * @param key {QString}
 * @param value {QVariant}
 */
void ScriptingService::setPersistentVariable(const QString &key,
                                             const QVariant &value);

/**
 * Loads a persistent variable
 * These variables are accessible globally over all scripts
 *
 * @param key {QString}
 * @param defaultValue {QVariant} return value if the setting doesn't exist (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
21

# 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

/**
 * Loads an application settings variable
 *
 * @param key {QString}
 * @param defaultValue {QVariant} return value if the setting doesn't exist (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"));

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

# Opening a dialog to show the differences between two texts

# Methodenaufruf und Parameter

/**
* Opens a dialog to show the differences between two texts and lets the user edit the result
*
* @param title {QString} title of the dialog
* @param label {QString} label text of the dialog
* @param text1 {QString} first text
* @param text2 {QString} second text
* @return
  */
  QString ScriptingService::textDiffDialog(const QString &title, const QString &label,
                                           const QString &text1, const QString &text2);

1
2
3
4
5
6
7
8
9
10
11

text2 is the text you will be able to edit in the dialog. An empty string will be returned, if Cancel was clicked or Escape was pressed.

# Beispiel

const text = script.noteTextEditSelectedText();
const aiPrompt = "Translate the text to English";
const aiResult = script.aiComplete(aiPrompt + ":\n\n" + text);

var result = script.textDiffDialog("AI Text Tool", "Resulting text", text, aiResult);
script.log(result);

1
2
3
4
5
6

# Überprüfen, ob eine Datei vorhanden ist

# Method call and parameters

/**
 * Überprüft, ob eine Datei vorhanden ist
 * @param filePath
 * @return
 */
bool ScriptingService::fileExists(QString &filePath);

1
2
3
4
5
6

# Example

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.

← QOwnNotes Scripting Hooks →

Crafted by Patrizio Bekerle with ❤️

# Methoden und Objekte, die QOwnNotes bereitstellt

# Starten eines externen Programms im Hintergrund

# Methodenaufruf und Parameter

# Beispiel

# Ein externes Programm starten und auf eine Ausgabe warten

# Methodenaufruf und Parameter

# Beispiel

# Abrufen des Pfads des aktuellen Notizordners

# Methodenaufruf und Parameter

# Beispiel

# Abrufen der aktuellen Notiz

# Methodenaufruf und Parameter

# Beispiel

# Protokollierung auf das Protokoll-Widget

# Methodenaufruf und Parameter

# Beispiel

# Herunterladen einer URL in eine Zeichenfolge

# Methodenaufruf und Parameter

# Beispiel

# Herunterladen einer URL in den Medienordner

# Methodenaufruf und Parameter

# Beispiel

# Einfügen einer Mediendatei in den Medienordner

# Methodenaufruf und Parameter

# Beispiel

# Einfügen einer Anhangsdatei in den Anhangsordner

# Methodenaufruf und Parameter

# Beispiel

# Die Notizvorschau erneuern

# Methodenaufruf und Parameter

# Beispiel

# Registrieren einer benutzerdefinierten Aktion

# Methodenaufruf und Parameter

# Beispiel

# Ein Label registrieren

# Methodenaufruf und Parameter

# Beispiel

# Festlegen des Textes eines registrierten Labels

# Methodenaufruf und Parameter

# Beispiel

# Neue Notiz erstellen

# Methodenaufruf und Parameter

# Beispiel

# Zugriff auf die Zwischenablage

# Methodenaufruf und Parameter

# Beispiel

# Text in das Notizbearbeitungsfeld schreiben

# Methodenaufruf und Parameter

# Beispiel

# Den ausgewählten Text in der Notizbearbeitung lesen

# Methodenaufruf und Parameter

# Beispiel

# Den gesamten Text in der Notiztextbearbeitung auswählen

# Methodenaufruf und Parameter

# Beispiel

# Wählen Sie die aktuelle Zeile in der Notiztextbearbeitung aus

# Methodenaufruf und Parameter

# Beispiel

# Das aktuelle Wort in der Notiztextbearbeitung auswählen

# Methodenaufruf und Parameter

# Beispiel

# Den aktuell ausgewählten Text in der Notiztextbearbeitung festlegen

# Methodenaufruf und Parameter

# Beispiel

# Die Startposition der aktuellen Auswahl in der Notiztextbearbeitung erhalten

# Methodenaufruf und Parameter

# Beispiel

# Die Endposition der aktuellen Auswahl in der Notiztextbearbeitung erhalten

# Methodenaufruf und Parameter

# Beispiel

# Den Textcursor in der Notiztextbearbeitung auf eine bestimmte Position setzen

# Methodenaufruf und Parameter

# Beispiel

# Die aktuelle Position des Textcursors in der Notiztextbearbeitung abrufen

# Methodenaufruf und Parameter

# Beispiel

# Das aktuelle Wort aus der Notiztextbearbeitung lesen

# Methodenaufruf und Parameter

# Beispiel

# Read the current block from the note text edit