# Methoden en objecten die QOwnNotes biedt

# Het starten van een extern programma op de achtergrond

# Methodeaanroep en parameters

/**
  * QML-wrapper om een losgekoppeld proces te starten
  *
  * @param executable Pad het pad naar het uitvoerbare bestand
  * @param parameters een lijst met parameterreeksen
  * @param callbackIdentifier een ID die moet worden gebruikt in de functie onDetachedProcessCallback () (optioneel)
  * @param callbackParameter een extra parameter voor loops en dergelijke (optioneel)
  * @param processData-gegevens die naar het proces worden geschreven als de callback wordt gebruikt (optioneel)
  * @return true bij succes, anders false
  */
bool startDetachedProcess (QString executablePath, QStringList parameters,
                             QString callbackIdentifier, QVariant callbackParameter,
                             QByteArray processData);
1
2
3
4
5
6
7
8
9
10
11
12
13

# Voorbeeld

Eenvoudig voorbeeld:

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

Veel processen uitvoeren:

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

Misschien wilt u het voorbeeld eens bekijken custom-actions.qml (opens new window), callback.qml (opens new window) of execute-command-after-note-update.qml (opens new window).

Misschien wil je ook eens kijken naar de onDetachedProcessCallback hook.

TIP

U kunt ook lokale en algemene snelkoppelingen aan uw aangepaste acties toewijzen in de Shortcuts settings.

# Start een extern programma en wacht op de uitvoer

# Methodeaanroep en parameters

/**
  * QML-wrapper om een synchroon proces te starten
  *
  * @param executable Pad het pad naar het uitvoerbare bestand
  * @param parameters een lijst met parameterreeksen
  * @param data de data die naar het proces worden geschreven (optioneel)
  * @return de tekst die door het proces is geretourneerd
QByteArray startSynchronousProcess (QString executablePath, QStringList-parameters, QByteArray-gegevens);
1
2
3
4
5
6
7
8

# Voorbeeld

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

Misschien wilt u het voorbeeld eens bekijken encryption-keybase.qml (opens new window).

# Het pad ophalen van de huidige notitiemap

# Methodeaanroep en parameters

/**
  * QML-wrapper om het huidige pad naar de notitiemap op te halen
  *
  * @return het pad van de huidige notitiemap
  */
QString currentNoteFolderPath ();
1
2
3
4
5
6

# Voorbeeld

var path = script.currentNoteFolderPath();
1

Misschien wilt u het voorbeeld eens bekijken absolute-media-links.qml (opens new window).

# De huidige notitie ophalen

# Methodeaanroep en parameters

/**
  * QML-wrapper om de huidige notitie te krijgen
  *
  * @ retourneert {NoteApi} het huidige nootobject
  */
OpmerkingApi currentNote ();
1
2
3
4
5
6

# Voorbeeld

var note = script.currentNote();
1

Misschien wilt u het voorbeeld eens bekijken custom-actions.qml (opens new window).

# Inloggen op de log-widget

# Methodeaanroep en parameters

/**
  * QML-wrapper om in te loggen op de log-widget
  *
  * @param tekst
  */
ongeldig logboek (QString-tekst);
1
2
3
4
5
6

# Voorbeeld

script.log("my text");
1

# Het downloaden van een url naar een string

# Methodeaanroep en parameters

/**
  * QML-wrapper om een url te downloaden en als tekst terug te sturen
  *
  * @param url
  * @return {QString} de inhoud van de gedownloade url
  */
QString downloadUrlToString (QUrl url);
1
2
3
4
5
6
7

# Voorbeeld

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

Misschien wilt u het voorbeeld eens bekijken insert-headline-with-link-from-github-url.qml (opens new window).

# Een url downloaden naar de mediamap

# Methodeaanroep en parameters

/**
  * QML-wrapper om een url naar de mediamap te downloaden en de media terug te sturen
  * url of de markdown-afbeeldingstekst van de media ten opzichte van de huidige notitie
  *
  * @param {QString} url
  * @param {bool} returnUrlAlleen als waar alleen de media-URL wordt geretourneerd (standaard false)
  * @return {QString} de media-markdown of url
  */
QString downloadUrlToMedia (QUrl url, bool returnUrlOnly);
1
2
3
4
5
6
7
8
9

# Voorbeeld

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

Misschien wilt u het voorbeeld eens bekijken paste-latex-image.qml (opens new window).

# Een mediabestand invoegen in de mediamap

# Methodeaanroep en parameters

/**
  * QML-wrapper om een mediabestand in de mediamap in te voegen en terug te keren
  * de media-url of de afgeprijsde afbeeldingstekst van de media ten opzichte van de huidige notitie
  *
  * @param {QString} mediaFilePath
  * @param {bool} returnUrlAlleen als waar alleen de media-URL wordt geretourneerd (standaard false)
  * @return {QString} de media-markdown of url
  */
QString ScriptingService :: insertMediaFile (QString mediaFilePath,
                                         bool returnUrlOnly);
1
2
3
4
5
6
7
8
9
10

# Voorbeeld

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

Misschien wilt u het voorbeeld eens bekijken scribble.qml (opens new window).

# Het notitievoorbeeld opnieuw genereren

Vernieuwt het notitievoorbeeld.

# Methodeaanroep en parameters

/**
  * Genereert het notitievoorbeeld opnieuw
  */
QString ScriptingService::regenerateNotePreview();
1
2
3
4

# Voorbeeld

script.regenerateNotePreview();
1

Misschien wilt u het voorbeeld eens bekijken scribble.qml (opens new window).

# Registering a custom action

# Methodeaanroep en parameters

**
 * Registreert een aangepaste actie
 *
 * @param identifier de identifier van de actie
 * @param menu Tekst de tekst die in het menu wordt weergegeven
 * @param button Sms de tekst die in de knop wordt weergegeven
 * (er wordt geen knop weergegeven als deze leeg is)
 * @param icon het pictogrambestandspad of de naam van een freedesktop-themapictogram
 * u vindt hier een lijst met pictogrammen:
 * https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
 * @param useInNoteEditContextMenu indien true, gebruik dan de actie in de notitiebewerking
 * contextmenu (standaard: false)
 * @param hideButtonInToolbar indien waar zal de knop niet getoond worden in het
 * aangepaste actiewerkbalk (standaard: false)
 * @param useInNoteListContextMenu indien waar, gebruik dan de actie in de notitielijst
 * contextmenu (standaard: false)
 */
void ScriptingService :: registerCustomAction (QString identifier,
                                            QString menuText,
                                            QString-knop Tekst,
                                            QString-pictogram,
                                            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

# Voorbeeld

// voeg een aangepaste actie toe zonder een knop
script.registerCustomAction ("mycustomaction1", "Menutekst");

// voeg een aangepaste actie toe met een knop
script.registerCustomAction ("mycustomaction1", "Menutekst", "Knoptekst");

// voeg een aangepaste actie toe met een knop en een freedesktop-themapictogram
script.registerCustomAction ("mycustomaction1", "Menutekst", "Knoptekst", "taak-nieuw");

// voeg een aangepaste actie toe met een knop en een pictogram uit een bestand
script.registerCustomAction ("mycustomaction1", "Menutekst", "Knoptekst", "/usr/share/icons/breeze/actions/24/view-calendar-tasks.svg");
1
2
3
4
5
6
7
8
9
10
11

U kunt dan de identifier met functie customActionInvoked gebruiken in een script zoals custom-actions.qml (opens new window).

# Een label registreren

# Methodeaanroep en parameters

/**
  * Registreert een label om naar te schrijven
  *
  * @param identifier de identifier van het label
  * @param tekst de tekst die in het label wordt getoond (optioneel)
  */
void ScriptingService :: registerLabel (QString-ID, QString-tekst);
1
2
3
4
5
6
7

# Voorbeeld

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

De labels zijn zichtbaar in de scriptdock-widget.

U kunt zowel platte tekst als html in de labels gebruiken. De tekst kan worden geselecteerd en er kan op links worden geklikt.

Misschien wilt u het voorbeeld eens bekijken scripting-label-demo.qml (opens new window).

# De tekst van een geregistreerd label instellen

# Methodeaanroep en parameters

/**
  * Stelt de tekst van een geregistreerd label in
  *
  * @param identifier de identifier van het label
  * @param tekst de tekst die in het label wordt weergegeven
  */
void ScriptingService :: setLabelText (QString-ID, QString-tekst);
1
2
3
4
5
6
7

# Voorbeeld

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

U kunt zowel platte tekst als html in de labels gebruiken. De tekst kan worden geselecteerd en er kan op links worden geklikt.

Misschien wilt u het voorbeeld eens bekijken scripting-label-demo.qml (opens new window).

# Een nieuwe notitie maken

# Methodeaanroep en parameters

/**
  * Maakt een nieuwe notitie
  *
  * @param sms de notitietekst
  */
void ScriptingService :: createNote (QString-tekst);
1
2
3
4
5
6

# Voorbeeld

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

Misschien wilt u het voorbeeld eens bekijken custom-actions.qml (opens new window).

# Toegang tot het klembord

# Methodeaanroep en parameters

/**
  * Retourneert de inhoud van het klembord als tekst of html
  *
  * @param asHtml geeft de inhoud van het klembord terug als html in plaats van tekst
  */
QString ScriptingService :: clipboard (bool asHtml);
1
2
3
4
5
6

# Voorbeeld

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

Misschien wilt u het voorbeeld eens bekijken custom-actions.qml (opens new window).

# Schrijf tekst naar de tekst van de notitie

# Methodeaanroep en parameters

/**
  * Schrijft tekst naar de huidige cursorpositie in de tekstbewerking van de notitie
  *
  * @param tekst
  */
void ScriptingService :: noteTextEditWrite (QString-tekst);
1
2
3
4
5
6

# Voorbeeld

// schrijf tekst naar de notitie tekst bewerken
script.noteTextEditWrite ("Mijn aangepaste tekst");
1
2

Misschien wilt u de aangepaste actie transformTextRot13 bekijken in het voorbeeld custom-actions.qml (opens new window).

U kunt dit samen met noteTextEditSelectAll gebruiken om de hele tekst van de huidige notitie te overschrijven.

# Lees de geselecteerde tekst in de tekstbewerking van de notitie

# Methodeaanroep en parameters

/**
  * Leest de geselecteerde tekst in de tekstbewerking van de notitie
  *
  * @return
  */
QString ScriptingService :: noteTextEditSelectedText ();
1
2
3
4
5
6

# Voorbeeld

// lees de geselecteerde tekst uit de notitietekst bewerk 
var text = script.noteTextEditSelectedText ();
1
2

Misschien wilt u de aangepaste actie transformTextRot13 in voorbeeld custom-actions.qml (opens new window) bekijken.

# Selecteer alle tekst in de tekstbewerking van de notitie

# Methodeaanroep en parameters

/**
  * Selecteert alle tekst in de tekstbewerking van de notitie
  */
leegte ScriptingService :: noteTextEditSelectAll ();
1
2
3
4

# Voorbeeld

script.noteTextEditSelectAll();
1

U kunt dit samen met noteTextEditWrite gebruiken om de hele tekst van de huidige notitie te overschrijven.

# Selecteer de huidige regel in de tekstbewerking van de notitie

# Methodeaanroep en parameters

/**
 * Selects the current line in the note text edit
 */
void ScriptingService::noteTextEditSelectCurrentLine();
1
2
3
4

# Voorbeeld

script.noteTextEditSelectCurrentLine();
1

# Selecteer de huidige woord in de tekstbewerking van de notitie

# Methodeaanroep en parameters

/**
  * Selecteert de huidige regel in de tekstbewerking van de notitie
  */
void ScriptingService :: noteTextEditSelectCurrentWord ();
1
2
3
4

# Voorbeeld

script.noteTextEditSelectCurrentWord();
1

# Stel de momenteel geselecteerde tekst in bij het bewerken van de notitietekst

# Methodeaanroep en parameters

/**
  * Stelt de momenteel geselecteerde tekst in de notitietekst in
  *
  * @param start
  * @param einde
  */
void ScriptingService :: noteTextEditSetSelection (int start, int end);
1
2
3
4
5
6
7

# Voorbeeld

// breidt de huidige selectie uit met één teken
script.noteTextEditSetSelection (
     script.noteTextEditSelectionStart () - 1,
     script.noteTextEditSelectionEnd () + 1);
1
2
3
4

# Verkrijg de startpositie van de huidige selectie in de notitietekst

# Methodeaanroep en parameters

/**
  * Geeft als resultaat de startpositie van de huidige selectie in de notitietekst
  */
int ScriptingService::noteTextEditSelectionStart();
1
2
3
4

# Voorbeeld

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

# Haal de eindpositie van de huidige selectie op in de tekstbewerking van de notitie

# Methodeaanroep en parameters

/**
 * Returns the end position of the current selection in the note text edit
 */
int ScriptingService::noteTextEditSelectionEnd();
1
2
3
4

# Voorbeeld

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

# Set the text cursor in the note text edit to a certain position

# Methodeaanroep en parameters

/**
  * Zet de tekstcursor in de tekstbewerking van de notitie op een bepaalde positie
  * 0 zou het begin van de notitie zijn
  * speciaal geval: -1 zou het einde van de notitie zijn
  *
  * @param positie
  */
void ScriptingService :: noteTextEditSetCursorPosition (int positie);
1
2
3
4
5
6
7
8

# Voorbeeld

// spring naar het 11e teken in de notitie
script.noteTextEditSetCursorPosition(10);

// spring naar het einde van de notitie
script.noteTextEditSetCursorPosition(-1);
1
2
3
4
5

# Haal de huidige positie van de tekstcursor op in de tekstbewerking van de notitie

# Methodeaanroep en parameters

/**
  * Geeft de huidige positie van de tekstcursor terug in de notitietekst
  * 0 zou het begin van de notitie zijn
  */
int ScriptingService::noteTextEditCursorPosition();
1
2
3
4
5

# Voorbeeld

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

# Lees het huidige woord uit de tekst van de notitie

# Methodeaanroep en parameters

/**
  * Leest het huidige woord in de notitietekst
  *
  * @param withPreviousCharacters krijgen in het begin ook meer tekens
  * om tekens als "@" te krijgen die dat niet zijn
  * woordtekens
  * @return
  */
QString ScriptingService::noteTextEditCurrentWord(bool withPreviousCharacters);
1
2
3
4
5
6
7
8
9

# Voorbeeld

// lees het huidige woord in de tekst van de notitie
var text = script.noteTextEditCurrentWord();
1
2

Misschien wilt u het voorbeeld eens bekijken autocompletion.qml (opens new window).

# Controleer of het platform Linux, OS X of Windows is

# Methodeaanroep en parameters

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

# Voorbeeld

// lees het huidige woord in de tekst van de notitie
var text = script.noteTextEditCurrentWord();
1
2

# Tag de huidige notitie

# Methodeaanroep en parameters

/**
  * Label de huidige notitie met een tag met de naam tagName
  *
  * @param tagName
  */
void ScriptingService :: tagCurrentNote (QString tagnaam);
1
2
3
4
5
6

# Voorbeeld

// voeg een "favoriete" tag toe aan de huidige notitie
script.tagCurrentNote ("favoriet");
1
2

Misschien wilt u de aangepaste actie favoriteNote in het voorbeeld favorite-note.qml (opens new window) bekijken.

# Maak of haal een tag op met de naam van de broodkruimellijst

# Methodeaanroep en parameters

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

# Voorbeeld

// maakt alle tags tot het 3e niveau en retourneert het tag-object voor
// tag "level3", die er zo uitziet in de tagboom:
// level1 & gt; level2 & gt; niveau 3
var tag = script.getTagByNameBreadcrumbList (["level1", "level2", "level3"]);
1
2
3
4

# Zoek naar tags op naam

# Methodeaanroep en parameters

/**
  * Haalt alle tags op door een substring-zoekopdracht uit te voeren in het naamveld
  *
  * @param naam {QString} naam om naar te zoeken
  * @return {QStringList} lijst met tagnamen
  */
QStringList ScriptingService :: searchTagsByName (QString-naam);
1
2
3
4
5
6
7

# Voorbeeld

// zoekt naar alle tags met het woordspel erin
var tags = script.searchTagsByName("game");
1
2

Misschien wilt u het voorbeeld eens bekijken autocompletion.qml (opens new window).

# Zoek naar notities op notitietekst

# Methodeaanroep en parameters

/**
  * Retourneert een lijst met notitie-id's van alle notities met een bepaalde tekst in de notitietekst
  *
  * Helaas is er geen gemakkelijke manier om een QList <NoteApi*> in QML te gebruiken, dus wij
  * kan alleen de notitie-ID's overdragen
  *
  * @return {QList <int>} lijst met notitie-id's
  */
QList <int> ScriptingService :: fetchNoteIdsByNoteTextPart (QString-tekst);
1
2
3
4
5
6
7
8
9

# Voorbeeld

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

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

    // doe iets met de notitie
});

1
2
3
4
5
6
7
8

Misschien wilt u het voorbeeld eens bekijken unique-note-id.qml (opens new window).

# Voeg een aangepast stylesheet toe

# Methodeaanroep en parameters

/**
  * Voegt een aangepast stylesheet toe aan de applicatie
  *
  * @param stylesheet
  */
void ScriptingService :: addStyleSheet (QString-stylesheet);
1
2
3
4
5
6

# Voorbeeld

// maak de tekst in de notitielijst groter
script.addStyleSheet("QTreeWidget # noteTreeWidget {font-size: 30px;}");
1
2

Misschien wilt u het voorbeeld eens bekijken custom-stylesheet.qml (opens new window).

U kunt de objectnamen uit de *.ui -bestanden halen, bijvoorbeeld mainwindow.ui (opens new window).

Bekijk Style Sheet Reference (opens new window) voor een referentie van welke stijlen beschikbaar zijn.

Als u stijlen in html-voorbeeld wilt injecteren om de manier waarop notities worden weergegeven te wijzigen, kijk dan naar notetomarkdownhtmlhook.

# Herladen van de script-engine

# Methodeaanroep en parameters

/**
  * Herlaadt de script-engine
  */
void ScriptingService::reloadScriptingEngine();
1
2
3
4

# Voorbeeld

// herlaad de script-engine
script.reloadScriptingEngine();
1
2

# Een notitie ophalen op basis van de bestandsnaam

# Methodeaanroep en parameters

/**
  * Haalt een notitie op met de bestandsnaam
  *
  * @param fileName string de bestandsnaam van de notitie (verplicht)
  * @param noteSubFolderId geheel getal-id van de notitie-submap
  * @return OpmerkingApi *
  */
NoteApi * ScriptingService::fetchNoteByFileName (QString bestandsnaam,
                                                 int noteSubFolderId);
1
2
3
4
5
6
7
8
9

# Voorbeeld

// fetch note by file name
script.fetchNoteByFileName("my note.md");
1
2

# Een notitie ophalen op basis van zijn ID

# Methodeaanroep en parameters

/**
  * Haalt een notitie op met zijn id
  *
  * @param id int de id van de notitie
  * @return OpmerkingApi *
  */
NoteApi * ScriptingService :: fetchNoteById (int id);
1
2
3
4
5
6
7

# Voorbeeld

// haal notitie op met id
script.fetchNoteById(243);
1
2

Misschien wilt u het voorbeeld eens bekijken export-notes-as-one-html.qml (opens new window).

# Controleren of een notitie bestaat op basis van de bestandsnaam

# Methodeaanroep en parameters

/**
  * Controleert of een notitiebestand bestaat op basis van de bestandsnaam
  *
  * @param fileName string de bestandsnaam van de notitie (verplicht)
  * @param ignoreNoteId integer-id van een notitie die bij de controle moet worden genegeerd
  * @param noteSubFolderId geheel getal-id van de notitie-submap
  * @return bool
  */
bool ScriptingService :: noteExistsByFileName (QString bestandsnaam,
                                             int ignoreNoteId,
                                             int noteSubFolderId);
1
2
3
4
5
6
7
8
9
10
11

# Voorbeeld

// controleer of opmerking bestaat, maar negeer de id van "note"
script.noteExistsByFileName("my note.md", note.id);
1
2

Misschien wilt u het voorbeeld eens bekijken use-tag-names-in-filename.qml (opens new window).

# Tekst naar het klembord kopiëren

# Methodeaanroep en parameters

/ **
  * Kopieert tekst naar het klembord als platte tekst of html mime-gegevens
  *
  * @param tekstreeks tekst om op het klembord te plaatsen
  * @param asHtml bool indien true wordt de tekst ingesteld als html mime-gegevens
  * /
void ScriptingService::setClipboardText(QString text, bool asHtml);
1
2
3
4
5
6
7

# Voorbeeld

// kopieer tekst naar het klembord
script.setClipboardText("text to copy");
1
2

Misschien wilt u het voorbeeld eens bekijken selected-markdown-to-bbcode.qml (opens new window).

# Naar een notitie springen

# Methodeaanroep en parameters

/**
  * Stelt de huidige notitie in als de notitie zichtbaar is in de notitielijst
  *
  * @param note Note Api-notitie om naar te springen
  */
void ScriptingService::setCurrentNote(NoteApi *note);
1
2
3
4
5
6

# Voorbeeld

// spring naar de notitie
script.setCurrentNote (opmerking);
1
2

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

# Springen naar een submap van een notitie

# Methodeaanroep en parameters

/**
  * Springt naar een submap voor notities
  *
  * @param noteSubFolderPath {QString} pad van de submap, relatief aan de notitiemap
  * @param scheidingsteken {QString} scheidingsteken tussen delen van het pad, standaard "/"
  * @return waar als de sprong succesvol was
  */
bool ScriptingService :: jumpToNoteSubFolder (const QString & amp; noteSubFolderPath,
                                             QString-scheidingsteken);
1
2
3
4
5
6
7
8
9

# Voorbeeld

// spring naar de submap notitie "een submap"
script.jumpToNoteSubFolder ("een submap");

// spring naar de submap "sub" van de notitie in "een submap"
script.jumpToNoteSubFolder ("een submap / sub");
1
2
3
4
5

TIP

U kunt een nieuwe submap voor notities maken in de huidige submap door mainWindow.createNewNoteSubFolder aan te roepen.

# Een informatieberichtvenster weergeven

# Methodeaanroep en parameters

/**
  * Toont een informatieberichtvenster
  *
  * @param tekst
  * @param title (optioneel)
  */
void ScriptingService :: informationMessageBox (QString-tekst, QString-titel);
1
2
3
4
5
6
7

# Voorbeeld

// toon een informatieberichtvenster
script.informationMessageBox ("De tekst die ik wil laten zien", "Een optionele titel");
1
2

# Er wordt een berichtvenster met een vraag weergegeven

# Methodeaanroep en parameters

/**
  * Toont een vraagberichtvenster
  *
  * Zie voor informatie over knoppen:
  * https://doc.qt.io/qt-5/qmessagebox.html#StandardButton-enum
  *
  * @param tekst
  * @param title (optioneel)
  * @param buttons knoppen die getoond moeten worden (optioneel)
  * @param defaultButton standaardknop die wordt geselecteerd (optioneel)
  * @return id van ingedrukte knop
 */
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

# Voorbeeld

// toon een vraagberichtvenster met een sollicitatie- en een helpknop
// zie: https://doc.qt.io/qt-5/qmessagebox.html#StandardButton-enum
var resultaat = script.questionMessageBox (
    "De tekst die ik wil laten zien", "Een optionele titel", 0x01000000 | 0x02000000, 0x02000000);
script.log (resultaat);
1
2
3
4
5

Zie voor informatie over knoppen StandardButton (opens new window).

Zie voor informatie over knoppen StandardButton (opens new window).

# Een open bestandsdialoog weergeven

# Methodeaanroep en parameters

**
  * Toont een open bestandsdialoog
  *
  * @param caption (optioneel)
  * @param dir (optioneel)
  * @param filter (optioneel)
  * @return QString
  * /
QString ScriptingService::getOpenFileName(QString caption, QString dir,
                                            QString filter);
1
2
3
4
5
6
7
8
9
10

# Voorbeeld

// toon een open bestandsdialoog
var fileName = script.getOpenFileName("Please select an image", "/home/user/images", "Images (*.png *.xpm *.jpg)");
1
2

# Een zekere bestandsdialoog weergeven

# Methodeaanroep en parameters

/**
  * Toont een dialoogvenster voor het opslaan van bestanden
  *
  * @param caption (optioneel)
  * @param dir (optioneel)
  * @param filter (optioneel)
  * @return QString
  */
QString ScriptingService::getSaveFileName (QString caption, QString dir,
                                             QString-filter);
1
2
3
4
5
6
7
8
9
10

# Voorbeeld

// toon een dialoogvenster voor het opslaan van bestanden
var fileName = script.getSaveFileName("Please select HTML file to save", "output.html", "HTML (*.html)");
1
2

Misschien wilt u het voorbeeld eens bekijken export-notes-as-one-html.qml (opens new window).

# Variabelen voor scriptinstellingen registreren

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

De gebruiker kan deze eigenschappen vervolgens instellen in de scriptinstellingen.

# Voorbeeld

// u moet uw geregistreerde variabelen definiëren zodat u ze later kunt openen
property string myString;
property bool myBoolean;
property string myText;
property int myInt;
property string myFile;
property string mySelection;

// registreer uw instellingsvariabelen zodat de gebruiker ze kan instellen in de scriptinstellingen
// gebruik deze eigenschap als je dat niet nodig hebt

// // helaas is er geen QVariantHash in Qt, we kunnen alleen
// QVariantMap (dat geen willekeurige volgorde heeft) of QVariantList
// (die op zijn minst willekeurig kan worden besteld)

eigenschapsvariantinstellingen Variabelen: [
     {
         "identifier": "myString",
         "name": "Ik ben een lijnbewerker",
         "description": "Voer een geldige string in:",
         "type": "string",
         "default": "Mijn standaardwaarde",
     },
     {
         "identifier": "myBoolean",
         "name": "Ik ben een selectievakje",
         "description": "Een beschrijving",
         "text": "Vink dit selectievakje aan",
         "type": "boolean",
         "default": true,
     },
     {
         "identifier": "myText",
         "name": "Ik ben tekstvak",
         "description": "Voer uw tekst in:",
         "typ Text",
         "default": "Dit kan een hele lange tekst zijn \ nmet meerdere regels.",
     },
     {
         "identifier": "myInt",
         "name": "Ik ben een nummerkiezer",
         "description": "Voer een getal in:",
         "type": "geheel getal",
         "standaard": 42,
     },
     {
         "identifier": "myFile",
         "name": "Ik ben een bestandskiezer",
         "description": "Selecteer het bestand:",
         "type": "bestand",
         "default": "pandoc",
     },
     {
         "identifier": "mySelection",
         "name": "Ik ben een itemkiezer",
         "description": "Selecteer een item:",
         "type": "selectie",
         "default": "option2",
         "items": {"option1": "Tekst voor optie 1", "option2": "Tekst voor optie 2", "option3": "Tekst voor optie 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

Bovendien kun je de settingsVariables overschrijven met een speciale functie registerSettingsVariables() zoals deze:

# Voorbeeld

/**
  * Registreert de instellingsvariabelen opnieuw
  *
  * Gebruik deze methode als u code wilt gebruiken om uw variabelen te overschrijven, zoals instelling
  * standaardwaarden zijn afhankelijk van het besturingssysteem.
 */
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

Misschien wilt u het voorbeeld eens bekijken variables.qml (opens new window).

# Persistente variabelen opslaan en laden

# Methodeaanroep en parameters

/**
  * Slaat een permanente variabele op
  * Deze variabelen zijn wereldwijd toegankelijk via alle scripts
  * Gebruik een betekenisvol voorvoegsel in uw sleutel, zoals "PersistentVariablesTest / myVar"
  *
  * @param sleutel {QString}
  * @param waarde {QVariant}
  */
void ScriptingService :: setPersistentVariable (const QString & amp; key,
                                                 const QVariant & waarde);

/**
  * Laadt een permanente variabele
  * Deze variabelen zijn wereldwijd toegankelijk via alle scripts
  *
  * @param sleutel {QString}
  * @param defaultValue {QVariant} retourwaarde als de instelling niet bestaat (optioneel)
  * @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

# Voorbeeld

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

// load and log persistent variable
script.log(script.getPersistentVariable("PersistentVariablesTest/myVar", "nothing here yet"));
1
2
3
4
5

Zorg ervoor dat u een betekenisvol voorvoegsel in uw sleutel gebruikt, zoals PersistentVariablesTest/myVar, omdat de variabelen toegankelijk zijn vanuit alle scripts.

Misschien wilt u het voorbeeld eens bekijken persistent-variables.qml (opens new window).

# Variabelen voor applicatie-instellingen laden

# Methodeaanroep en parameters

/**
  * Laadt een variabele voor toepassingsinstellingen
  *
  * @param sleutel {QString}
  * @param defaultValue {QVariant} retourwaarde als de instelling niet bestaat (optioneel)
  * @return
  */
QVariant ScriptingService::getApplicationSettingsVariable(const QString &key,
                                                            const QVariant &defaultValue);
1
2
3
4
5
6
7
8
9

# Voorbeeld

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

Houd er rekening mee dat instellingen eigenlijk leeg kunnen zijn, daar moet u zelf voor zorgen. defaultValue wordt alleen gebruikt als de instelling helemaal niet bestaat.

# Een cachemap maken

U kunt bestanden cachen op de standaard cachelocatie van uw systeem.

# Methodeaanroep en parameters

/**
  * Retourneert een cachemap voor een script
  *
  * @param {QString} subDir de submap die moet worden gemaakt en gebruikt
  * @return {QString} het pad naar de cache-map
  */
QString ScriptingService::cacheDir(const QString &subDir) const;
1
2
3
4
5
6
7

# Voorbeeld

// maak de cachemap voor my-script-id
var cacheDirForScript = script.cacheDir("my-script-id");
1
2

# Een cachemap wissen

U kunt de cachebestanden van uw script wissen door de naam door te geven aan clearCacheDir().

# Methodeaanroep en parameters

/**
  * Wist de cachemap voor een script
  *
  * @param {QString} subDir de submap die moet worden gewist
  * @return {bool} true bij succes
  */
bool ScriptingService::clearCacheDir(const QString &subDir) const;
1
2
3
4
5
6
7

# Voorbeeld

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

# Het pad naar de directory van uw script lezen

Als u het pad naar de directory waar uw script is geplaatst, nodig heeft om bijvoorbeeld andere bestanden te laden, moet u een property string scriptDirPath; registreren. Deze eigenschap wordt ingesteld met het pad naar de directory van het script.

# Voorbeeld

importeer QtQml 2.0
importeer QOwnNotesTypes 1.0

Script {
     // het pad naar de directory van het script wordt hier ingesteld
     eigenschap string scriptDirPath;

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

# Padscheidingstekens omzetten in native

# Methodeaanroep en parameters

/**
  * Geeft pad terug met de '/' scheidingstekens geconverteerd naar scheidingstekens die zijn
  * geschikt voor het onderliggende besturingssysteem.
 *
 * 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

# Voorbeeld

// retourneert "c:\winnt\system32" op Windows
script.log (script.toNativeDirSeparators ("c:/winnt/system32"));
1
2

# Padscheidingstekens omzetten van native

# Methodeaanroep en parameters

/**
 * Geeft het pad terug met '/' als bestandseparator.
 * Op Windows, bijvoorbeeld fromNativeDirSeparators("c:\\winnt\\system32")
  * geeft "c: / winnt / system32" terug.
 *
 * @param path
 * @return
 */
QString ScriptingService::fromNativeDirSeparators(QString path);
1
2
3
4
5
6
7
8
9

# Voorbeeld

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

# Het native directoryscheidingsteken ophalen

# Methodeaanroep en parameters

/**
  * Retourneert het native directoryscheidingsteken "/" of "\" in Windows
  *
  * @return
  */
QString ScriptingService :: dirSeparator ();
1
2
3
4
5
6

# Voorbeeld

// retourneert "\" in Windows
script.log(script.dirSeparator());
1
2

# Een lijst ophalen met de paden van alle geselecteerde notities

# Methodeaanroep en parameters

/**
  * Retourneert een lijst met de paden van alle geselecteerde notities
  *
  * @return {QStringList} lijst met geselecteerde notitiepaden
  */
QStringList ScriptingService::selectedNotesPaths();
1
2
3
4
5
6

# Voorbeeld

// retourneert een lijst met de paden van alle geselecteerde notities
script.log(script.selectedNotesPaths());
1
2

Misschien wilt u het voorbeeld eens bekijken external-note-diff.qml (opens new window).

# Een lijst ophalen met de id's van alle geselecteerde notities

# Methodeaanroep en parameters

/**
  * Retourneert een lijst met de id's van alle geselecteerde notities
  *
  * @return {QList <int>} lijst met geselecteerde notitie-id's
  */
QList<int> ScriptingService::selectedNotesIds();
1
2
3
4
5
6

# Voorbeeld

// retourneert een lijst met de paden van alle geselecteerde notities
script.log(script.selectedNotesIds());
1
2

Misschien wilt u het voorbeeld eens bekijken export-notes-as-one-html.qml (opens new window).

# Een menuactie activeren

# Methodeaanroep en parameters

/**
  * Activeert een menuactie
  *
  * @param objectName {QString} objectnaam van de actie die moet worden geactiveerd
  * @param aangevinkt {QString} activeert alleen de actie als aangevinkt-status is
  * anders dan deze parameter (optioneel, kan 0 of 1 zijn)
 */
void ScriptingService::triggerMenuAction(QString objectName, QString checked);

1
2
3
4
5
6
7
8
9

# Voorbeeld

// schakel de alleen-lezen modus in
script.triggerMenuAction("actionAllow_note_editing");

// schakel de alleen-lezen modus uit
script.triggerMenuAction("actionAllow_note_editing", 1);
1
2
3
4
5

Misschien wilt u het voorbeeld eens bekijken disable-readonly-mode.qml (opens new window).

U kunt de objectnamen van de menuactie ophalen uit mainwindow.ui (opens new window).

# Een invoerdialoog openen met een selectievak

# Methodeaanroep en parameters

/**
  * Opent een invoerdialoog met een selectievak
  *
  * @param titel {QString} titel van het dialoogvenster
  * @param label {QString} labeltekst van het dialoogvenster
  * @param items {QStringList} lijst met te selecteren items
  * @param huidige {int} index van het item dat moet worden geselecteerd (standaard: 0)
  * @param bewerkbaar {bool} indien true kan de tekst in het dialoogvenster worden bewerkt (standaard: false)
  * @return {QString} tekst van het geselecteerde 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

# Voorbeeld

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

Misschien wilt u het voorbeeld eens bekijken input-dialogs.qml (opens new window).

# Een invoerdialoog openen met een regelbewerking

# Methodeaanroep en parameters

/**
  * Opent een invoerdialoog met een lijnbewerking
  *
  * @param titel {QString} titel van het dialoogvenster
  * @param label {QString} labeltekst van het dialoogvenster
  * @param tekst {QString} tekst in het dialoogvenster (optioneel)
  * @return
  */
QString ScriptingService::inputDialogGetText(
        const QString &title, const QString &label, const QString &text);
1
2
3
4
5
6
7
8
9
10

# Voorbeeld

var result = script.inputDialogGetText(
    "line edit", "Please enter a name", "current text");
script.log(result);
1
2
3

# Controleren of er een bestand bestaat

# Methodeaanroep en parameters

**
  * Controleer of er een bestand bestaat
  * @param filePath
  * @return
  */
bool ScriptingService::fileExists(QString &filePath);
1
2
3
4
5
6

# Voorbeeld

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

# Tekst uit een bestand lezen

# Methodeaanroep en parameters

/**
  * Lees tekst uit een bestand
  *
  * @param filePath {QString} pad van het te laden bestand
  * @param codec {QString} bestandscodering (standaard: UTF-8)
  * @return de bestandsgegevens of null als het bestand niet bestaat
  */
QString ScriptingService::readFromFile(const QString &filePath, const QString &codec)
1
2
3
4
5
6
7
8

# Voorbeeld

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

# Tekst naar een bestand schrijven

# Methodeaanroep en parameters

/**
  * Schrijft een tekst naar een bestand
  *
  * @param filePath {QString}
  * @param-gegevens {QString}
  * @param createParentDirs {bool} optioneel (standaard: false)
  * @return
  */
bool ScriptingService::writeToFile(const QString &filePath, const QString &data, bool createParentDirs);
1
2
3
4
5
6
7
8
9

# Voorbeeld

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

Misschien wilt u het voorbeeld eens bekijken export-notes-as-one-html.qml (opens new window).

# Werken met websockets

U kunt QOwnNotes op afstand bedienen met WebSocketServer.

Bekijk het voorbeeld eens websocket-server.qml (opens new window). U kunt de socketserver testen door er verbinding mee te maken op Websocket-test (opens new window).

U kunt ook naar sockets luisteren met WebSocket. Kijk alstublieft naar de voorbeeld websocket-client.qml (opens new window).

Onthoud dat u Qt's QML websocket-bibliotheek moet hebben geïnstalleerd om dit te gebruiken. U kunt bijvoorbeeld onder Ubuntu Linux installeren qml-module-qtwebsockets.