# 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
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
2
3
4
5
6
7
8
9
10
You may want to take a look at the example 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
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
You may want to take a look at the example 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
2
3
4
5
6
# Példa
var path = script.currentNoteFolderPath();
1
You may want to take a look at the example absolute-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
2
3
4
5
6
# Példa
var note = script.currentNote();
1
You may want to take a look at the example custom-actions.qml (opens new window).
# 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
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
2
3
4
5
6
7
# Példa
var html = script.downloadUrlToString("https://www.qownnotes.org");
1
You may want to take a look at the example 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
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
You may want to take a look at the example 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
2
3
4
5
6
7
8
9
10
# Példa
var markdown = script.insertMediaFile("/path/to/your/image.png");
1
You may want to take a look at the example 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
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
2
3
4
# Példa
script.regenerateNotePreview();
1
You may want to take a look at the example 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
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
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
For some more examples please see 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
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
2
3
4
5
The labels will be visible in the Scripting panel, which you need to enable in the Window / Panels menu.
A címkékben használhat sima szöveget vagy HTML-t is. A szöveg választható lesz, és a linkekre kattintani lehet.
You may then want to take a look at the example script 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
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.
You may then want to take a look at the example script scripting-label-demo.qml (opens new window).
TIP
The scripting label also supports external links, as well as internal links to notes, tasks, deck cards and more. You might get a grasp of what's supported by taking a look at URL handling (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
2
3
4
5
6
# Példa
script.createNote("My note headline\n===\n\nMy text");
1
You may want to take a look at the example custom-actions.qml (opens new window).
TIP
If you turned off that your note headline determines the note filename then you have to rename your note file yourself afterward, like this:
var note = script.currentNote();
note.renameNoteFile('your-filename');
1
2
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
2
3
4
5
6
# Példa
var clipboardText = script.clipboard();
var clipboardHtml = script.clipboard(true);
1
2
2
You may want to take a look at the example custom-actions.qml (opens new window).
# Í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
2
3
4
5
6
# Példa
// szöveget ír a jegyzet szövegszerkesztésébe
script.noteTextEditWrite ("Saját szöveg");
1
2
2
You might want to look at the custom action transformTextRot13 in the example custom-actions.qml (opens new window).
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
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
2
You might want to look at the custom action transformTextRot13 in the example custom-actions.qml (opens new window).
# 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
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
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
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
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
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
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
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
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
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
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
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
2
You may want to take a look at the example autocompletion.qml (opens new window).
# Read the current block from the note text edit
# Módszerhívás és paraméterek
/**
* Reads the current block in the note text edit
*
* @return
*/
QString ScriptingService::noteTextEditCurrentBlock();
1
2
3
4
5
6
2
3
4
5
6
# Példa
// Read the current block in the note text edit
var text = script.noteTextEditCurrentBlock();
1
2
2
You may want to take a look at the example ai-autocompletion.qml (opens new window).
# Use a completion prompt on the currently selected AI model
The AI completion prompt is a feature that allows you to use a completion prompt on the currently selected AI model.
The AI system needs to be enabled in the AI toolbar or main menu for this to work.
# Módszerhívás és paraméterek
/**
* QML wrapper to use the AI Completer
*
* @param prompt
* @return {QString} the result of the completer
*/
QString ScriptingService::aiComplete(const QString& prompt);
1
2
3
4
5
6
7
2
3
4
5
6
7
# Példa
// Ask the currently selected AI model to complete the prompt
var text = script.aiComplete("Tell me how do you feel today?");
1
2
2
You may want to take a look at the example ai-autocompletion.qml (opens new window).
# 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
2
3
# Példa
if (script.platformIsLinux()) {
// Csak akkor kerül végrehajtásra, ha Linux alatt
}
1
2
3
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
2
3
4
5
6
# Példa
// adjon hozzá egy "kedvenc" címkét az aktuális jegyzethez
script.tagCurrentNote ("kedvenc");
1
2
2
You might want to look at the custom action favoriteNote in the example favorite-note.qml (opens new window).
# 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
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
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
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
2
You may want to take a look at the example autocompletion.qml (opens new window).
# 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
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
2
3
4
5
6
7
You may want to take a look at the example unique-note-id.qml (opens new window).
# 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
2
3
4
5
6
# Példa
// nagyítsa a jegyzetlista szövegét
script.addStyleSheet("QTreeWidget#noteTreeWidget {font-size: 30px;}");
1
2
2
You may want to take a look at the example custom-stylesheet.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).
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
The style.qss (opens new window) of qdarkstyle (opens new window) might also be a good reference for styles you can change.
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
2
3
4
# Példa
// töltse be újra a szkript motort
script.reloadScriptingEngine();
1
2
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
2
3
4
5
6
7
8
9
# Példa
// jegyzet letöltése fájlnév szerint
script.fetchNoteByFileName ("jegyzetem.md");
1
2
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
2
3
4
5
6
7
# Példa
// a jegyzet lehívása azonosító szerint
script.fetchNoteById (243);
1
2
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
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
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
2
3
4
5
6
7
# Példa
// szöveg másolása a vágólapra
script.setClipboardText("text to copy");
1
2
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
/**
* Sets the current note if the note is visible in the note list
*
* @param note NoteApi note to jump to
* @param asTab bool if true the note will be opened in a new tab (if not already open)
*/
void ScriptingService::setCurrentNote(NoteApi *note, bool asTab = false);
1
2
3
4
5
6
7
2
3
4
5
6
7
# Példa
// jump to the note
script.setCurrentNote(note);
// open note in new tab (if not already open)
script.setCurrentNote(note, true);
1
2
3
4
5
2
3
4
5
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
/**
* 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 ¬eSubFolderPath,
QString separator);
1
2
3
4
5
6
7
8
9
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
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
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
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
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
2
3
4
5
A gombokkal kapcsolatos információkért lásd: 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
/**
* 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
2
3
4
5
6
7
8
9
10
# Example
// 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
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
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
2
You may want to take a look at the example 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
// you have to define your registered variables so you can access them later
property string myString;
property string myStringSecret;
property bool myBoolean;
property string myText;
property int myInt;
property string myFile;
property string myDirectory;
property string mySelection;
// register your settings variables so the user can set them in the script settings
//
// unfortunately there is no QVariantHash in Qt, we only can use
// QVariantMap (that has no arbitrary ordering) or QVariantList (which at
// least can be ordered arbitrarily)
property variant settingsVariables: [
{
"identifier": "myString",
"name": "I am a line edit",
"description": "Please enter a valid string:",
"type": "string",
"default": "My default value",
},
{
"identifier": "myStringSecret",
"name": "I am a password field",
"description": "Please enter a valid string:",
"type": "string-secret",
},
{
"identifier": "myBoolean",
"name": "I am a checkbox",
"description": "Some description",
"text": "Check this checkbox",
"type": "boolean",
"default": true,
},
{
"identifier": "myText",
"name": "I am textbox",
"description": "Please enter your text:",
"type": "text",
"default": "This can be a really long text\nwith multiple lines.",
},
{
"identifier": "myInt",
"name": "I am a number selector",
"description": "Please enter a number:",
"type": "integer",
"default": 42,
},
{
"identifier": "myFile",
"name": "I am a file selector",
"description": "Please select the file:",
"type": "file",
"default": "pandoc",
},
{
"identifier": "myDirectory",
"name": "I am a directory selector",
"description": "Please select the directory:",
"type": "directory",
"default": "/home",
},
{
"identifier": "mySelection",
"name": "I am an item selector",
"description": "Please select an item:",
"type": "selection",
"default": "option2",
"items": {"option1": "Text for option 1", "option2": "Text for option 2", "option3": "Text for option 3"},
}
];
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
In addition, you can override the settingsVariables with a special function registerSettingsVariables() like this:
# 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
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
/**
* Stores a persistent variable
* These variables are accessible globally over all scripts
* Please use a meaningful prefix in your key like "PersistentVariablesTest/myVar"
*
* @param key {QString}
* @param value {QVariant}
*/
void ScriptingService::setPersistentVariable(const QString &key,
const QVariant &value);
/**
* Loads a persistent variable
* These variables are accessible globally over all scripts
*
* @param key {QString}
* @param defaultValue {QVariant} return value if the setting doesn't exist (optional)
* @return
*/
QVariant ScriptingService::getPersistentVariable(const QString &key,
const QVariant &defaultValue);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
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.
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
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
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
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
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
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
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
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
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
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
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
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
2
3
4
5
6
# Példa
// will return "\" Windows-on
script.log(script.dirSeparator());
1
2
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
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
2
You may want to take a look at the example 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
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
You may want to take a look at the example export-notes-as-one-html.qml (opens new window).
# Menüművelet kiváltása
# 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
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
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). 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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
An empty string will be returned, if Cancel was clicked or Escape was pressed.
# 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
2
3
You may want to take a look at the example 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
2
3
4
5
6
7
8
9
10
An empty string will be returned, if Cancel was clicked or Escape was pressed.
# Példa
var result = script.inputDialogGetText(
"line edit", "Kérjük, adjon meg egy nevet", "current text");
script.log(result);
1
2
3
2
3
# Opening an input dialog with a multi-line text edit
# Módszerhívás és paraméterek
/**
* Opens an input dialog with a multi-line text edit
*
* @param title {QString} title of the dialog
* @param label {QString} label text of the dialog
* @param text {QString} text in the dialog (optional)
* @return
*/
QString ScriptingService::inputDialogGetMultiLineText(
const QString &title, const QString &label, const QString &text);
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
An empty string will be returned, if Cancel was clicked or Escape was pressed.
# Példa
var result = script.inputDialogGetMultiLineText(
"multi-line edit", "Please enter a text", "current text");
script.log(result);
1
2
3
2
3
# Opening a dialog to show the differences between two texts
# Módszerhívás és paraméterek
/**
* Opens a dialog to show the differences between two texts and lets the user edit the result
*
* @param title {QString} title of the dialog
* @param label {QString} label text of the dialog
* @param text1 {QString} first text
* @param text2 {QString} second text
* @return
*/
QString ScriptingService::textDiffDialog(const QString &title, const QString &label,
const QString &text1, const QString &text2);
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
text2 is the text you will be able to edit in the dialog. An empty string will be returned, if Cancel was clicked or Escape was pressed.
# Példa
const text = script.noteTextEditSelectedText();
const aiPrompt = "Translate the text to English";
const aiResult = script.aiComplete(aiPrompt + ":\n\n" + text);
var result = script.textDiffDialog("AI Text Tool", "Resulting text", text, aiResult);
script.log(result);
1
2
3
4
5
6
2
3
4
5
6
# Ellenőrizze, hogy létezik-e fájl
# Method call and parameters
/**
* Ellenőrizze, hogy létezik-e fájl
* @param filePath
* @Visszatérés
*/
bool ScriptingService::fileExists(QString &filePath);
1
2
3
4
5
6
2
3
4
5
6
# Example
var result = script.fileExists(filePath);
script.log(result);
1
2
2
# Szöveg olvasása egy fájlból
# Method call and parameters
/**
* 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
2
3
4
5
6
7
8
# Example
if(script.fileExists(filePath)){
var data = script.readFromFile(filePath);
script.log(data);
}
1
2
3
4
2
3
4
# Szöveg írása fájlba
# Method call and parameters
/**
* 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
2
3
4
5
6
7
8
9
# Example
var result = script.writeToFile(filePath, html);
script.log(result);
1
2
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
A QOwnNotes távolról vezérelhető a WebSocketServer használatával.
Please take a look at the example 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. Please take look at the example 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.
# Method call and parameters
/**
* 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
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 |
# Example
// 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
2
3
4
5
6
7
You can also take a look at the examples in highlighting.qml (opens new window).
Crafted by Patrizio Bekerle with ❤️