# Módszerek és objektumok, amelyeket a QOwnNotes biztosít

# Külső program indítása a háttérben

# Módszerhívás és paraméterek

/**
 * QML wrapper to start a detached process
 *
 * @param executablePath the path of the executable
 * @param parameters a list of parameter strings
 * @param callbackIdentifier an identifier to be used in the onDetachedProcessCallback() function (optional)
 * @param callbackParameter an additional parameter for loops or the like (optional)
 * @param processData data written to the process if the callback is used (optional)
 * @param workingDirectory the working directory to execute the process in (optional, only works without callback)
 * @return true on success, false otherwise
 */
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

# Példa

Egyszerű példa:

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

Sok folyamat futtatása:

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

Érdemes megnézni a példát custom-actions.qml (opens new window), callback.qml (opens new window) or execute-command-after-note-update.qml (opens new window).

Érdemes egy pillantást vetni az onDetachedProcessCallback kampóra is.

# Indítson egy külső programot, és várja meg a kimenetet

# Módszerhívás és paraméterek

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

# Példa

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

Érdemes megnézni a példát encryption-keybase.qml (opens new window).

# Az aktuális jegyzet mappa elérési útjának lekérése

# Módszerhívás és paraméterek

/**
  * QML-csomagoló az aktuális jegyzetmappa elérési útjának megszerzéséhez
  *
  * @ visszaállítja az aktuális jegyzet mappa elérési útját
  */
QString currentNoteFolderPath();
1
2
3
4
5
6

# Példa

var path = script.currentNoteFolderPath();
1

Érdemes megnézni a példát abszolút-media-links.qml (opens new window).

# Az aktuális jegyzet megszerzése

# Módszerhívás és paraméterek

/**
  * QML-burkoló az aktuális jegyzet lekéréséhez
  *
  * @visszaadja a {NoteApi} aktuális jegyzetobjektumot
  */
NoteApi currentNote();
1
2
3
4
5
6

# Példa

var note = script.currentNote();
1

Érdemes megnéznie az custom-actions.qml (opens new window) példát.

# Naplózás a napló widgetbe

# Módszerhívás és paraméterek

/**
  * QML-csomagoló a napló widgetbe való bejelentkezéshez
  *
  * @param szöveg
  */
void log(QString text);
1
2
3
4
5
6

# Példa

script.log("my text");
1

# URL letöltése egy karakterláncra

# Módszerhívás és paraméterek

/**
  * Wrapper QML pour télécharger une URL et la renvoyer sous forme de texte
  *
  * @param url
  * @return {QString} le contenu de l'url téléchargée
  */
QString downloadUrlToString (QUrl url);
1
2
3
4
5
6
7

# Példa

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

Érdemes megnézni a példát insert-headline-with-link-from-github-url.qml (opens new window).

# URL letöltése a média mappába

# Módszerhívás és paraméterek

/**
  * QML-csomagoló egy URL letöltésére a média mappába és a média visszaküldése
  * URL vagy az adathordozó jelölési képszövege az aktuális jegyzethez képest
  *
  * @param {QString} URL
  * @param {bool} returnUrlCsak akkor, ha igaz, csak a média URL kerül visszaadásra (alapértelmezett hamis)
  * @return {QString} a média jelölése vagy URL-je
  */
QString downloadUrlToMedia(QUrl url, bool returnUrlOnly);
1
2
3
4
5
6
7
8
9

# Példa

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

Érdemes megnézni a példát paste-latex-image.qml (opens new window).

# Inserting a media file into the media folder

# Módszerhívás és paraméterek

/**
  * QML-csomagoló médiafájl beszúrásához a média mappába és visszatérés
  * az adathordozó URL-je vagy a hordozó jelölési képszövege az aktuális jegyzethez képest
  *
  * @param {QString} mediaFilePath
  * @param {bool} returnUrlCsak akkor, ha igaz, csak a média URL kerül visszaadásra (alapértelmezett hamis)
  * @return {QString} a média jelölése vagy URL-je
  */
QString ScriptingService :: insertMediaFile (QString mediaFilePath,
                                         bool returnUrlOnly);
1
2
3
4
5
6
7
8
9
10

# Példa

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

Érdemes megnézni a példát scribble.qml (opens new window).

# Mellékletfájl beszúrása a mellékletek mappájába

# Módszerhívás és paraméterek

 * QML-burkoló egy csatolmányfájl beszúrásához a "mellékletek" mappába, és
  * a melléklet url-jének vagy a melléklet leíró szövegének visszaadása
  * az aktuális hanghoz képest
  *
 * @param {QString} attachmentFilePath
 * @param {QString} fileName to use in the markdown
 * @param {bool} returnUrlOnly if true only the attachment url will be returned
 * (default false)
 * @return {QString} the attachment markdown or url
 */
QString ScriptingService::insertAttachmentFile(const QString &attachmentFilePath,
                                               const QString &fileName,
                                               bool returnUrlOnly);
1
2
3
4
5
6
7
8
9
10
11
12
13

# Példa

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

# A jegyzet előnézetének regenerálása

Frissíti a jegyzet előnézetét.

# Módszerhívás és paraméterek

/**
  * Regenerálja a jegyzet előnézetét
  */
QString ScriptingService::regenerateNotePreview();
1
2
3
4

# Példa

script.regenerateNotePreview();
1

Érdemes megnézni a példát scribble.qml (opens new window).

# Egyéni művelet regisztrálása

# Módszerhívás és paraméterek

/**
 * Egyéni műveletet regisztrál
 *
 * @param azonosítója a művelet azonosítója
 * @param menü Szöveg a menüben látható szöveg
 * @param gombText a gombon látható szöveg
 * (üres gomb nem jelenik meg)
 * @param ikon az ikonfájl útvonala vagy a freeskesk téma téma neve
 * az ikonok listáját itt találja:
 * https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
 * @param useInNoteEditContextMenu, ha igaz, használja a műveletet a jegyzet szerkesztésében
 * helyi menü (alapértelmezett: hamis)
 * @param hideButtonInToolbar ha igaz, akkor a gomb nem jelenik meg a
 * egyéni műveleti eszköztár (alapértelmezett: hamis)
 * @param useInNoteListContextMenu, ha igaz, használja a jegyzetlista műveletét
 * helyi menü (alapértelmezett: hamis)
 */
void ScriptingService::registerCustomAction(QString identifier,
                                            QString menuText,
                                            QString buttonText,
                                            QString ikon,
                                            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

Helyi és globális parancsikonokat is rendelhet az egyéni műveletekhez a Shortcuts settings részben.

::: Figyelem Ne feledje, hogy az ingyenes asztali téma ikonok (opens new window) többnyire csak Linux alatt érhetők el. Tehát ha valóban ikont szeretne használni alatta macOS vagy Windows rendszert kell biztosítania a szkripthez. A scriptDirPath tulajdonság használatával lekérheti a szkript elérési útját, hogy beállítsa az ikon megfelelő elérési útját. :::

# Példa

import QtQml 2.0
import QOwnNotesTypes 1.0

Script {
    /**
     * Inicializálja az egyéni műveleteket
     */
    function init() {
        // egyéni művelet hozzáadása gomb nélkül
        script.registerCustomAction("mycustomaction1", "Menu text");

        // egyéni művelet hozzáadása gombbal
        script.registerCustomAction("mycustomaction2", "Menu text", "Button text");

        // egyéni művelet hozzáadása gombbal és ingyenes asztali téma ikonnal
        script.registerCustomAction("mycustomaction3", "Menu text", "Button text", "task-new");

        // egyéni művelet hozzáadása gombbal és ikonnal egy fájlból
        script.registerCustomAction("mycustomaction4", "Menu text", "Button text", "/usr/share/icons/breeze/actions/24/view-calendar-tasks.svg");
    }

    /**
     * Ez a funkció akkor kerül meghívásra, amikor egyéni műveletet indítanak el
     * menüben vagy gombbal
     * 
     * @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

További példákért lásd: custom-actions.qml (opens new window).

TIP

Egyéni műveletet is kiválthat az alkalmazás indítása után a(z) --action customAction_<identifier> paraméterrel. További információért tekintse meg a(z) Indítás utáni menüműveleteket.

# Címke regisztrálása

# Módszerhívás és paraméterek

/**
  * Regisztrál egy címkét, amelyhez írhat
  *
  * @param azonosítója a címke azonosítója
  * @param szöveg a címkén látható szöveg (nem kötelező)
  */
void ScriptingService :: registerLabel (QString azonosító, QString szöveg);
1
2
3
4
5
6
7

# Példa

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", "egy másik nagyon hosszú, egy másik nagyon hosszú, egy másik nagyon hosszú, egy másik nagyon hosszú, egy másik nagyon hosszú, egy másik nagyon hosszú, egy másik nagyon hosszú, egy másik nagyon hosszú szöveg , egy másik nagyon hosszú szöveg, egy másik nagyon hosszú szöveg, egy másik nagyon hosszú szöveg, amely be fog burkolni ");

script.registerLabel ("ellencímke");
1
2
3
4
5

A címkék láthatók lesznek a szkriptek dokkoló moduljában.

A címkékben használhat sima szöveget vagy HTML-t is. A szöveg választható lesz, és a linkekre kattintani lehet.

Ezután érdemes megnéznie a példa szkriptet scripting-label-demo.qml (opens new window).

# Bejegyzett címke szövegének beállítása

# Módszerhívás és paraméterek

/**
  * Beállítja a bejegyzett címke szövegét
  *
  * @param azonosítója a címke azonosítója
  * @param szöveg a címkén látható szöveget
  */
void ScriptingService::setLabelText(QString identifier, QString text);
1
2
3
4
5
6
7

# Példa

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

A címkékben használhat sima szöveget vagy HTML-t is. A szöveg választható lesz, és a linkekre kattintani lehet.

Ezután érdemes megnéznie a példa szkriptet scripting-label-demo.qml (opens new window).

# Új jegyzet létrehozása

# Módszerhívás és paraméterek

/**
  * Új jegyzetet hoz létre
  *
  * @param írja be a jegyzet szövegét
  */
void ScriptingService::createNote(QString text);
1
2
3
4
5
6

# Példa

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

Érdemes megnéznie az custom-actions.qml (opens new window) példát.

TIP

Ha kikapcsolta, hogy a jegyzet címsora határozza meg a jegyzet fájlnevét, akkor utána magának kell átneveznie a jegyzetfájlt, így:

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

# A vágólap elérése

# Módszerhívás és paraméterek

/**
  * A vágólap tartalmát szövegként vagy HTML-ként adja vissza
  *
  * @param asHtml a vágólap tartalmát html-ként adja vissza szöveg helyett
  */
QString ScriptingService::clipboard(bool asHtml);
1
2
3
4
5
6

# Példa

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

Érdemes megnéznie az custom-actions.qml (opens new window) példát.

# Írjon szöveget a jegyzet szövegszerkesztésébe

# Módszerhívás és paraméterek

/**
  * Szöveget ír a kurzor aktuális pozíciójába a jegyzet szövegszerkesztésében
  *
  * @param szöveg
  */
void ScriptingService::noteTextEditWrite(QString text);
1
2
3
4
5
6

# Példa

// szöveget ír a jegyzet szövegszerkesztésébe
script.noteTextEditWrite ("Saját szöveg");
1
2

Érdemes megnéznie az transformTextRot13 egyéni műveletet a custom-actions.qml (opens new window) példában.

Használhatja ezt a noteTextEditSelectAll vel együtt az aktuális jegyzet teljes szövegének felülírásához.

# Olvassa el a kijelölt szöveget a jegyzet szövegszerkesztésében

# Módszerhívás és paraméterek

/**
  * Elolvassa a kiválasztott szöveget a jegyzet szövegszerkesztésében
  *
  * @Visszatérés
  */
QString ScriptingService :: noteTextEditSelectedText ();
1
2
3
4
5
6

# Példa

// elolvassa a kijelölt szöveget a jegyzet szövegszerkesztéséből
var text = script.noteTextEditSelectedText();
1
2

Érdemes megnéznie az transformTextRot13 egyéni műveletet a custom-actions.qml (opens new window) példában.

# Jelölje ki az összes szöveget a jegyzet szövegszerkesztésében

# Módszerhívás és paraméterek

/**
  * Kiválasztja az összes szöveget a jegyzet szövegszerkesztésében
  */
void ScriptingService::noteTextEditSelectAll();
1
2
3
4

# Példa

script.noteTextEditSelectAll();
1

Használhatja ezt a noteTextEditWrite vel együtt az aktuális jegyzet teljes szövegének felülírásához.

# Válassza ki az aktuális sort a jegyzet szövegszerkesztésében

# Módszerhívás és paraméterek

/**
  * Kiválasztja az aktuális sort a jegyzet szövegszerkesztésében
  */
void ScriptingService::noteTextEditSelectCurrentLine();
1
2
3
4

# Példa

script.noteTextEditSelectCurrentLine();
1

# Válassza ki az aktuális szót a jegyzet szövegszerkesztésében

# Módszerhívás és paraméterek

/**
  * Kijelöli az aktuális szót a jegyzet szövegének szerkesztésében
  */
void ScriptingService::noteTextEditSelectCurrentWord();
1
2
3
4

# Példa

script.noteTextEditSelectCurrentWord();
1

# Állítsa be az aktuálisan kiválasztott szöveget a jegyzet szövegszerkesztésében

# Módszerhívás és paraméterek

/**
  * Beállítja az aktuálisan kiválasztott szöveget a jegyzet szövegszerkesztésében
  *
  * @param indítás
  * @param vége
  */
void ScriptingService :: noteTextEditSetSelection (int kezdet, int vég);
1
2
3
4
5
6
7

# Példa

// egy karakterrel kibontja az aktuális választást
script.noteTextEditSetSelection(
    script.noteTextEditSelectionStart() - 1,
    script.noteTextEditSelectionEnd() + 1);
1
2
3
4

# Az aktuális kijelölés kiindulási helyének megszerzése a jegyzetszöveg szerkesztésében

# Módszerhívás és paraméterek

/**
  * Visszaadja az aktuális kijelölés kezdő pozícióját a jegyzetszöveg szerkesztésében
  */
int ScriptingService::noteTextEditSelectionStart();
1
2
3
4

# Példa

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

# Az aktuális kijelölés végpozíciója a jegyzetszöveg szerkesztésében

# Módszerhívás és paraméterek

/**
  * Visszaadja az aktuális kijelölés végpozícióját a jegyzetszöveg szerkesztésében
  */
int ScriptingService :: noteTextEditSelectionEnd ();
1
2
3
4

# Példa

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

# Állítsa a kurzort a jegyzet szövegszerkesztésében egy bizonyos pozícióra

# Módszerhívás és paraméterek

/**
  * Beállítja a kurzort a jegyzet szövegszerkesztésében egy bizonyos pozícióba
  * 0 lenne a hang eleje
  * speciális eset: -1 lenne a hang vége
  *
  * @param pozíció
  */
void ScriptingService::noteTextEditSetCursorPosition(int position);
1
2
3
4
5
6
7
8

# Példa

// ugrás a jegyzet 11. karakterére
script.noteTextEditSetCursorPosition(10);

// ugrás a hang végére
script.noteTextEditSetCursorPosition(-1);
1
2
3
4
5

# Szerezze be a szövegmutató aktuális helyzetét a jegyzetszöveg szerkesztésében

# Módszerhívás és paraméterek

/**
  * Visszaadja a kurzor aktuális helyzetét a jegyzet szövegszerkesztésében
  * 0 lenne a hang eleje
  */
int ScriptingService::noteTextEditCursorPosition();
1
2
3
4
5

# Példa

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

# Olvassa el az aktuális szót a jegyzet szövegszerkesztéséből

# Módszerhívás és paraméterek

/**
 * Beolvassa az aktuális szót a jegyzetszöveg szerkesztésében
 *
 * @param withPreviousCharacters also get more characters at the beginning
 *                               to get characters like "@" that are not
 *                               word-characters
 * @return
 */
QString ScriptingService::noteTextEditCurrentWord(bool withPreviousCharacters);
1
2
3
4
5
6
7
8
9

# Példa

// olvassa el az aktuális szót a jegyzet szövegszerkesztésében
var text = script.noteTextEditCurrentWord();
1
2

Érdemes megnéznie az autocompletion.qml (opens new window) példát.

# Ellenőrizze, hogy a platform Linux, OS X vagy Windows

# Módszerhívás és paraméterek

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

# Példa

if (script.platformIsLinux()) {
    // Csak akkor kerül végrehajtásra, ha Linux alatt
}
1
2
3

# Jelölje be az aktuális jegyzetet

# Módszerhívás és paraméterek

/**
  * Az aktuális jegyzetet tagName nevű címkével látja el
  *
  * @param tagName
  */
void ScriptingService :: tagCurrentNote (QString tagName);
1
2
3
4
5
6

# Példa

// adjon hozzá egy "kedvenc" címkét az aktuális jegyzethez
script.tagCurrentNote ("kedvenc");
1
2

Érdemes megnéznie a kedvencNote egyéni műveletet a favorite-note.qml (opens new window) példában.

# Hozzon létre vagy válasszon egy címkét a nevének rákattintási listáján

# Módszerhívás és paraméterek

/**
 * Fetches or creates a tag by its "breadcrumb list" of tag names
 * Element nameList[0] would be highest in the tree (with parentId: 0)
 *
 * @param nameList
 * @param createMissing {bool} if true (default) all missing tags will be created
 * @return TagApi object of deepest tag of the name breadcrumb list
 */
TagApi *ScriptingService::getTagByNameBreadcrumbList(
    const QStringList &nameList, bool createMissing);
1
2
3
4
5
6
7
8
9
10

# Példa

// az összes címkét létrehozza a 3. szintig, és visszaadja a címke objektumot
// tag "level3", amely így nézne ki a címkefában:
// szint1 > 2. szint > szint3
var tag = script.getTagByNameBreadcrumbList (["szint1", "szint2", "szint3"]);
1
2
3
4

# Címkék keresése név szerint

# Módszerhívás és paraméterek

/**
  * Az összes címkét lekérdezi a névmezőben egy részlekereséssel
  *
  * @param név {QString} név a keresésre
  * @return {QStringList} címke nevek listája
 */
QStringList ScriptingService::searchTagsByName(QString name);
1
2
3
4
5
6
7

# Példa

// megkeresi az összes címkét, benne a játék szóval
var tags = script.searchTagsByName("game");
1
2

Érdemes megnéznie az autocompletion.qml (opens new window) példát.

# Jegyzetek keresése jegyzetszöveg alapján

# Módszerhívás és paraméterek

/**
  * Visszaadja az összes jegyzet jegyzetazonosítóinak listáját, egy bizonyos szöveggel a jegyzet szövegében
  *
  * Sajnos nincs egyszerű módszer a QList <NoteApi*>használatára a QML-ben, ezért mi
  * csak a jegyzetazonosítókat tudja átvinni
  *
  * @return {QList<int>} jegyzetazonosítók listája
*/
QList<int>ScriptingService::fetchNoteIdsByNoteTextPart(QString text);

1
2
3
4
5
6
7
8
9
10

# Példa

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

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

     // tegyen valamit a jegyzettel
});
1
2
3
4
5
6
7

Érdemes megnéznie az unique-note-id.qml (opens new window) példát.

# Adjon hozzá egy egyedi stíluslapot

# Módszerhívás és paraméterek

/**
  * Hozzáad egy egyedi stíluslapot az alkalmazáshoz
  *
  * @param stíluslap
  */
void ScriptingService :: addStyleSheet (QString stíluslap);
1
2
3
4
5
6

# Példa

// nagyítsa a jegyzetlista szövegét
script.addStyleSheet("QTreeWidget#noteTreeWidget {font-size: 30px;}");
1
2

Érdemes megnézni a példát egyéni stíluslap.qml (opens new window).

A widgetek neveit a *.ui fájlokból kaphatja meg, például a főablak a mainwindow.ui (opens new window).

A Qt-dokumentáció (például QMainWindow (opens new window)) segíthet abban, hogy megnézze, hogyan kapcsolódnak egymáshoz a widgetek (keresse az Öröklések kifejezést az oldalakon).

Az alap widget szinte mindenhez a QWidget (opens new window). Tehát csak a QWidget stílust, például a QWidget {background-color: black; color: white;} azt jelenti, hogy mindennek fekete háttérszíne és fehér előtérszíne van.

TIP

Astyle.qss (opens new window) a qdarkstyle (opens new window)-ból szintén jó referencia lehet a módosítható stílusokhoz.

Vessen egy pillantást a Stíluslap-referenciára (opens new window), ahol megtudhatja, milyen stílusok érhetők el.

Ha stílusokat szeretne beilleszteni a html előnézetbe, hogy módosítsa a jegyzetek előnézetének módját, kérjük, tekintse meg a notetomarkdownhtmlhook részt.

TIP

Ha valóban látni szeretné, hogyan néznek ki a párbeszédpanelek és mi a nevük, töltse le a Qt Creator (opens new window) programot, és nyissa meg a benne lévő *.ui fájlokat.

# A parancsfájlmotor újratöltése

# Módszerhívás és paraméterek

/**
  * Újra feltölti a parancsfájl-motor
  */
void ScriptingService :: reloadScriptingEngine ();
1
2
3
4

# Példa

// töltse be újra a szkript motort
script.reloadScriptingEngine();
1
2

# Jegyzet letöltése fájlneve alapján

# Módszerhívás és paraméterek

/**
  * Megjegyzést a fájlneve alapján kap
  *
  * @param fileName karakterlánc a megjegyzés fájlneve (kötelező)
  * @param noteSubFolderId a jegyzet almappájának egész azonosítója
  * @return NoteApi *
  */
NoteApi* ScriptingService::fetchNoteByFileName(QString fileName,
                                                int noteSubFolderId);
1
2
3
4
5
6
7
8
9

# Példa

// jegyzet letöltése fájlnév szerint
script.fetchNoteByFileName ("jegyzetem.md");
1
2

# Megjegyzés behozása az azonosítója alapján

# Módszerhívás és paraméterek

/**
  * A jegyzetet az azonosítója alapján szerzi be
  *
  * @param id a jegyzet azonosítójában
  * @return NoteApi *
  */
NoteApi* ScriptingService::fetchNoteById(int id);
1
2
3
4
5
6
7

# Példa

// a jegyzet lehívása azonosító szerint
script.fetchNoteById (243);
1
2

Érdemes megnézni a példát export-notes-as-one-html.qml (opens new window).

# Annak ellenőrzése, hogy létezik-e jegyzet a fájlneve alapján

# Módszerhívás és paraméterek

/**
  * Ellenőrzi, hogy a jegyzetfájl létezik-e a fájlnév alapján
  *
  * @param fileName karakterlánc a megjegyzés fájlneve (kötelező)
  * @param ignoreNoteId az ellenőrzés során figyelmen kívül hagyandó jegyzet egész azonosítója
  * @param noteSubFolderId a jegyzet almappájának egész azonosítója
  * @return bool
  */
bool ScriptingService::noteExistsByFileName(QString fileName,
                                            int ignoreNoteId,
                                            int noteSubFolderId);
1
2
3
4
5
6
7
8
9
10
11

# Példa

// ellenőrizze, hogy létezik-e jegyzet, de hagyja figyelmen kívül a "jegyzet" azonosítóját
script.noteExistsByFileName("my note.md", note.id);
1
2

Érdemes megnézni a példát use-tag-names-in-fájlnév.qml (opens new window).

# Szöveg másolása a vágólapra

# Módszerhívás és paraméterek

/**
  * Szöveget vagy HTML-mime adatot másol a vágólapra
  *
  * @param szöveges szöveg a vágólapra
  * @param asHtml bool, ha igaz, a szöveg html mime adatként lesz beállítva
  */
void ScriptingService::setClipboardText(QString text, bool asHtml);
1
2
3
4
5
6
7

# Példa

// szöveg másolása a vágólapra
script.setClipboardText("text to copy");
1
2

Érdemes megnézni a példát selected-markdown-to-bbcode.qml (opens new window).

# Ugrás egy jegyzethez

# Módszerhívás és paraméterek

/**
  * Beállítja az aktuális jegyzetet, ha a jegyzet látható a jegyzetlistában
  *
  * @param note NoteApi jegyzet, ahova ugorhat
  */
void ScriptingService::setCurrentNote(NoteApi *note);
1
2
3
4
5
6

# Példa

// ugrás a hangra
script.setCurrentNote(note);
1
2

Érdemes megnézni a példát journal-entry.qml (opens new window).

# Ugrás egy jegyzet almappájára

# Módszerhívás és paraméterek

/**
  * Ugrás egy jegyzet almappába
  *
  * @param noteSubFolderPath {QString} az almappa elérési útja a jegyzetmappához képest
  * @param elválasztó {QString} elválasztó az útvonal részei között, alapértelmezett "/"
  * @return true, ha az ugrás sikeres volt
 */
bool ScriptingService::jumpToNoteSubFolder(const QString &noteSubFolderPath,
                                            QString separator);
1
2
3
4
5
6
7
8
9

# Példa

// ugrás a "almappa" jegyzet almappájához
script.jumpToNoteSubFolder("a sub folder");

// ugrás az "almappa" belsejében található "al" mappához
script.jumpToNoteSubFolder("a sub folder/sub");
1
2
3
4
5

TIP

Új jegyzetmappát hozhat létre az aktuális almappában a mainWindow.createNewNoteSubFolder hívásával.

# Információs üzenetdoboz megjelenítése

# Módszerhívás és paraméterek

/**
  * Információs üzenet mezőt mutat
  *
  * @param szöveg
  * @param cím (nem kötelező)
  */
1
2
3
4
5
6

# Példa

// információs üzenet mező megjelenítése
script.informationMessageBox("The text I want to show", "Some optional title");
1
2

# Kérdés üzenetmező megjelenítése

# Módszerhívás és paraméterek

/**
  * Megjeleníti a kérdésüzenet mezőt
  *
  * A gombokkal kapcsolatos információkért lásd:
  * https://doc.qt.io/qt-5/qmessagebox.html#StandardButton-enum
  *
  * @param szöveg
  * @param cím (nem kötelező)
  * Megjelenítendő @param gombok (opcionális)
  * @param defaultButton alapértelmezett gomb, amely kiválasztásra kerül (opcionális)
  * @return gombjának megnyomása
  */
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

# Példa

// kérdéses üzenetdoboz megjelenítése egy alkalmazással és egy súgó gombbal
// lásd: https://doc.qt.io/qt-5/qmessagebox.html#StandardButton-enum
var result = script.questionMessageBox (
     "A megjeleníteni kívánt szöveg", "Néhány választható cím", 0x01000000 | 0x02000000, 0x02000000);
script.log(result);
1
2
3
4
5

A gombokkal kapcsolatos információkért lásd: StandardButton (opens new window).

Érdemes egy pillantást vetni a példára is input-dialogs.qml (opens new window).

# Megnyitott fájl párbeszédpanel megjelenítése

# Módszerhívás és paraméterek

/**
 * Megjelenít egy megnyitott fájl párbeszédpanelt
 *
 * @param caption (optional)
 * @param dir (optional)
 * @param filter (optional)
 * @return QString
 */
QString ScriptingService::getOpenFileName(QString caption, QString dir,
                                            QString filter);
1
2
3
4
5
6
7
8
9
10

# Példa

// nyitott fájl párbeszédpanel megjelenítése
var fileName = script.getOpenFileName("Please select an image", "/home/user/images", "Images (*.png *.xpm *.jpg)");
1
2

# Fájl mentési párbeszédpanel megjelenítése

# Módszerhívás és paraméterek

/**
  * Fájl mentési párbeszédpanelt mutat
  *
  * @param felirat (opcionális)
  * @param dir (opcionális)
  * @param szűrő (opcionális)
  * @return QString
  */
QString ScriptingService::getSaveFileName(QString caption, QString dir,
                                            QString filter);
1
2
3
4
5
6
7
8
9
10

# Példa

// a fájl mentése párbeszédpanel megjelenítése
var fileName = script.getSaveFileName ("Please select HTML file to save", "output.html", "HTML (*.html)");
1
2

Érdemes megnézni a példát export-notes-as-one-html.qml (opens new window).

# Registering script settings variables

Meg kell határoznia a beállítási változókat tulajdonságként a szkriptben, és regisztrálnia kell őket egy settingsVariables nevű tulajdonságba.

Ezután a felhasználó beállíthatja ezeket a tulajdonságokat a szkript beállításaiban.

# Példa

// meg kell határoznia a regisztrált változókat, hogy később hozzáférhessen hozzájuk
property string myString;
property bool myBoolean;
property string myText;
property int myInt;
property string myFile;
property string mySelection;

// regisztrálja a beállítási változóit, hogy a felhasználó beállíthassa azokat a szkriptbeállításokban
//
// Sajnos a Qt-ban nincs QVariantHash, csak használhatjuk
// QVariantMap (amelynek nincs tetszőleges sorrendje) vagy QVariantList (amely 
// legalább tetszőlegesen megrendelhető)
property variant settingsVariables: [
    {
        "identifier": "myString",
        "name": "Sorszerkesztő vagyok",
        "description": "Adjon meg egy érvényes karakterláncot:",
        "type": "string",
        "default": "My default value",
    },
    {
        "identifier": "myBoolean",
        "name": "Jelölőnégyzet vagyok",
        "description": "Egy kis leírás",
        "text": "Jelölje be ezt a jelölőnégyzetet",
        "type": "boolean",
        "default": true,
    },
    {
        "identifier": "myText",
        "name": "Szövegdoboz vagyok",
        "description": "Kérjük, írja be a szövegét:",
        "type": "text",
        "default": "Ez nagyon hosszú szöveg lehet,\többsoros.",
    },
    {
        "identifier": "myInt",
        "name": "Számválasztó vagyok",
        "description": "Kérjük, írjon be egy számot:",
        "type": "integer",
        "default": 42,
    },
    {
        "identifier": "myFile",
        "name": "Fájlválasztó vagyok",
        "description": "Kérjük, válassza ki a fájlt:",
        "type": "file",
        "default": "pandoc",
    },
    {
        "identifier": "mySelection",
        "name": "Tételválasztó vagyok",
        "description": "Kérjük, válasszon egy tételt:",
        "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

Ezenkívül felülírhatja a settingsVariables funkciót egy registerSettingsVariables() speciális funkcióval, mint ez:

# Példa

/**
  * Újra regisztrálja a beállítási változókat
  *
  * Használja ezt a módszert, ha kódot szeretne használni a változók felülírásához, például a beállításhoz
  * az alapértelmezett értékek az operációs rendszertől függtek.
 */
function registerSettingsVariables() {
    if (script.platformIsWindows()) {
        // override the myFile default value
        settingsVariables[3].default = "pandoc.exe"
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

Érdemes egy pillantást vetni erre a példára is: variables.qml (opens new window).

# Tartós változók tárolása és betöltése

# Módszerhívás és paraméterek

/**
  * Tartós változót tárol
  * Ezek a változók globálisan elérhetők az összes szkripten
  * Kérjük, használjon értelmes előtagot a kulcsában, például "PersistentVariablesTest / myVar"
  *
  * @param key {QString}
  * @param defaultValue {QVariant}
  */
void ScriptingService::setPersistentVariable (const QString & amp; kulcs,
                                                 const QVariant &amp);

/**
  * Tartós változót tölt be
  * Ezek a változók globálisan elérhetők az összes szkripten
  *
  * @param key {QString}
  * @param defaultValue {QVariant} visszatérési érték, ha a beállítás nem létezik (nem kötelező)
  * @Return
  */
QVariant ScriptingService::getPersistentVariable (const QString & kulcs,
                                                     const QVariant & defaultValue);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# Példa

// perzisztens változó tárolása
script.setPersistentVariable("PersistentVariablesTest/myVar", result);

// perzisztens változó betöltése és naplózása
script.log(script.getPersistentVariable("PersistentVariablesTest/myVar", "nothing here yet"));
1
2
3
4
5

Kérjük, ne felejtsen el értelmes előtagot használni a kulcsában, például PersistentVariablesTest / myVar, mert a változók minden szkriptből elérhetők.

Érdemes megnéznie a persistent-variables.qml (opens new window) példát is.

# Az alkalmazás beállításainak változóinak betöltése

# Módszerhívás és paraméterek

/**
 * Betölti az alkalmazás beállításainak változóját
 *
 * @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

# Példa

// betölti és naplózza az alkalmazás beállításainak változóját
script.log(script.getApplicationSettingsVariable("gitExecutablePath"));
1
2

Ne feledje, hogy a beállítások valóban üresek lehetnek, effelől magának kell gondoskodnia. Az defaultValue csak akkor használható, ha a beállítás egyáltalán nem létezik.

# Gyorsítótár könyvtár létrehozása

A fájlokat a rendszer alapértelmezett gyorsítótár-helyén tárolhatja.

# Módszerhívás és paraméterek

/**
  * Egy szkript gyorsítótár-könyvtárát adja eredményül
  *
  * @param {QString} alirányítsa az almappát létrehozásra és használatra
  * @return {QString} a gyorsítótár dir útvonalát
  */
QString ScriptingService::cacheDir(const QString &subDir) const;
1
2
3
4
5
6
7

# Példa

// létrehozza a cache könyvtárat a my-script-id számára
var cacheDirForScript = script.cacheDir ("my-script-id");
1
2

# Gyorsítótár könyvtár törlése

Törölheti a szkript gyorsítótár-könyvtárát, ha átadja a nevét a clearCacheDir()-nek.

# Módszerhívás és paraméterek

/**
 * Törli a szkript gyorsítótár könyvtárát
 *
 * @param {QString} subDir the subfolder to clear
 * @return {bool} true on success
 */
bool ScriptingService::clearCacheDir(const QString &subDir) const;
1
2
3
4
5
6
7

# Példa

// törölje a gyorsítótár könyvtárát a my-script-id-ből
script.clearCacheDir("my-script-id");
1
2

# A szkript könyvtárának elérési útjának elolvasása

Ha meg kell kapnia annak a könyvtárnak az elérési útját, ahová a szkript tartozik, például más fájlok betöltéséhez, regisztrálnia kell egy script stringDirPath; tulajdonságot. Ez a tulajdonság a szkript könyvtárának elérési útjával lesz beállítva.

# Példa

importálja a QtQml 2.0 fájlt
importálja a QOwnNotesTypes 1.0 fájlt

Script {
    property string scriptDirPath;

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

# Az útvonalelválasztók átalakítása natívakká

# Módszerhívás és paraméterek

/**
  * A '/' elválasztókkal elválasztókká alakított útvonalat adja vissza
  * megfelel az alapul szolgáló operációs rendszernek.
 *
 * Windows rendszeren a toNativeDirSeparators ("c:/winnt/system32") visszatér
 * "c:\winnt\system32".
 *
  * @param útvonal
  * @Visszatérés
  */
QString ScriptingService::toNativeDirSeparators(QString path);
1
2
3
4
5
6
7
8
9
10
11

# Példa

// a "c:\winnt\system32" szót adja vissza Windows rendszeren
script.log(script.toNativeDirSeparators("c:/winnt/system32"));
1
2

# Az ösvényelválasztók konvertálása a natívakról

# Módszerhívás és paraméterek

/**
  * Visszaadja az elérési utat a '/' fájlelválasztóként.
 * Windows rendszeren pl. fromNativeDirSeparators("c:\\winnt\\system32")
 * returns "c:/winnt/system32".
 *
 * @param path
 * @return
 */
QString ScriptingService::fromNativeDirSeparators(QString path);
1
2
3
4
5
6
7
8
9

# Példa

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

# A natív könyvtár elválasztó megszerzése

# Módszerhívás és paraméterek

/**
  * Visszaadja a natív könyvtárelválasztót "/" vagy "\" Windows rendszeren
  *
  * @ return
  */
QString ScriptingService :: dirSeparator ();
1
2
3
4
5
6

# Példa

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

# Az összes kijelölt jegyzet elérési útjának felsorolása

# Módszerhívás és paraméterek

/**
  * Visszaadja az összes kijelölt jegyzet elérési útját
  *
  * @return {QStringList} a kiválasztott jegyzet útvonalak listája
  */
QStringList ScriptingService :: selectedNotesPaths ();
1
2
3
4
5
6

# Példa

// az összes kijelölt jegyzet elérési útjának listáját adja vissza
script.log (script.selectedNotesPaths());
1
2

Érdemes megnézni a példát external-note-diff.qml (opens new window).

# Az összes kijelölt jegyzet azonosítóinak listájának lekérése

# Módszerhívás és paraméterek

/**
  * Visszaadja az összes kijelölt jegyzet azonosítóinak listáját
  *
  * @return {QList <int>} a kiválasztott jegyzetazonosítók listája
  */
QList <int> ScriptingService :: selectedNotesIds ();
1
2
3
4
5
6

# Példa

// az összes kijelölt jegyzet azonosítóinak listáját adja vissza a script.log (script.selectedNotesIds());
1

Érdemes megnézni a példát export-notes-as-one-html.qml (opens new window).

# Módszerhívás és paraméterek

/**
  * Kiválaszt egy menüműveletet
  *
  * @param objectName {QString} a kiváltandó művelet objektumneve
  * A @param bejelölt {QString} csak akkor aktiválja a műveletet, ha a check-state van
  * eltér ettől a paramétertől (opcionális, lehet 0 vagy 1)
  */
void ScriptingService::triggerMenuAction(QString objectName, QString checked);
1
2
3
4
5
6
7
8

# Példa

// az írásvédett mód váltása
script.triggerMenuAction("actionAllow_note_editing");

// tiltsa le az írásvédett módot
script.triggerMenuAction("actionAllow_note_editing", 1);
1
2
3
4
5

Érdemes megnézni a példát disable-readonly-mode.qml (opens new window).

TIP

A menümű objektumneveit innen szerezheti be mainwindow.ui (opens new window). Csak keresse meg az angol menü címét. Ne feledje, hogy ezek a szövegek idővel változhatnak.

# Beviteli párbeszédpanel megnyitása egy kiválasztott mezővel

# Módszerhívás és paraméterek

Amy D. Lang (nyersfreeamy)
@unchase itt is (lásd a másik kommentemet)
/**
  * Megnyit egy beviteli párbeszédpanelt egy kiválasztó mezővel
  *
  * @param title {QString} párbeszédpanel címe
  * @param label {QString} címke szövege a párbeszédpanelen
  * @param items {QStringList} a kiválasztandó elemek listája
  * A kiválasztandó elem @param current {int} indexe (alapértelmezett: 0)
  * @param szerkeszthető {bool}, ha igaz, a párbeszédpanelen lévő szöveg szerkeszthető (alapértelmezett: hamis)
  * @return {QString} szöveg a kiválasztott elemről
  */
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
14
15

# Példa

var result = script.inputDialogGetItem(
    "combo box", "Kérjük, válasszon egy elemet", ["Item 1", "Item 2", "Item 3"]);
script.log(result);
1
2
3

Érdemes megnézni a példát input-dialogs.qml (opens new window).

# Beviteli párbeszédpanel megnyitása sorszerkesztéssel

# Módszerhívás és paraméterek

/**
 * Megnyit egy beviteli párbeszédablakot sorszerkesztéssel
 *
 * @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::inputDialogGetText(
        const QString &title, const QString &label, const QString &text);
1
2
3
4
5
6
7
8
9
10

# Példa

var result = script.inputDialogGetText(
    "line edit", "Kérjük, adjon meg egy nevet", "current text");
script.log(result);
1
2
3

# Ellenőrizze, hogy létezik-e fájl

# Módszerhívás és paraméterek

/**
  * Ellenőrizze, hogy létezik-e fájl
  * @param filePath
  * @Visszatérés
  */
bool ScriptingService::fileExists(QString &filePath);
1
2
3
4
5
6

# Példa

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

# Szöveg olvasása egy fájlból

# Módszerhívás és paraméterek

/**
  * Szöveg olvasása egy fájlból
  *
  * A betöltendő fájl @param filePath {QString} elérési útja
  * @param codec {QString} fájlkódolás (alapértelmezett: UTF-8)
  * @visszaállítja a fájl adatait, vagy null, ha a fájl nem létezik
  */
QString ScriptingService::readFromFile (const QString & filePath, const QString & kodek)
1
2
3
4
5
6
7
8

# Példa

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

# Szöveg írása fájlba

# Módszerhívás és paraméterek

/**
  * Szöveget ír egy fájlba
  *
  * @param filePath {QString}
  * @param adatok {QString}
  * @param createParentDirs {bool} opcionális (alapértelmezett: hamis)
  * @Visszatérés
  */
bool ScriptingService :: writeToFile (const QString & amp; filePath, const QString & amp; adatok, bool createParentDirs);
1
2
3
4
5
6
7
8
9

# Példa

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

Érdemes megnézni a példát export-notes-as-one-html.qml (opens new window).

# Webhálózatok használata

A QOwnNotes távolról vezérelhető a WebSocketServer használatával.

Kérjük, nézze meg a példát websocket-server.qml (opens new window). A socket kiszolgálót úgy tesztelheti, hogy csatlakozik hozzá a Websocket test (opens new window).

A foglalatokat a WebSocket használatával is meghallgathatja. Kérjük, nézze meg a példát websocket-client.qml (opens new window).

Ne feledje, hogy ennek használatához telepítenie kell a Qt QML websocket könyvtárát. Például az Ubuntu Linux alatt telepíthet qml-module-qtwebsockets.

# Kiemelési szabály hozzáadása a szerkesztőhöz

A kiemelési szabályokat közvetlenül beillesztheti a szerkesztőbe úgy, hogy reguláris kifejezéseket definiál és kiemelési állapothoz rendel.

# Módszerhívás és paraméterek

/**
  * Kiemelési szabályt ad a szerkesztő szintaxiskiemelőjéhez
  *
  * @param minta {QString} a kiemelendő reguláris kifejezés mintája
  * @param shouldContain {QString} egy karakterlánc, amelynek szerepelnie kell a kiemelt szövegben a minta elemzéséhez
  * @param állapot {int} a használni kívánt szintaxiskiemelő állapota
  * @param capturingGroup {int} a kiemeléshez használandó minta rögzítési csoportja (alapértelmezett: 0)
  * @param maskedGroup {int} a maszkoláshoz használandó minta rögzítési csoportja (alapértelmezett: 0)
  */
void ScriptingService::addHighlightingRule(const QString &minta,
                                            const QString &tartalmaznia kell,
                                            ink állapotban,
                                            int capturingGroup,
                                            int maskedGroup);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Az állapotok kiemelése

Név Nr.
NoState -1
Link 0
Image 3
CodeBlock 4
CodeBlockComment 5
Dőlt 7
Félkövér 8
Lista 9
Hozzászólás 11
H1 12
H2 13
H3 14
H4 15
H5 16
H6 17
BlockQuote 18
HorizontalRuler 21
Táblázat 22
InlineCodeBlock 23
MaskedSyntax 24
CurrentLineBackgroundColor 25
BrokenLink 26
FrontmatterBlock 27
TrailingSpace 28
CheckBoxUnChecked 29
CheckBoxChecked 30
StUnderline 31

# Példa

// Jelöljön ki egy szövegsort, mint például a „BLOCK: some text”, mint idézőjel (18-as állapot)
script.addHighlightingRule("^BLOCK: (.+)", "BLOCK:", 18);

// Minden karakter maszkolása (24-es állapot) 32 karakter után egy sorban
// CapturingGroup 1 azt jelenti, hogy a minta első zárójeles részének kifejezése kiemelve lesz
// A maskedGroup -1 azt jelenti, hogy nem szabad maszkolni
script.addHighlightingRule("^.{32}(.+)", "", 24, 1, -1);
1
2
3
4
5
6
7

Megnézheti a példákat is kiemelés.qml (opens new window).