# 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-csomagoló egy leválasztott folyamat elindításához
  *
  * @param végrehajthatóPath a futtatható fájl elérési útja
  * @param paraméterek a paraméterláncok listája
  * @param callbackIdentifier az onDetachedProcessCallback () függvényben használandó azonosító (opcionális)
  * @param callbackParameter egy további paraméter a hurkokhoz vagy hasonlókhoz (opcionális)
  * @param processA visszahívás használata esetén a folyamatba írt adatok (opcionális)
  * @retret true a sikerre, hamis egyébként
  */
bool startDetachedProcess (QString végrehajtható útvonal, QStringList paraméterek,
                             QString callbackIdentifier, QVariant callbackParameter,
                             QByteArray processData);
1
2
3
4
5
6
7
8
9
10
11
12
13

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

TIP

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

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

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

/**
  * QML-csomagoló a szinkron folyamat elindításához
  *
  * @param végrehajthatóPath a futtatható fájl elérési útja
  * @param paraméterek a paraméterláncok listája
  * @param adatok a folyamatba írandó adatok (nem kötelező)
  * @ visszaadja a folyamat által visszaadott szöveget
QByteArray startSynchronousProcess(QString executablePath, QStringList parameters, QByteArray data);
1
2
3
4
5
6
7
8

# Példa

var result = script.startSynchronousProcess("/path/to/my/program", ["my parameter"], "data");
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-csomagoló az aktuális jegyzet megszerzéséhez
  *
  * @returns {NoteApi} az 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 wrapper to insert an attachment file into the `attachments` folder and
 * returning the attachment url or the markdown text of the attachment
 * relative to the current note
 *
 * @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

/**
 * Registers a custom action
 *
 * @param identifier the identifier of the action
 * @param menuText the text shown in the menu
 * @param buttonText the text shown in the button
 *                   (no button will be viewed if empty)
 * @param icon the icon file path or the name of a freedesktop theme icon
 *             you will find a list of icons here:
 *             https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
 * @param useInNoteEditContextMenu if true use the action in the note edit
 *                                 context menu (default: false)
 * @param hideButtonInToolbar if true the button will not be shown in the
 *                            custom action toolbar (default: false)
 * @param useInNoteListContextMenu if true use the action in the note list
 *                                 context menu (default: false)
 */
void ScriptingService::registerCustomAction(QString identifier,
                                            QString menuText,
                                            QString buttonText,
                                            QString icon,
                                            bool useInNoteEditContextMenu,
                                            bool hideButtonInToolbar,
                                            bool useInNoteListContextMenu);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Példa

// add a custom action without a button
script.registerCustomAction("mycustomaction1", "Menu text");

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

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

// add a custom action with a button and an icon from a file
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

Ezután érdemes használni az azonosítót a function funkcióval customActionInvoked egy hasonló szkriptben 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

/**
 * Registers a label to write to
 *
 * @param identifier the identifier of the label
 * @param text the text shown in the label (optional)
 */
void ScriptingService::registerLabel(QString identifier, QString text);
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", "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

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

# Setting the text of a registered label

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

/**
 * Sets the text of a registered label
 *
 * @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

# 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

/**
 * Creates a new note
 *
 * @param text the note text
 */
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 a 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

// read the selected text from the note text edit
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

/**
 * Selects the current line in the note text edit
 */
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

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

# Példa

// expands the current selection by one character
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

/**
 * Returns the start position of the current selection in the note text edit
 */
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

/**
 * Returns the end position of the current selection in the note text edit
 */
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

// jump to the 11th character in the note
script.noteTextEditSetCursorPosition(10);

// jump to the end of the note
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

/**
 * Returns the current position of the text cursor in the note text edit
 * 0 would be the beginning of the note
 */
int ScriptingService::noteTextEditCursorPosition();
1
2
3
4
5

# Példa

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

# Read the current word from the note text edit

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

/**
 * Reads the current word in the note text edit
 *
 * @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

// read the current word in the note text edit
var text = script.noteTextEditCurrentWord();
1
2

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

# Check whether platform is Linux, OS X or 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()) {
    // only will be executed if under Linux
}
1
2
3

# Tag the current note

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

/**
 * Tags the current note with a tag named tagName
 *
 * @param tagName
 */
void ScriptingService::tagCurrentNote(QString tagName);
1
2
3
4
5
6

# Példa

// add a "favorite" tag to the current note
script.tagCurrentNote("favorite");
1
2

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

# Create or fetch a tag by its name breadcrumb list

# 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

// creates all tags until the 3rd level and returns the tag object for
// tag "level3", which would look like that in the tag tree:
// level1 > level2 > level3
var tag = script.getTagByNameBreadcrumbList(["level1", "level2", "level3"]);
1
2
3
4

# Search for tags by name

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

/**
 * Fetches all tags by doing a substring search on the name field
 *
 * @param name {QString} name to search for
 * @return {QStringList} list of tag names
 */
QStringList ScriptingService::searchTagsByName(QString name);
1
2
3
4
5
6
7

# Példa

// searches for all tags with the word game in it
var tags = script.searchTagsByName("game");
1
2

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

# Search for notes by note text

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

/**
 * Returns a list of note ids of all notes with a certain text in the note text
 *
 * Unfortunately there is no easy way to use a QList<NoteApi*> in QML, so we
 * can only transfer the note ids
 *
 * @return {QList<int>} list of note ids
 */
QList<int> ScriptingService::fetchNoteIdsByNoteTextPart(QString text);
1
2
3
4
5
6
7
8
9

# Példa

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

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

    // do something with the note
});
1
2
3
4
5
6
7

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

# Add a custom stylesheet

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

/**
 * Adds a custom stylesheet to the application
 *
 * @param stylesheet
 */
void ScriptingService::addStyleSheet(QString stylesheet);
1
2
3
4
5
6

# Példa

// make the text in the note list bigger
script.addStyleSheet("QTreeWidget#noteTreeWidget {font-size: 30px;}");
1
2

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

You can get the widget names from the *.ui files, for example the main window is mainwindow.ui (opens new window).

The Qt documentation (for example QMainWindow (opens new window)) can help you to see how the widgets are related to each other (search for Inherits on the pages).

The base widget for almost everything is QWidget (opens new window). So just styling QWidget with for example QWidget {background-color: black; color: white;} would mean everything has a black background color and a white foreground color.

TIP

The style.qss (opens new window) of qdarkstyle (opens new window) might also be a good reference for styles you can change.

Take a look at Style Sheet Reference (opens new window) for a reference of what styles are available.

If you want to inject styles into html preview to alter the way notes are previewed please look at notetomarkdownhtmlhook.

TIP

If you actually want to see how the dialogs look and what the names are you could download Qt Creator (opens new window) and open the *.ui files in it.

# Reloading the scripting engine

# 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

You may want to take a look at the example 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

You may want to take a look at the example use-tag-names-in-filename.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

You may want to take a look at the example 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

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

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

# Ugrás egy jegyzet almappájára

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

/**
 * Jumps to a note subfolder
 *
 * @param noteSubFolderPath {QString} path of the subfolder, relative to the note folder
 * @param separator {QString} separator between parts of the path, default "/"
 * @return true if jump was successful
 */
bool ScriptingService::jumpToNoteSubFolder(const QString &noteSubFolderPath,
                                            QString separator);
1
2
3
4
5
6
7
8
9

# Példa

// jump to the note subfolder "a sub folder"
script.jumpToNoteSubFolder("a sub folder");

// jump to the note subfolder "sub" inside of "a sub folder"
script.jumpToNoteSubFolder("a sub folder/sub");
1
2
3
4
5

TIP

You can create a new note subfolder in the current subfolder by calling mainWindow.createNewNoteSubFolder.

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

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

/**
 * Shows an information message box
 *
 * @param text
 * @param title (optional)
 */
void ScriptingService::informationMessageBox(QString text, QString title);
1
2
3
4
5
6
7

# Példa

// show a information message box
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

/**
 * Shows a question message box
 *
 * For information about buttons see:
 * https://doc.qt.io/qt-5/qmessagebox.html#StandardButton-enum
 *
 * @param text
 * @param title (optional)
 * @param buttons buttons that should be shown (optional)
 * @param defaultButton default button that will be selected (optional)
 * @return id of pressed button
 */
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

// show a question message box with an apply and a help button
// see: https://doc.qt.io/qt-5/qmessagebox.html#StandardButton-enum
var result = script.questionMessageBox(
    "The text I want to show", "Some optional title", 0x01000000|0x02000000, 0x02000000);
script.log(result);
1
2
3
4
5

For information about buttons see StandardButton (opens new window).

You may also want to take a look at the example input-dialogs.qml (opens new window).

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

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

/**
 * Shows an open file dialog
 *
 * @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

// show an open file dialog
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

You may want to take a look at the example export-notes-as-one-html.qml (opens new window).

# Registering script settings variables

You need to define your settings variables as properties in your script and register them in a property named settingsVariables.

The user can then set these properties in the script settings.

# Példa

// meg kell határoznia a regisztrált változókat, hogy később hozzájuk férhessen
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ókat, hogy a felhasználó beállítsa őket a szkript beállításaiban
// használja ezt a tulajdonságot, ha nincs rá szüksége
//
// sajnos a Qt-ben nincs QVariantHash, csak használni tudjuk
// QVariantMap (amelynek nincs önkényes sorrendje) vagy QVariantList (amely a
// a legkevesebb tetszőlegesen megrendelhető)
tulajdonságváltozat beállításaiVáltozók: [
    {
        "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
60
61

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

# 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

You may also want to take a look at the example 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

Please make sure to use a meaningful prefix in your key like PersistentVariablesTest/myVar because the variables are accessible from all scripts.

You may also want to take a look at the example persistent-variables.qml (opens new window).

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

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

/**
 * Loads an application settings variable
 *
 * @param key {QString}
 * @param defaultValue {QVariant} return value if the setting doesn't exist (optional)
 * @return
 */
QVariant ScriptingService::getApplicationSettingsVariable(const QString &key,
                                                            const QVariant &defaultValue);
1
2
3
4
5
6
7
8
9

# Példa

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

Keep in mind that settings actually can be empty, you have to take care about that yourself. defaultValue is only used if the setting doesn't exist at all.

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

You can cache files at the default cache location of your system.

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

/**
 * Returns a cache directory for a script
 *
 * @param {QString} subDir the subfolder to create and use
 * @return {QString} the cache dir path
 */
QString ScriptingService::cacheDir(const QString &subDir) const;
1
2
3
4
5
6
7

# Példa

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

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

You can clear the cache files of your script by passing its name to clearCacheDir().

# 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

# Example

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

# Reading the path to the directory of your script

If you need to get the path to the directory where your script is placed to for example load other files you have to register a property string scriptDirPath;. This property will be set with the path to the script's directory.

# Példa

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

# Converting path separators to native ones

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

/**
 * Returns path with the '/' separators converted to separators that are
 * appropriate for the underlying operating system.
 *
 * On Windows, toNativeDirSeparators("c:/winnt/system32") returns
 * "c:\winnt\system32".
 *
 * @param path
 * @return
 */
QString ScriptingService::toNativeDirSeparators(QString path);
1
2
3
4
5
6
7
8
9
10
11

# Példa

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

# Converting path separators from native ones

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

/**
 * Returns path using '/' as file separator.
 * On Windows, for instance, 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" on Windows
script.log(script.fromNativeDirSeparators("c:\\winnt\\system32"));
1
2

# Getting the native directory separator

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

/**
 * Returns the native directory separator "/" or "\" on Windows
 *
 * @return
 */
QString ScriptingService::dirSeparator();
1
2
3
4
5
6

# Példa

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

# Getting a list of the paths of all selected notes

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

/**
 * Returns a list of the paths of all selected notes
 *
 * @return {QStringList} list of selected note paths
 */
QStringList ScriptingService::selectedNotesPaths();
1
2
3
4
5
6

# Példa

// returns a list of the paths of all selected notes
script.log(script.selectedNotesPaths());
1
2

You may want to take a look at the example external-note-diff.qml (opens new window).

# Getting a list of the ids of all selected notes

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

/**
 * Returns a list of the ids of all selected notes
 *
 * @return {QList<int>} list of selected note ids
 */
QList<int> ScriptingService::selectedNotesIds();
1
2
3
4
5
6

# Példa

// returns a list of the ids of all selected notes
script.log(script.selectedNotesIds());
1
2

You may want to take a look at the example export-notes-as-one-html.qml (opens new window).

# Triggering a menu action

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

/**
 * Triggers a menu action
 *
 * @param objectName {QString} object name of the action to trigger
 * @param checked {QString} only trigger the action if checked-state is
 *                          different than this parameter (optional, can be 0 or 1)
 */
void ScriptingService::triggerMenuAction(QString objectName, QString checked);
1
2
3
4
5
6
7
8

# Példa

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

You may want to take a look at the example disable-readonly-mode.qml (opens new window).

TIP

You can get the object names of the menu action from mainwindow.ui (opens new window). Just search for the English menu title. Note that these texts can change over time.

# Opening an input dialog with a select box

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

/**
 * Opens an input dialog with a select box
 *
 * @param title {QString} title of the dialog
 * @param label {QString} label text of the dialog
 * @param items {QStringList} list of items to select
 * @param current {int} index of the item that should be selected (default: 0)
 * @param editable {bool} if true the text in the dialog can be edited (default: false)
 * @return {QString} text of the selected item
 */
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

# Példa

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

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

# Opening an input dialog with a line edit

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

/**
 * Opens an input dialog with a line edit
 *
 * @param title {QString} title of the dialog
 * @param label {QString} label text of the dialog
 * @param text {QString} text in the dialog (optional)
 * @return
 */
QString ScriptingService::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", "Please enter a name", "current text");
script.log(result);
1
2
3

# Checking if a file exists

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

/**
 * Check if a file exists
 * @param filePath
 * @return
 */
bool ScriptingService::fileExists(QString &filePath);
1
2
3
4
5
6

# Példa

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

# Reading text from a file

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

/**
 * Read text from a file
 *
 * @param filePath {QString} path of the file to load
 * @param codec {QString} file encoding (default: UTF-8)
 * @return the file data or null if the file does not exist
 */
QString ScriptingService::readFromFile(const QString &filePath, const QString &codec)
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

You may want to take a look at the example export-notes-as-one-html.qml (opens new window).

# Webhálózatok használata

You can remote control QOwnNotes by using WebSocketServer.

Please take a look at the example websocket-server.qml (opens new window). You can test the socket server by connecting to it on Websocket test (opens new window).

You can also listen to sockets with WebSocket. Please take look at the example websocket-client.qml (opens new window).

Keep in mind that you need to have Qt's QML websocket library installed to use this. For example under Ubuntu Linux you can install qml-module-qtwebsockets.