# Methoden und Objekte, die QOwnNotes bereitstellt

# Starten eines externen Programms im Hintergrund

# Methodenaufruf und Parameter

/**
     * QML-Wrapper zum Starten eines getrennten Prozesses
     *
     * @param executeablePath der Pfad der ausführbaren Datei
     * @param parameters eine Liste von Parameterzeichenfolgen
     * @param callbackIdentifier Ein Bezeichner, der in der Funktion onDetachedProcessCallback () verwendet werden soll (optional).
     * @param callbackParameter ein zusätzlicher Parameter für Schleifen oder ähnliches (optional)
     * @param processData-Daten, die in den Prozess geschrieben werden, wenn der Rückruf verwendet wird (optional)
     * @return true bei Erfolg, andernfalls false
     */
bool startDetachedProcess (QString ausführbarer Pfad, QStringList-Parameter,
                             QString callbackIdentifier, QVariant callbackParameter,
                             QByteArray processData);
1
2
3
4
5
6
7
8
9
10
11
12
13

# 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

Vielleicht möchten Sie sich das Beispiel ansehen: custom-actions.qml (opens new window), callback.qml (opens new window) oder: execute-command-after-note-update.qml (opens new window).

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

TIP

Sie können Ihren benutzerdefinierten Aktionen auch lokale und globale Verknüpfungen in den Verknüpfungseinstellungen zuweisen.

# Starten Sie ein externes Programm und warten Sie auf die Ausgabe

# Methodenaufruf und Parameter

/**
  * QML-Wrapper zum Starten eines synchronen Prozesses
  *
  * @param executeablePath - der Pfad der ausführbaren Datei
  * @param parameters - eine Liste von Parameterzeichenfolgen
  * @param data - die Daten, die in den Prozess geschrieben werden (optional)
  * @return - den Text, der vom Prozess zurückgegeben wurde
QByteArray startSynchronousProcess (QString ausführbarer Pfad, QStringList-Parameter, QByteArray-Daten);
1
2
3
4
5
6
7
8

# Beispiel

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

Vielleicht möchten Sie sich das Beispiel ansehen encryption-keybase.qml (opens new window).

# Abrufen des Pfads des aktuellen Notizordners

# Methodenaufruf und Parameter

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

# Beispiel

var path = script.currentNoteFolderPath();
1

Vielleicht möchten Sie sich das Beispiel absolute-media-links.qml (opens new window) ansehen.

# Abrufen der aktuellen Notiz

# Methodenaufruf und Parameter

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

# Beispiel

var note = script.currentNote();
1

Vielleicht möchten Sie sich das Beispiel ansehen custom-actions.qml (opens new window).

# Protokollierung beim Protokoll-Widget

# Methodenaufruf und Parameter

/**
     * QML-Wrapper zum Protokollieren im Protokoll-Widget
     *
     * @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 zum Herunterladen einer URL und zum Zurückgeben als Text
  *
  * @param url
  * @return {QString} den 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

Vielleicht möchten Sie sich das Beispiel ansehen: insert-headline-with-link-from-github-url.qml (opens new window).

# Herunterladen einer URL in den Medienordner

# Methodenaufruf und Parameter

/**
     * QML-Wrapper zum Herunterladen einer URL in den Medienordner und zum Zurückgeben des Mediums
     * URL oder der Markdown-Bildtext des Mediums relativ zur aktuellen Notiz
     *
     * @param {QString} URL
     * @param {bool} returnUrlOnly if true, wird nur die Medien-URL zurückgegeben (Standard false).
     * @return {QString} den Medienabschlag oder die 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

Vielleicht möchten Sie sich das Beispiel ansehen paste-latex-image.qml (opens new window).

# Einfügen einer Mediendatei in den Medienordner

# Methodenaufruf und Parameter

/**
 * QML-Wrapper zum Einfügen einer Mediendatei in den Medienordner und zum Zurückgeben
 * die Medien-URL oder der Markdown-Bildtext des Mediums relativ zur aktuellen Notiz
 *
 * @param {QString} mediaFilePath
 * @param {bool} returnUrlOnly wenn true, wird nur die Medien-URL zurückgegeben (Standardwert false)
 * @return {QString} den Medienabschlag oder die 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

Vielleicht möchten Sie sich das Beispiel ansehen scribble.qml (opens new window).

# Die Notizenvorschau erneuern

Aktualisiert die Notizvorschau.

# Methodenaufruf und Parameter

/**
 * Regeneriert die Notenvorschau
 */
QString ScriptingService::regenerateNotePreview ();
1
2
3
4

# Beispiel

script.regenerateNotePreview();
1

Vielleicht möchten Sie sich das Beispiel ansehen scribble.qml (opens new window).

# Registrieren einer benutzerdefinierten Aktion

# Methodenaufruf und Parameter

/**
    * Registriert eine benutzerdefinierte Aktion
    *
    * @param bezeichner der bezeichner der aktion
    * @param menuText den im Menü angezeigten Text
    * @param buttonText den in der Schaltfläche angezeigten Text
    *               (keine Schaltfläche wird angezeigt, wenn leer)
    * @param icon Der Pfad der Symboldatei oder der Name eines Freedesktop-Themensymbols
    * Eine Liste der Symbole finden Sie hier:
    * https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
    * @param useInNoteEditContextMenu Wenn true, verwenden Sie die Aktion in der Notizbearbeitung
    *                Kontextmenü (Standard: false)
    * @param hideButtonInToolbar Wenn true, wird die Schaltfläche nicht in der angezeigt
    *                Symbolleiste für benutzerdefinierte Aktionen (Standard: false)
    * @param useInNoteListContextMenu Wenn true, verwenden Sie die Aktion in der Notizliste
    *                Kontextmenü (Standard: false)
    */
void ScriptingService::registerCustomAction (QString-ID,
                                            QString menuText,
                                            QString buttonText,
                                            QString-Symbol,
                                            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

# Beispiel

// eine benutzerdefinierte Aktion ohne Schaltfläche hinzufügen
script.registerCustomAction ("mycustomaction1", "Menütext");

// eine benutzerdefinierte Aktion mit einer Schaltfläche hinzufügen
script.registerCustomAction ("mycustomaction1", "Menu text", "Button text");

// füge eine benutzerdefinierte Aktion mit einer Schaltfläche und einem Freedesktop-Themensymbol hinzu
script.registerCustomAction ("mycustomaction1", "Menu text", "Button text", "task-new");

// eine benutzerdefinierte Aktion mit einer Schaltfläche und einem Symbol aus einer Datei hinzufügen
script.registerCustomAction ("mycustomaction1", "Menu text", "Button text", "/usr/share/icons/breeze/actions/24/view-calendar-tasks.svg");
1
2
3
4
5
6
7
8
9
10
11

Möglicherweise möchten Sie dann den Bezeichner mit Funktion verwenden customActionInvoked in einem Skript wie custom-action.qml (opens new window).

# Ein Label registrieren

# Methodenaufruf und Parameter

/**
     * Registriert ein Etikett, auf das geschrieben werden soll
     *
     * @param bezeichner der bezeichner des etiketts
     * @param text der auf dem Etikett angezeigte Text (optional)
     */
void ScriptingService :: registerLabel (QString-ID, 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", "another very long text, another very long text, another very long text, another very long text, another very long text, another very long text, another very long text, another very long text, another very long text, another very long text, another very long text that will wrap");

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

Die Beschriftungen werden im Skript-Dock-Widget angezeigt.

Sie können sowohl einfachen Text als auch HTML in den Beschriftungen verwenden. Der Text kann ausgewählt werden und Links können angeklickt werden.

Vielleicht möchten Sie sich dann das Beispielskript ansehen scripting-label-demo.qml (opens new window).

# Einstellen des Textes eines registrierten Etiketts

# Methodenaufruf und Parameter

/**
     * Legt den Text eines registrierten Etiketts fest
     *
     * @param bezeichner der bezeichner des etiketts
     * @param text der auf dem Etikett angezeigte Text
     */
void ScriptingService::setLabelText (QString-ID, 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 Beschriftungen verwenden. Der Text kann ausgewählt werden und Links können angeklickt werden.

Vielleicht möchten Sie sich dann das Beispielskript ansehen scripting-label-demo.qml (opens new window).

# Neue Notiz erstellen

# Methodenaufruf und Parameter

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

# Beispiel

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

Vielleicht möchten Sie sich das Beispiel ansehen custom-actions.qml (opens new window).

# 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

Vielleicht möchten Sie sich das Beispiel ansehen custom-actions.qml (opens new window).

# Schreiben Sie Text in die Notiztextbearbeitung

# 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 ("Mein benutzerdefinierter Text");
1
2

Möglicherweise möchten Sie die benutzerdefinierte Aktion transformTextRot13 im Beispiel custom-actions.qml (opens new window) anzeigen.

Sie können dies zusammen mit noteTextEditSelectAll verwenden, um den gesamten Text der aktuellen Notiz zu überschreiben.

# Lesen Sie den ausgewählten Text in der Notiztextbearbeitung

# 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

Möglicherweise möchten Sie die benutzerdefinierte Aktion transformTextRot13 im Beispiel anzeigen custom-actions.qml (opens new window).

# Wählen Sie den gesamten Text in der Notiztextbearbeitung aus

# 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

# Wählen Sie das aktuelle Wort in der Notiztextbearbeitung aus

# Methodenaufruf und Parameter

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

# Beispiel

script.noteTextEditSelectCurrentWord();
1

# Stellen Sie den aktuell ausgewählten Text in der Notiztextbearbeitung ein

# Methodenaufruf und Parameter

/**
 * Legt den aktuell ausgewählten 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

# Holen Sie sich die Startposition der aktuellen Auswahl in der Notiztextbearbeitung

# 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

# Holen Sie sich die Endposition der aktuellen Auswahl in der Notiztextbearbeitung

# 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

# Setzen Sie den Textcursor in der Notiztextbearbeitung auf eine bestimmte Position

# 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

# Ruft die aktuelle Position des Textcursors in der Notiztextbearbeitung ab

# 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

# Lesen Sie das aktuelle Wort aus der Notiztextbearbeitung

# Methodenaufruf und Parameter

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

# Beispiel

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

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

# Prüfen Sie, 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

# Verschlagworten Sie die aktuelle Notiz

# Methodenaufruf und Parameter

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

# Beispiel

// füge der aktuellen Notiz ein "Favorit" -Tag hinzu
script.tagCurrentNote("favorite");
1
2

Vielleicht möchten Sie sich die benutzerdefinierte Aktion favoriteNote in der Beispiel favorite-note.qml (opens new window).

# Erstellen oder holen Sie ein Tag anhand seiner Namens-Breadcrumb-Liste

# Methodenaufruf und Parameter

/**
     * Ruft ein Tag anhand seiner "Breadcrumb-Liste" von Tag-Namen ab oder erstellt es
     * Element nameList[0] wäre im Baum am höchsten (mit parentId: 0)
     *
     * @param nameList
     * @param createMissing {bool} Wenn true (Standard), werden alle fehlenden Tags erstellt
     * @return TagApi-Objekt des tiefsten Tags der Breadcrumb-Liste
     */
TagApi * ScriptingService :: getTagByNameBreadcrumbList (
     const QStringList &nameList, bool createMissing);
1
2
3
4
5
6
7
8
9
10

# Beispiel

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

# Suche nach Tags nach Namen

# Methodenaufruf und Parameter

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

# Beispiel

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

Vielleicht möchten Sie sich das Beispiel ansehen autocompletion.qml (opens new window).

# Suchen Sie nach Notizen gemäß Notiztext

# 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
     * kann nur die Noten-IDs übertragen
     *
     * @return {QList<int>} Liste der Noten-IDs
     */
QList<int> ScriptingService::fetchNoteIdsByNoteTextPart (QString-Text);
1
2
3
4
5
6
7
8
9

# Beispiel

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

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

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

Vielleicht möchten Sie sich das Beispiel ansehen unique-note-id.qml (opens new window).

# Fügen Sie ein benutzerdefiniertes Stylesheet hinzu

# 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

// mache den Text in der Notizliste größer
script.addStyleSheet ("QTreeWidget # noteTreeWidget {Schriftgröße: 30px;}");
1
2

Vielleicht möchten Sie sich das Beispiel ansehen custom-stylesheet.qml (opens new window).

Sie können die Objektnamen aus den Dateien *.ui abrufen, z.B. mainwindow.ui (opens new window).

Schauen Sie sich das Style Sheet Reference (opens new window) für eine Referenz hinsichtlich verfügbarer Stile.

Wenn Sie Stile in die HTML-Vorschau einfügen möchten, um die Vorschau von Notizen zu ändern, lesen Sie bitte notetomarkdownhtmlhook.

# Skript-Engine neu laden

# Methodenaufruf und Parameter

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

# Beispiel

// Laden Sie 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 Dateiname der Notiz (obligatorisch)
     * @param noteSubFolderId Ganzzahl-ID des Notiz-Unterordners
     * @return NoteApi *
     */
NoteApi * ScriptingService::fetchNoteByFileName (QString fileName,
                                                 int noteSubFolderId);
1
2
3
4
5
6
7
8
9

# Beispiel

// Notiz nach Dateiname holen
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 mit ID abrufen
1

Vielleicht möchten Sie sich das Beispiel ansehen export-notes-as-one-html.qml (opens new window).

# Überprüfen Sie anhand des Dateinamens, 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 Ganzzahl-ID einer Notiz, die bei der Prüfung ignoriert werden soll
     * @param noteSubFolderId Ganzzahl-ID des Notiz-Unterordners
     * @return bool
     */
bool ScriptingService::noteExistsByFileName (QString-Dateiname,
                                             int ignoreNoteId,
                                             int noteSubFolderId);
1
2
3
4
5
6
7
8
9
10
11

# Beispiel

// check if note exists, but ignore the id of "note"
script.noteExistsByFileName("my note.md", note.id);
1
2

You may want to take a look at the example

# Kopieren von Text in die Zwischenablage

# Methodenaufruf und Parameter

/**
     * Kopiert Text als Nur-Text- 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

// copy text to the clipboard
script.setClipboardText("text to copy");
1
2

Vielleicht möchten Sie sich das Beispiel ansehen selected-markdown-to-bbcode.qml (opens new window).

# Zu einer Notiz springen

# Methodenaufruf und Parameter

/**
    * Legt die aktuelle Notiz fest, wenn die Notiz in der Notizliste sichtbar ist
    *
    * @param note NoteApi note to jump to
    */
void ScriptingService::setCurrentNote(NoteApi *note);
1
2
3
4
5
6

# Beispiel

// jump to the note
script.setCurrentNote(note);
1
2

Vielleicht möchten Sie sich das Beispiel ansehen

# 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 / Unter");
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-Titel);
1
2
3
4
5
6
7

# Beispiel

// ein Informationsmeldungsfeld anzeigen
script.informationMessageBox ("Der Text, den ich anzeigen möchte", "Einige optionale Titel");
1
2

# Anzeigen eines Fragenmeldungsfelds

# Methodenaufruf und Parameter

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

# Beispiel

// ein Frage-Meldungsfeld mit einer Schaltfläche zum Anwenden und einer Hilfe anzeigen
// siehe: https://doc.qt.io/qt-5/qmessagebox.html#StandardButton-enum
var result = script.questionMessageBox (
     "Der Text, den ich anzeigen möchte", "Einige optionale Titel", 0x01000000 | 0x02000000, 0x02000000);
script.log (Ergebnis);
1
2
3
4
5

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

Vielleicht möchten Sie sich auch das Beispiel ansehen input-dialogs.qml (opens new window).

# Anzeigen eines geöffneten Dateidialogs

# 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-Beschriftung, QString-Verzeichnis,
                                             QString-Filter);
1
2
3
4
5
6
7
8
9
10

# Beispiel

// zeige einen geöffneten Dateidialog
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-Beschriftung, QString-Verzeichnis,
                                             QString-Filter);
1
2
3
4
5
6
7
8
9
10

# Beispiel

// zeige einen Dialog zum Speichern von Dateien
var fileName = script.getSaveFileName ("Bitte wählen Sie die zu speichernde HTML-Datei aus", "output.html", "HTML (*.html)");
1
2

Vielleicht möchten Sie sich das Beispiel ansehen export-notes-as-one-html.qml (opens new window).

# 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 registrierten Variablen definieren, damit Sie später darauf zugreifen können
Eigenschaftszeichenfolge myString;
Eigenschaft bool myBoolean;
Eigenschaftszeichenfolge myText;
property int myInt;
Eigenschaftszeichenfolge myFile;
Eigenschaftszeichenfolge mySelection;

// Registrieren Sie Ihre Einstellungsvariablen, damit der Benutzer sie in den Skripteinstellungen festlegen kann
// benutze diese Eigenschaft, wenn du sie nicht brauchst
// //
// Leider gibt es kein QVariantHash in Qt, wir können es nur verwenden
// QVariantMap (das hat keine willkürliche Reihenfolge) oder QVariantList (die bei
// am wenigsten kann beliebig bestellt werden)
EigenschaftenvarianteneinstellungenVariablen: [
    {
        "bezeichner": "myString",
        "name": "Ich bin ein Zeilenbearbeiter",
        "description": "Bitte geben Sie eine gültige Zeichenfolge ein:",
        "type": "string",
        "default": "Mein Standardwert",
    },
    {
        "bezeichner": "myBoolean",
        "name": "Ich bin ein Kontrollkästchen",
        "description": "Some description",
        "text": "Aktivieren Sie dieses Kontrollkästchen",
        "type": "boolean",
        "default": true,
    },
    {
        "bezeichner": "myText",
        "name": "Ich bin ein Textfeld",
        "description": "Bitte geben Sie Ihren Text ein:",
        "Text eingeben",
        "default": "Dies kann ein sehr langer Text mit mehreren Zeilen sein.",
    },
    {
        "bezeichner": "myInt",
        "name": "Ich bin ein Nummernwähler",
        "description": "Bitte geben Sie eine Nummer ein:",
        "Typ": "Ganzzahl",
        "Standard": 42,
    },
    {
        "bezeichner": "myFile",
        "name": "Ich bin ein Datei-Selektor",
        "description": "Bitte wählen Sie die Datei aus:",
        "Typ": "Datei",
        "default": "pandoc",
    },
    {
        "bezeichner": "mySelection",
        "name": "Ich bin ein Artikelwähler",
        "description": "Bitte wählen Sie einen Artikel aus:",
        "Typ": "Auswahl",
        "default": "option2",
        "items": {"option1": "Text für Option 1", "option2": "Text für Option 2", "option3": "Text für 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

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. Einstellungen
  * Standardwerte abhängig vom Betriebssystem.
 * /
Funktion registerSettingsVariables () {
     if (script.platformIsWindows ()) {
         // überschreibe den myFile Standardwert
         settingsVariables [3] .default = "pandoc.exe"
     }}
}}
1
2
3
4
5
6
7
8
9
10
11
12

Vielleicht möchten Sie sich auch das Beispiel ansehen variables.qml (opens new window).

# Speichern und Laden persistenter Variablen

# Methodenaufruf und Parameter

/**
     * Speichert eine persistente Variable
     * Auf diese Variablen kann global über alle Skripte zugegriffen werden
     * Bitte verwenden Sie in Ihrem Schlüssel ein aussagekräftiges Präfix wie "PersistentVariablesTest / myVar".
     * *
     * @param key {QString}
     * @param value {QVariant}
     */
void ScriptingService :: setPersistentVariable (const QString & amp;key,
                                                 const QVariant &value);

/**
 * Lädt eine persistente Variable
 * Auf diese Variablen kann global über alle Skripte zugegriffen werden
 *
 * @param key {QString}
 * @param defaultValue {QVariant} Rückgabewert, wenn die Einstellung nicht vorhanden ist (optional)
 * @Rückkehr
 */
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

// store persistent variable
script.setPersistentVariable("PersistentVariablesTest/myVar", result);

// load and log persistent variable
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.

Sie können sich auch das Beispiel persistent-variables.qml (opens new window) ansehen.

# 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)
     * @Rückkehr
     */
QVariant ScriptingService::getApplicationSettingsVariable (const QString &key,
                                                             const QVariant &defaultValue);
1
2
3
4
5
6
7
8
9

# Beispiel

// load and log an application settings variable
script.log(script.getApplicationSettingsVariable("gitExecutablePath"));
1
2

Denken Sie daran, dass die Einstellungen tatsächlich leer sein können. Sie sorgen sich darum selbst. 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} den Cache-Verzeichnispfad
 */
QString ScriptingService::cacheDir (const QString & subDir) const;
1
2
3
4
5
6
7

# Beispiel

// create the cache directory for my-script-id
var cacheDirForScript = script.cacheDir("my-script-id");
1
2

# Löschen eines Cache-Verzeichnisses

Sie können die Cache-Dateien Ihres Skripts löschen, indem Sie den Namen an clearCacheDir () übergeben.

# Methodenaufruf und Parameter

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

# Beispiel

// clear cache directory of my-script-id 
script.clearCacheDir("my-script-id");
1
2

# Lesen Sie den Pfad zum Verzeichnis Ihres Skripts

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 -Eigenschaftszeichenfolge scriptDirPath; registrieren. Diese Eigenschaft wird mit dem Pfad zum Verzeichnis des Skripts festgelegt.

# Beispiel

import QtQml 2.0
import QOwnNotesTypes 1.0

Script {
    // the path to the script's directory will be set here
    property string scriptDirPath;

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

# Konvertieren von Pfadtrennzeichen in native

# Methodenaufruf und Parameter

/**
  * Gibt den Pfad mit den '/' Trennzeichen zurück, die in Trennzeichen konvertiert wurden
  * passend für das zugrunde liegende Betriebssystem.
 *
     * Unter Windows wird toNativeDirSeparators ("c: / winnt / system32") zurückgegeben
 * "c:\winnt\system32".
 *
 * @param path
 * @return
 */
QString ScriptingService::toNativeDirSeparators(QString path);
1
2
3
4
5
6
7
8
9
10
11

# Beispiel

// will return "c:\winnt\system32" on Windows
script.log(script.toNativeDirSeparators("c:/winnt/system32"));
1
2

# Konvertieren von Pfadtrennzeichen von nativen

# Methodenaufruf und Parameter

/**
 * Gibt den Pfad mit '/' als Dateitrennzeichen zurück.
 * Unter Windows beispielsweise fromNativeDirSeparators("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

# Beispiel

// will return "c:/winnt/system32" on Windows
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
     *
     * @Rückkehr
     */
QString ScriptingService::dirSeparator ();
1
2
3
4
5
6

# Beispiel

// will return "\" on Windows
script.log(script.dirSeparator());
1
2

# Abrufen einer Liste der Pfade aller ausgewählten Noten

# Methodenaufruf und Parameter

/**
     * Gibt eine Liste der Pfade aller ausgewählten Noten zurück
     *
     * @return {QStringList} Liste der ausgewählten Notenpfade
     */
QStringList ScriptingService :: selectedNotesPaths ();
1
2
3
4
5
6

# Beispiel

// gibt eine Liste der Pfade aller ausgewählten Noten zurück
script.log (script.selectedNotesPaths ());
1
2

Vielleicht möchten Sie sich das Beispiel ansehen external-note-diff.qml (opens new window).

# Abrufen einer Liste der IDs aller ausgewählten Notizen

# Methodenaufruf und Parameter

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

# Beispiel

// gibt eine Liste der IDs aller ausgewählten Noten zurück
script.log (script.selectedNotesIds ());
1
2

Vielleicht möchten Sie sich das Beispiel ansehen export-notes-as-one-html.qml (opens new window).

# 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 Status check aktiviert ist
     * anders als dieser Parameter (optional, kann 0 oder 1 sein)
     */
void ScriptingService::triggerMenuAction (QString objectName, QString geprüft);
1
2
3
4
5
6
7
8

# Beispiel

// toggle the read-only mode
script.triggerMenuAction("actionAllow_note_editing");

// disable the read-only mode
script.triggerMenuAction("actionAllow_note_editing", 1);
1
2
3
4
5

Vielleicht möchten Sie sich das Beispiel ansehen disable-readonly-mode.qml (opens new window).

Sie können die Objektnamen der Menüaktion von abrufen mainwindow.ui (opens new window).

# Ö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 aktueller {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 editierbar);
1
2
3
4
5
6
7
8
9
10
11
12
13

# Beispiel

var result = script.inputDialogGetItem(
    "combo box", "Please select an item", ["Item 1", "Item 2", "Item 3"]);
script.log(result);
1
2
3

Vielleicht möchten Sie sich das Beispiel ansehen input-dialogs.qml (opens new window).

# Ö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)
     * @Rückkehr
     * /
QString ScriptingService::inputDialogGetText(
        const QString &title, const QString &label, const QString &text);
1
2
3
4
5
6
7
8
9
10

# Beispiel

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

# Überprüfen, ob eine Datei vorhanden ist

# Methodenaufruf und Parameter

/**
     * Überprüfen Sie, 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

# Methodenaufruf und Parameter

/**
 * Lesen Sie 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

# Beispiel

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

# Text in eine Datei schreiben

# Methodenaufruf und Parameter

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

# Beispiel

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

Vielleicht möchten Sie sich das Beispiel ansehen export-notes-as-one-html.qml (opens new window).

# Arbeiten mit Websockets

Sie können QOwnNotes mithilfe von WebSocketServer fernsteuern.

Bitte schauen Sie sich das Beispiel an: websocket-server.qml (opens new window). Du kannst die Socket Server Verbindung testen indem du dich mit Websocket test (opens new window) zu ihr verbindest.

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

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.