# Methoden und Objekte, die QOwnNotes bereitstellt

# Starten eines externen Programms im Hintergrund

# Methodenaufruf und Parameter

/**
 * QML wrapper to start a detached process
 *
 * @param executablePath der Pfad der ausf├╝hrbaren Datei
 * @param parameters eine Liste von Parameterstrings
 * @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 data in den Prozess geschrieben, wenn der Callback verwendet wird (optional)
 * @param workingDirectory das Arbeitsverzeichnis, in dem der Prozess ausgef├╝hrt werden soll (optional, funktioniert nur ohne Callback)
 * @return true bei Erfolg, sonst false
 */
bool startDetachedProcess(QString executablePath, QStringList parameters,
                            QString callbackIdentifier, QVariant callbackParameter,
                            QByteArray processData, QString workingDirectory);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Beispiel

Einfaches Beispiel:

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

Viele Prozesse ausf├╝hren:

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

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

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.

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

# Methodenaufruf und Parameter

/**
 * QML wrapper to start a synchronous process
 *
 * @param executablePath the path of the executable
 * @param parameters a list of parameter strings
 * @param data the data that will be written to the process (optional)
 * @param workingDirectory the working directory to execute the process in (optional)
 * @return the text that was returned by the process
QByteArray startSynchronousProcess(QString executablePath, QStringList parameters, QByteArray data, QString workingDirectory);
1
2
3
4
5
6
7
8
9

# Beispiel

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

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

# 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} AnhangFilePath
  * @param {QString} Dateiname f├╝r den Markdown
  * @param {bool} returnUrlOnly - Nur wenn true wird nur die Anhangs-URL zur├╝ckgegeben
  * (Standardwert falsch)
  * @return {QString} das Markdown oder die URL des Anhangs
  */
QString ScriptingService::insertAttachmentFile(const QString &attachmentFilePath,
                                                const QString &fileName,
                                                bool returnUrlOnly);
1
2
3
4
5
6
7
8
9
10
11
12
13

# Beispiel

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

# Die Notizenvorschau erneuern

Aktualisiert die Notizvorschau.

# Methodenaufruf und Parameter

/**
 * Erzeugt die Notizvorschau neu
 */
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

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 Symbol 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 Symbol festzulegen, k├Ânnen Sie die scriptDirPath property verwenden.

# Beispiel

import QtQml 2.0
import QOwnNotesTypes 1.0

Script {
    /**
     * Initializes the custom actions
     */
    function init() {
        // add a custom action without a button
        script.registerCustomAction("mycustomaction1", "Menu text");

        // add a custom action with a button
        script.registerCustomAction("mycustomaction2", "Menu text", "Button text");

        // add a custom action with a button and freedesktop theme icon
        script.registerCustomAction("mycustomaction3", "Menu text", "Button text", "task-new");

        // add a custom action with a button and an icon from a file
        script.registerCustomAction("mycustomaction4", "Menu text", "Button text", "/usr/share/icons/breeze/actions/24/view-calendar-tasks.svg");
    }

    /**
     * This function is invoked when a custom action is triggered
     * in the menu or via button
     * 
     * @param identifier string the identifier defined in registerCustomAction
     */
    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 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", "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 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 identifier the identifier of the label
 * @param text the text shown in the label
 */
void ScriptingService::setLabelText(QString identifier, QString text);
1
2
3
4
5
6
7

# Beispiel

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

Sie k├Ânnen sowohl einfachen Text als auch HTML in den 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).

TIP

Wenn Sie deaktiviert haben, dass Ihre Notiz├╝berschrift den Dateinamen der Notiz bestimmt, m├╝ssen Sie Ihre Notizdatei anschlie├čend selbst wie folgt 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

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

# Schreiben Sie Text in die Notiztext-Bearbeitung

# 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

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

Vielleicht m├Âchten Sie die benutzerdefinierte Aktion transformTextRot13 im Beispiel custom-actions.qml (opens new window) anzeigen.

# 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 das aktuelle Wort 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

/**
 * Sets the currently selected text in the note text edit
 *
 * @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

Vielleicht m├Âchten Sie sich das Beispiel ansehen 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 ausgef├╝hrt, wenn unter Linux
}
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├╝gen Sie der aktuellen Notiz ein "Favorit" -Tag hinzu
script.tagCurrentNote ("Favorit");
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 nach 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 Widget-Namen aus den *.ui-Dateien abrufen, zum Beispiel ist das Hauptfenster 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

Die style.qss (opens new window) von qdarkstyle (opens new window) kann auch eine gute Referenz f├╝r Stile sein, 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

// reload the scripting engine
script.reloadScriptingEngine();
1
2

# Abrufen einer Notiz anhand ihres Dateinamens

# Methodenaufruf und Parameter

/**
  * Ruft eine Notiz anhand ihres Dateinamens ab
 *
 * @param fileName string the file name of the note (mandatory)
 * @param noteSubFolderId integer id of the note subfolder
 * @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

// fetch note by id
script.fetchNoteById(243);
1
2

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

// pr├╝fe ob eine Notiz existiert, aber ignoriere die ID von "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

// Text in die Zwischenablage kopieren
script.setClipboardText ("zu kopierender Text");
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

// zur Notiz springen
script.setCurrentNote(note);
1
2

Vielleicht m├Âchten Sie sich das Beispiel ansehen journal-entry.qml (opens new window).

# 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("Please select HTML file to save", "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
property string myString;
property bool myBoolean;
property string myText;
property int myInt;
property string myFile;
property string mySelection;

// Registrieren Sie Ihre Einstellungsvariablen, damit der Benutzer sie in den Skripteinstellungen festlegen kann
//
// leider gibt es kein QVariantHash in Qt, wir k├Ânnen es nur verwenden
// QVariantMap (die keine willk├╝rliche Reihenfolge hat) oder QVariantList (die bei
// am wenigsten beliebig bestellbar)
property variant settingsVariables: [
    {
        "identifier": "myString",
        "name": "I am a line edit",
        "description": "Please enter a valid string:",
        "type": "string",
        "default": "My default value",
    },
    {
        "identifier": "myBoolean",
        "name": "I am a checkbox",
        "description": "Some description",
        "text": "Check this checkbox",
        "type": "boolean",
        "default": true,
    },
    {
        "identifier": "myText",
        "name": "I am textbox",
        "description": "Please enter your text:",
        "type": "text",
        "default": "This can be a really long text\nwith multiple lines.",
    },
    {
        "identifier": "myInt",
        "name": "I am a number selector",
        "description": "Please enter a number:",
        "type": "integer",
        "default": 42,
    },
    {
        "identifier": "myFile",
        "name": "I am a file selector",
        "description": "Please select the file:",
        "type": "file",
        "default": "pandoc",
    },
    {
        "identifier": "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

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
  * Diese Variablen sind global ├╝ber alle Skripte zug├Ąnglich
  * Bitte verwenden Sie ein aussagekr├Ąftiges Pr├Ąfix in Ihrem Schl├╝ssel wie "PersistentVariablesTest/myVar"
 *
 * @param key {QString}
 * @param value {QVariant}
 */
void ScriptingService::setPersistentVariable(const QString &key,
                                                const QVariant &value);
/**
  * L├Ądt eine persistente Variable
  * Diese Variablen sind global ├╝ber alle Skripte zug├Ąnglich
 *
 * @param key {QString}
 * @param defaultValue {QVariant} 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

# 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 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} 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 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 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 {
    // 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

# 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

// 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
     *
     * @R├╝ckkehr
     */
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 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).

TIP

Die Objektnamen der Men├╝aktion erhalten Sie von mainwindow.ui (opens new window). 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 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 (
     "Kombinationsfeld", "Bitte w├Ąhlen Sie einen Artikel aus", ["Artikel 1", "Artikel 2", "Artikel 3"]);
script.log (Ergebnis);
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 (Ergebnis);
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.

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

# Methodenaufruf und Parameter

/**
  * 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-Zustand,
                                            int Erfassungsgruppe,
                                            int maskierteGruppe);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Highlighting states

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

# Beispiel

// Hervorheben einer Textzeile wie "BLOCK: irgendein Text" als Blockquote (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

Sie k├Ânnen sich auch die Beispiele in ansehen highlighting.qml (opens new window).