# Methods and objects QOwnNotes provides

# Uruchamianie zewnętrznego programu w tle

# Wywołanie metody i parametry

/**
  * Nakładka QML, aby rozpocząć odłączony proces
  *
  * @param executablePath ścieżka do pliku wykonywalnego
  * @param parameters lista ciągów parametrów
  * @param callbackIdentifier identyfikator do użycia w funkcji onDetachedProcessCallback() (opcjonalnie)
  * @param callbackParameter dodatkowy parametr dla pętli itp. (opcjonalnie)
  * @param processData dane zapisywane do procesu w przypadku użycia wywołania zwrotnego (opcjonalnie)
  * @param workingDirectory katalog roboczy do wykonania procesu (opcjonalnie, działa tylko bez wywołania zwrotnego)
  * @zwróć prawdę w przypadku sukcesu, w przeciwnym razie fałsz
  */
bool startDetachedProcess(QString executablePath, parametry QStringList,
                             QString callbackIdentifier, QVariant callbackParameter,
                             QByteArray processData, QString workingDirectory);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Przykład

Prosty przykład:

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

Uruchamianie wielu procesów:

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

Może zechcesz rzucić okiem na przykład custom-actions.qml (opens new window), callback.qml (opens new window) lub execute-command-after-note-update.qml (opens new window).

Możesz również przyjrzeć się haczykowi onDetachedProcessCallback.

# Uruchamiam zewnętrzny program i czekam na wyjście

# Wywołanie metody i parametry

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

# Przykład

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

Może zechcesz rzucić okiem na przykład encryption-keybase.qml (opens new window).

# Pobieranie ścieżki bieżącego folderu notatek

# Wywołanie metody i parametry

/**
 * QML wrapper to get the current note folder path
 *
 * @return the path of the current note folder
 */
QString currentNoteFolderPath();
1
2
3
4
5
6

# Przykład

var path = script.currentNoteFolderPath();
1

Może zechcesz rzucić okiem na przykład absolute-media-links.qml (opens new window).

# Pobieranie aktualnej notatki

# Wywołanie metody i parametry

/**
 * QML wrapper, aby uzyskać bieżącą notatkę
 *
 * @returns {NoteApi} bieżący obiekt notatki
 */
NoteApi currentNote();
1
2
3
4
5
6

# Przykład

var note = script.currentNote();
1

Może zechcesz rzucić okiem na przykład custom-actions.qml (opens new window).

# Logowanie do widżetu dziennika

# Wywołanie metody i parametry

/**
 * QML wrapper to log to the log widget
 *
 * @param text
 */
void log(QString text);
1
2
3
4
5
6

# Przykład

script.log("my text");
1

# Pobieranie adresu URL do ciągu znaków

# Wywołanie metody i parametry

/**
 * QML wrapper to download an url and returning it as text
 *
 * @param url
 * @return {QString} the content of the downloaded url
 */
QString downloadUrlToString(QUrl url);
1
2
3
4
5
6
7

# Przykład

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

Może zechcesz rzucić okiem na przykład insert-headline-with-link-from-github-url.qml (opens new window).

# Wywołanie metody i pobieranie adresu URL do folderu multimediów

# Wywołanie metody i parametry

/**
 * QML wrapper to download an url to the media folder and returning the media
 * url or the markdown image text of the media relative to the current note
 *
 * @param {QString} url
 * @param {bool} returnUrlOnly if true only the media url will be returned (default false)
 * @return {QString} the media markdown or url
 */
QString downloadUrlToMedia(QUrl url, bool returnUrlOnly);
1
2
3
4
5
6
7
8
9

# Przykład

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

Może zechcesz rzucić okiem na przykład paste-latex-image.qml (opens new window).

# Wstawianie pliku multimedialnego do folderu multimediów

# Wywołanie metody i parametry

/**
  * Opakowanie QML do wstawienia pliku multimedialnego do folderu multimediów i powrotu
  * adres URL multimediów lub tekst obrazu przeceny multimediów w stosunku do bieżącej notatki
  *
  * @param {QString} mediaFilePath
  * @param {bool} returnUrlTylko jeśli true zostanie zwrócony tylko adres URL mediów (domyślnie false)
  * @return {QString} znacznik lub adres URL mediów
  */
QString ScriptingService::insertMediaFile(QString mediaFilePath,
                                         bool returnUrlOnly);
1
2
3
4
5
6
7
8
9
10

# Przykład

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

Może zechcesz rzucić okiem na przykład scribble.qml (opens new window).

# Wstawianie pliku załącznika do folderu załączników

# Wywołanie metody i parametry

 * 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

# Przykład

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

# Ponowne generowanie podglądu notatki

Odświeża podgląd notatki.

# Wywołanie metody i parametry

/**
 * Regenerates the note preview
 */
QString ScriptingService::regenerateNotePreview();
1
2
3
4

# Przykład

script.regenerateNotePreview();
1

Może zechcesz rzucić okiem na przykład scribble.qml (opens new window).

# Rejestrowanie akcji niestandardowej

# Wywołanie metody i parametry

/**
 * Rejestruje akcję niestandardową
 *
 * @param identyfikator identyfikator akcji
 * @param menuText tekst widoczny w menu
 * @param buttonText tekst widoczny na przycisku
 * (żaden przycisk nie będzie widoczny, jeśli jest pusty)
 * @param icon ścieżka pliku ikony lub nazwa ikony motywu freedesktop
 * listę ikon znajdziesz tutaj:
 * https://specyfikacje.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
 * @param useInNoteEditContextMenu jeśli true użyj akcji w edycji notatki
 * menu kontekstowe (domyślnie: false)
 * @param hideButtonInToolbar jeśli prawda, przycisk nie będzie pokazywany w
 * niestandardowy pasek narzędzi akcji (domyślnie: fałsz)
 * @param useInNoteListContextMenu jeśli true użyj akcji na liście notatek
 * menu kontekstowe (domyślnie: false)
 */
void ScriptingService::registerCustomAction (identyfikator QString,
                                            Menu QStringTekst,
                                            Przycisk QStringTekst,
                                            ikona QString,
                                            bool useInNoteEditContextMenu,
                                            bool hideButtonInToolbar,
                                            bool useInNoteListContextMenu);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

TIP

Możesz także przypisać lokalne i globalne skróty do swoich działań niestandardowych w ustawieniach skrótów.

WARNING

Pamiętaj, że ikony motywów freedesktop (opens new window) są w większości dostępne tylko pod Linuksem. Więc jeśli naprawdę chcesz użyć ikony pod macOS lub Windows musisz dostarczyć go ze swoim skryptem. Aby uzyskać ścieżkę skryptu, aby ustawić właściwą ścieżkę dla swojej ikony, możesz użyć właściwości scriptDirPath property.

# Przykład

importuj QtQml 2.0
import QOwnNotesTypes 1.0

Skrypt {
    /**
     * Inicjuje akcje niestandardowe
     */
    funkcja init() {
        // dodaj niestandardową akcję bez przycisku
        script.registerCustomAction("mycustomaction1", "Tekst menu");

        // dodaj niestandardową akcję za pomocą przycisku
        script.registerCustomAction("mycustomaction2", "Tekst menu", "Tekst przycisku");

        // dodaj niestandardową akcję z przyciskiem i ikoną motywu freedesktop
        script.registerCustomAction("mycustomaction3", "Tekst menu", "Tekst przycisku", "zadanie-nowe");

        // dodaj niestandardową akcję z przyciskiem i ikoną z pliku
        script.registerCustomAction("mycustomaction4", "Tekst menu", "Tekst przycisku", "/usr/share/icons/breeze/actions/24/view-calendar-tasks.svg");
    }

    /**
     * Ta funkcja jest wywoływana po uruchomieniu niestandardowej akcji
     * w menu lub przyciskiem
     *
     * @param identyfikator string identyfikator zdefiniowany w registerCustomAction
     */
    function customActionInvoked(identyfikator) {
        przełącznik (identyfikator) {
            przypadek „mojaniestandardowa1”:
                script.log("Akcja 1");
            przerwanie;
            przypadek "moja niestandardowa akcja2":
                script.log("Akcja 2");
            przerwanie;
            przypadek "moja niestandardowa akcja3":
                script.log("Akcja 3");
            przerwanie;
            przypadek „mojeniestandardowe4”:
                script.log("Akcja 4");
            przerwanie;
        }
    }
}
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

Aby uzyskać więcej przykładów, zobacz custom-actions.qml (opens new window).

TIP

Możesz również wyzwolić akcję niestandardową po uruchomieniu aplikacji z parametrem --action customAction_<identifier>. Aby uzyskać więcej informacji, spójrz na Wyzwalaj działania menu po uruchomieniu.

# Rejestracja etykiety

# Wywołanie metody i parametry

/**
  * Rejestruje etykietę do pisania
  *
  * @param identyfikator identyfikator etykiety
  * @param text tekst widoczny na etykiecie (opcjonalnie)
  */
void ScriptingService::registerLabel(Identyfikator QString, tekst QString);
1
2
3
4
5
6
7

# Przykład

script.registerLabel("html-label", "<strong>Silny</strong> tekst HTML<br />z trzema liniami<br />i <a href='https://www.qownnotes.org'>linkiem do strony internetowej<//2>.");

script.registerLabel("long-label", "inny bardzo długi tekst, inny bardzo długi tekst, inny bardzo długi tekst, inny bardzo długi tekst, inny bardzo długi tekst, inny bardzo długi tekst, inny bardzo długi tekst, inny bardzo długi tekst , kolejny bardzo długi tekst, kolejny bardzo długi tekst, kolejny bardzo długi tekst, który będzie zawijany");

script.registerLabel("przeciwetykieta");
1
2
3
4
5

The labels will be visible in the Scripting panel, which you need to enable in the Window / Panels menu.

W etykietach można używać zarówno zwykłego tekstu, jak i html. W etykietach można używać zarówno zwykłego tekstu, jak i html.

Następnie możesz rzucić okiem na przykładowy skrypt scripting-label-demo.qml (opens new window).

# Ustawianie tekstu zarejestrowanej etykiety

# Metoda wywołania i parametry

/**
  * Ustawia tekst zarejestrowanej etykiety
  *
  * @param identyfikator identyfikator etykiety
  * @param text tekst pokazany na etykiecie
  */
void ScriptingService::setLabelText(Identyfikator QString, tekst QString);
1
2
3
4
5
6
7

# Przykład

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

W etykietach można używać zarówno zwykłego tekstu, jak i html. Tekst będzie do wyboru i linki można kliknąć.

Następnie możesz rzucić okiem na przykładowy skrypt scripting-label-demo.qml (opens new window).

# Tworzenie nowej notatki

# Wywołanie metody i parametry

/**
 * Tworzy nową notatkę
 *
 * @param text the note text
 */
void ScriptingService::createNote(QString text);
1
2
3
4
5
6

# Przykład

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

Może zechcesz rzucić okiem na przykład custom-actions.qml (opens new window).

TIP

wyłączyłeś, że nagłówek notatki określa nazwę pliku notatki, musisz później samodzielnie zmienić nazwę pliku notatki, na przykład:

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

# Dostęp do schowka

# Wywołanie metody i parametry

/**
 * Zwraca zawartość schowka jako tekst lub html
 *
 * @param asHtml returns the clipboard content as html instead of text
 */
QString ScriptingService::clipboard(bool asHtml);
1
2
3
4
5
6

# Przykład

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

Może zechcesz rzucić okiem na przykład custom-actions.qml (opens new window).

# Napisz tekst do notatki edytuj tekst

# Wywołanie metody i parametry

/**
 * Zapisuje tekst w bieżącej pozycji kursora w edycji tekstu notatki
 *
 * @param text
 */
void ScriptingService::noteTextEditWrite(QString text);
1
2
3
4
5
6

# Przykład

// napisz tekst do notatki edytuj tekst
script.noteTextEditWrite("My custom text");
1
2

Możesz spojrzeć na akcję niestandardową transformTextRot13 na przykładzie custom-actions.qml (opens new window).

Możesz użyć tego razem z noteTextEditSelectAll, aby nadpisać cały tekst bieżącej notatki.

# Przeczytaj zaznaczony tekst w edycji tekstu notatki

# Wywołanie metody i parametry

/**
 * Czyta zaznaczony tekst w edycji tekstu notatki
 *
 * @return
 */
QString ScriptingService::noteTextEditSelectedText();
1
2
3
4
5
6

# Przykład

// read the selected text from the note text edit
var text = script.noteTextEditSelectedText();
1
2

Możesz spojrzeć na akcję niestandardową transformTextRot13 na przykładzie custom-actions.qml (opens new window).

# Zaznacz cały tekst w edycji tekstu notatki

# Wywołanie metody i parametry

/**
 * Zaznacza cały tekst w edycji tekstu notatki
 */
void ScriptingService::noteTextEditSelectAll();
1
2
3
4

# Przykład

script.noteTextEditSelectAll();
1

Możesz użyć tego razem z noteTextEditWrite, aby nadpisać cały tekst bieżącej notatki.

# Wybierz bieżący wiersz w edycji tekstu notatki

# Wywołanie metody i parametry

/**
  * Wybiera bieżącą linię w edycji tekstu notatki
  */
void ScriptingService::noteTextEditSelectCurrentLine();
1
2
3
4

# Przykład

script.noteTextEditSelectCurrentLine();
1

# Wybierz bieżące słowo w edycji tekstu notatki

# Wywołanie metody i parametry

/**
 * Wybiera bieżące słowo w edycji tekstu notatki
 */
void ScriptingService::noteTextEditSelectCurrentWord();
1
2
3
4

# Przykład

script.noteTextEditSelectCurrentWord();
1

# Ustaw aktualnie zaznaczony tekst w edycji tekstu notatki

# Wywołanie metody i parametry

/**
 * Ustawia aktualnie zaznaczony tekst w edycji tekstu notatki
 *
 * @param start
 * @param end
 */
void ScriptingService::noteTextEditSetSelection(int start, int end);
1
2
3
4
5
6
7

# Przykład

// rozszerza aktualny wybór o jeden znak
script.noteTextEditSetSelection(
    script.noteTextEditSelectionStart() - 1,
    script.noteTextEditSelectionEnd() + 1);
1
2
3
4

# Uzyskaj pozycję początkową bieżącego zaznaczenia w edycji tekstu notatki

# Wywołanie metody i parametry

/**
 * Zwraca pozycję początkową bieżącego zaznaczenia w edycji tekstu notatki
 */
int ScriptingService::noteTextEditSelectionStart();
1
2
3
4

# Przykład

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

# Uzyskaj pozycję końcową bieżącego zaznaczenia w edycji tekstu notatki

# Wywołanie metody i parametry

/**
 * Zwraca pozycję początkową bieżącego zaznaczenia w edycji tekstu notatki
 */
int ScriptingService::noteTextEditSelectionStart();
1
2
3
4

# Przykład

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

# Zwraca pozycję początkową bieżącego zaznaczenia w edycji tekstu notatki

# Wywołanie metody i parametry

/**
 * Ustawia kursor tekstowy w edycji tekstu notatki w określonej pozycji
 * 0 would be the beginning of the note
 * special case: -1 would be the end of the note
 *
 * @param position
 */
void ScriptingService::noteTextEditSetCursorPosition(int position);
1
2
3
4
5
6
7
8

# Przykład

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

# Uzyskaj aktualną pozycję kursora tekstowego w edycji tekstu notatki

# Metoda wywołania i parametry

/**
 * Zwraca bieżącą pozycję kursora tekstowego w edycji tekstu notatki
 * 0 would be the beginning of the note
 */
int ScriptingService::noteTextEditCursorPosition();
1
2
3
4
5

# Przykład

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

# Przeczytaj bieżące słowo z edycji tekstu notatki

# Wywołanie metody i parametry

/**
  * Czyta bieżące słowo w edycji tekstu notatki
  *
 * @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

# Przykład

// odczytaj bieżące słowo w tekście notatki edytuj
var text = script.noteTextEditCurrentWord();
1
2

Może zechcesz rzucić okiem na przykład autocompletion.qml (opens new window).

# Sprawdź, czy platforma to Linux, OS X czy Windows

# Wywołanie metody i parametry

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

# Przykład

if (script.platformIsLinux()) {
    // Will be executed only if under Linux
}
1
2
3

# Oznacz bieżącą notatkę

# Wywołanie metody i parametry

/**
  * Oznacza bieżącą notatkę znacznikiem o nazwie tagName
 *
 * @param tagName
 */
void ScriptingService::tagCurrentNote(QString tagName);
CONTEXTREQUEST

1
2
3
4
5
6
7
8

# Przykład

// dodaj znacznik "ulubionych" do bieżącej notatki
script.tagCurrentNote("favorite");
1
2

Możesz spojrzeć na akcję niestandardową favoriteNote na przykładzie favorite-note.qml (opens new window).

# Utwórz lub pobierz tag według nazwy listy nawigacyjnej

# Wywołanie metody i parametry

/**
  * Pobiera lub tworzy tag na podstawie jego „listy okruszków” nazw tagów
  * Element nameList[0] byłby najwyżej w drzewie (z parentId: 0)
  *
  * @param nameList
  * @param createMissing {bool} jeśli true (domyślnie) wszystkie brakujące tagi zostaną utworzone
  * @return TagApi obiekt najgłębszego tagu na liście okruszków w nazwie
  */
TagApi *ScriptingService::getTagByNameBreadcrumbList(
     const QStringList &nameList, bool createMissing);
1
2
3
4
5
6
7
8
9
10

# Przykład

// tworzy wszystkie tagi do 3 poziomu i zwraca obiekt tagu dla
// tag "level3", który będzie wyglądał tak w drzewie tagów:
// level1 > level2 > level3
var tag = script.getTagByNameBreadcrumbList(["level1", "level2", "level3"]);
1
2
3
4

# Wyszukaj tagi według nazwy

# Wywołanie metody i parametry

/**
  * Pobiera wszystkie tagi, przeszukując podciągi w polu nazwy
  *
  * @param name {QString} nazwa do wyszukania
  * @return {QStringList} lista nazw znaczników
  */
QStringList ScriptingService::searchTagsByName(nazwa QString);
1
2
3
4
5
6
7

# Przykład

// wyszukuje wszystkie tagi zawierające słowo gra
var tags = script.searchTagsByName("game");
1
2

Może zechcesz rzucić okiem na przykład autocompletion.qml (opens new window).

# Szukaj notatek według tekstu notatki

# Wywołanie metody i parametry

/**
  * Zwraca listę identyfikatorów wszystkich notatek z określonym tekstem w tekście notatki
  *
  * Niestety nie ma łatwego sposobu na użycie QList<NoteApi*> w QML, więc my
  * może przenosić tylko identyfikatory banknotów
  *
* @return {QList<int>} list of note ids
 */
QList<int> ScriptingService::fetchNoteIdsByNoteTextPart(QString text);
1
2
3
4
5
6
7
8
9

# Przykład

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

Może zechcesz rzucić okiem na przykład unique-note-id.qml (opens new window).

# Dodaj niestandardowy arkusz stylów

# Wywołanie metody i parametry

/**
 * Dodaje niestandardowy arkusz stylów do aplikacji
 *
 * @param stylesheet
 */
void ScriptingService::addStyleSheet(QString stylesheet);
1
2
3
4
5
6

# Przykład

// zwiększ tekst na liście notatek
script.addStyleSheet("QTreeWidget#noteTreeWidget {font-size: 30px;}");
1
2

Może zechcesz rzucić okiem na przykład custom-stylesheet.qml (opens new window).

Możesz uzyskać nazwy widżetów z *.ui to pliki, na przykład główne okno mainwindow.ui (opens new window).

Dokumentacja Qt (na przykład QMainWindow (opens new window)) może pomóc Ci zobaczyć, jak widżety są ze sobą powiązane (wyszukaj Dziedziczy na stronach).

Podstawowym widżetem dla prawie wszystkiego jest QWidget (opens new window). Więc po prostu stylizuj QWidget za pomocą na przykład QWidget {background-color: black; kolor: biały;} oznaczałoby, że wszystko ma czarne tło i biały kolor pierwszego planu.

::: Wskazówka To style.qss (opens new window) z qdarkstyle (opens new window) może być również dobrym punktem odniesienia dla stylów, które można zmienić. :::

Spójrz na Informacje o arkuszu stylów (opens new window), aby dowiedzieć się, jakie style są dostępne.

Jeśli chcesz wstawić style do podglądu HTML, aby zmienić sposób wyświetlania podglądu notatek, spójrz na notetomarkdownhtmlhak.

TIP

Jeśli rzeczywiście chcesz zobaczyć, jak wyglądają okna dialogowe i jakie są ich nazwy, możesz pobrać Qt Creator (opens new window) i otworzyć w nim pliki *.ui.

# Ponowne ładowanie silnika skryptów

# Wywołanie metody i parametry

/**
 * Reloads the scripting engine
 */
void ScriptingService::reloadScriptingEngine();
1
2
3
4

# Przykład

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

# Pobieranie notatki według nazwy pliku

# Wywołanie metody i parametry

/**
  * Pobiera notatkę według nazwy pliku
  *
  * @param fileName ciąg nazwy pliku notatki (obowiązkowe)
  * @param noteSubFolderId całkowity identyfikator podfolderu notatki
  * @return NoteApi*
  */
NoteApi* ScriptingService::fetchNoteByFileName(QString fileName,
                                                 int notePodFolderId);
1
2
3
4
5
6
7
8
9

# Przykład

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

# Pobieranie notatki według jej identyfikatora

# Wywołanie metody i parametry

/**
 * Pobiera notatkę według swojego identyfikatora
 *
 * @param id int the id of the note
 * @return NoteApi*
 */
NoteApi* ScriptingService::fetchNoteById(int id);
1
2
3
4
5
6
7

# Przykład

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

Może zechcesz rzucić okiem na przykład export-notes-as-one-html.qml (opens new window).

# Sprawdzanie, czy notatka istnieje według nazwy pliku

# Wywołanie metody i parametry

/**
 * Sprawdza, czy plik notatki istnieje według nazwy pliku
 *
 * @param fileName string the file name of the note (mandatory)
 * @param ignoreNoteId integer id of a note to ignore in the check
 * @param noteSubFolderId integer id of the note subfolder
 * @return bool
 */
bool ScriptingService::noteExistsByFileName(QString fileName,
                                            int ignoreNoteId,
                                            int noteSubFolderId);
1
2
3
4
5
6
7
8
9
10
11

# Przykład

// sprawdź, czy notatka istnieje, ale zignoruj identyfikator „note”
script.noteExistsByFileName("my note.md", note.id);
1
2

Może zechcesz rzucić okiem na przykład use-tag-names-in-filename.qml (opens new window).

# Copying text into the clipboard

# Wywołanie metody i parametry

/**
 * Kopiuje tekst do schowka jako zwykły tekst lub dane mime html
 *
 * @param text string text to put into the clipboard
 * @param asHtml bool if true the text will be set as html mime data
 */
void ScriptingService::setClipboardText(QString text, bool asHtml);
1
2
3
4
5
6
7

# Przykład

// skopiuj tekst do schowka
script.setClipboardText("text to copy");
1
2

Może zechcesz rzucić okiem na przykład selected-markdown-to-bbcode.qml (opens new window).

# Skoki do notatki

# Wywołanie metody i parametry

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

# Przykład

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

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

# Przeskakiwanie do podfolderu notatki

# Wywołanie metody i parametry

/**
  * Przeskakuje do podfolderu notatki
  *
  * @param noteSubFolderPath {QString} ścieżka podfolderu względem folderu notatek
  * @param separator {QString} separator między częściami ścieżki, domyślnie "/"
  * @return true, jeśli skok się powiódł
  */
bool ScriptingService::jumpToNoteSubFolder(const QString &noteSubFolderPath,
                                             separator QString);
1
2
3
4
5
6
7
8
9

# Przykład

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

Możesz utworzyć nowy podfolder notatek w bieżącym podfolderze, dzwoniąc mainWindow.createNewNoteSubFolder.

# Wyświetlam okno wiadomości informacyjnej

# Wywołanie metody i parametry

/**
 * Wyświetla okno komunikatu informacyjnego
 *
 * @param text
 * @param title (optional)
 */
void ScriptingService::informationMessageBox(QString text, QString title);
1
2
3
4
5
6
7

# Przykład

// show a information message box
script.informationMessageBox("The text I want to show", "Some optional title");
1
2

# Wyświetlanie okna wiadomości z pytaniem

# Wywołanie metody i parametry

/**
 * Wyświetla okno wiadomości z pytaniem
 *
 * 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

# Przykład

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

Aby uzyskać informacje o przyciskach, zobacz StandardButton (opens new window).

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

# Pokazywanie okna dialogowego z otwartym plikiem

# Wywołanie metody i parametry

/**
 * Pokazuje okno dialogowe otwierania pliku
 *
 * @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

# Przykład

// pokaż okno dialogowe otwierania pliku
var fileName = script.getOpenFileName("Please select an image", "/home/user/images", "Images (*.png *.xpm *.jpg)");
1
2

# Wyświetlam okno dialogowe zapisywania pliku

# Wywołanie metody i parametry

/**
 * Pokazuje okno dialogowe zapisywania pliku
 *
 * @param caption (optional)
 * @param dir (optional)
 * @param filter (optional)
 * @return QString
 */
QString ScriptingService::getSaveFileName(QString caption, QString dir,
                                            QString filter);
1
2
3
4
5
6
7
8
9
10

# Przykład

// show a save file dialog
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).

# Rejestrowanie zmiennych ustawień skryptu

Musisz zdefiniować zmienne ustawień jako właściwości w skrypcie i zarejestruj je we właściwości o nazwie settingsVariables.

Użytkownik może następnie ustawić te właściwości w ustawieniach skryptu.

# Przykład

// you have to define your registered variables so you can access them later
property string myString;
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": "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

Ponadto możesz zastąpić settingsVariables specjalną funkcją registerSettingsVariables() w następujący sposób:

# Przykład

/**
 * Ponownie rejestruje zmienne ustawień
 *
 * Użyj tej metody, jeśli chcesz użyć kodu do zastąpienia zmiennych, takich jak ustawienie
 * wartości domyślne w zależności od systemu operacyjnego.
 */
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).

# Przechowywanie i ładowanie trwałych zmiennych

# Wywołanie metody i parametry

/**
* Przechowuje stałą zmienną
  * Te zmienne są dostępne globalnie we wszystkich skryptach
  * Użyj znaczącego prefiksu w swoim kluczu, takiego jak „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

# Przykład

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

Upewnij się, że używasz znaczącego prefiksu w swoim kluczu, takiego jak PersistentVariablesTest/myVar, ponieważ zmienne są dostępne ze wszystkich skryptów.

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

# Ładowanie zmiennych ustawień aplikacji

# Wywołanie metody i parametry

/**
 * Ładuje zmienną ustawień aplikacji
 *
 * @param key {QString}
 * @param defaultValue {QVariant} zwróć wartość, jeśli ustawienie nie istnieje (opcjonalnie)
 * @return
 */
QVariant ScriptingService::getApplicationSettingsVariable(const QString &key,
                                                            const QVariant &defaultValue);
1
2
3
4
5
6
7
8
9

# Przykład

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

Pamiętaj, że ustawienia faktycznie mogą być puste, musisz uważać o tym sam. defaultValue jest używany tylko wtedy, gdy ustawienie w ogóle nie istnieje.

# Tworzenie katalogu pamięci podręcznej

Możesz buforować pliki w domyślnej lokalizacji pamięci podręcznej systemu.

# Wywołanie metody i parametry

/**
 * Zwraca katalog pamięci podręcznej dla skryptu
 *
 * @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

# Przykład

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

# Czyszczenie katalogu pamięci podręcznej

Katalog pamięci podręcznej skryptu można wyczyścić, przekazując jego nazwę do metody clearCacheDir().

# Wywołanie metody i parametry

/**
 * Clears the cache directory for a script
 *
 * @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

# Przykład

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

# Czytanie ścieżki do katalogu twojego skryptu

Jeśli chcesz uzyskać ścieżkę do katalogu, w którym znajduje się twój skrypt, aby na przykład załadować inne pliki, musisz się zarejestrować property string scriptDirPath;. Ta właściwość zostanie ustawiona ze ścieżką do katalogu skryptu.

# Przykład

import QtQml 2.0
import QOwnNotesTypes 1.0

Script {
    // ścieżka do katalogu skryptu zostanie ustawiona tutaj
    property string scriptDirPath;

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

# Konwersja separatorów ścieżek na natywne

# Wywołanie metody i parametry

/**
  * Zwraca ścieżkę z separatorami „/” zamienionymi na separatory, które są
  * odpowiednie dla bazowego systemu operacyjnego.
 *
 * 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

# Przykład

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

# Konwersja separatorów ścieżek z natywnych

# Wywołanie metody i parametry

/**
  * Zwraca ścieżkę używając '/' jako separatora plików.
 * 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

# Przykład

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

# Pobieranie natywnego separatora katalogów

# Wywołanie metody i parametry

/**
 * Zwraca natywny separator katalogu "/" lub "\" w systemie Windows
 *
 * @return
 */
QString ScriptingService::dirSeparator();
1
2
3
4
5
6

# Przykład

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

# Uzyskanie listy ścieżek wszystkich wybranych notatek

# Wywołanie metody i parametry

/**
 * Zwraca listę ścieżek wszystkich wybranych notatek
 *
 * @return {QStringList} list of selected note paths
 */
QStringList ScriptingService::selectedNotesPaths();
1
2
3
4
5
6

# Przykład

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

# Uzyskanie listy identyfikatorów wszystkich wybranych notatek

# Wywołanie metody i parametry

/**
  * Zwraca listę identyfikatorów wszystkich wybranych notatek
  *
  * @return {QList<int>} lista wybranych identyfikatorów notatek
  */
QList<int> ScriptingService::selectedNotesIds();
1
2
3
4
5
6

# Przykład

// zwraca listę identyfikatorów wszystkich wybranych notatek
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).

# Wywoływanie akcji menu

# Wywołanie metody i parametry

/**
 * Uruchamia akcję menu
 *
 * @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

# Przykład

// przełącz tryb tylko do odczytu
script.triggerMenuAction("actionAllow_note_editing");

// wyłącz tryb tylko do odczytu
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). Po prostu wyszukaj tytuł menu w języku angielskim. Pamiętaj, że te teksty mogą się zmieniać w czasie.

# Otwieranie okna dialogowego wprowadzania danych z polem wyboru

# Wywołanie metody i parametry

/**
  * Otwiera okno dialogowe wprowadzania danych z polem wyboru
  *
  * @param title {QString} tytuł okna dialogowego
  * @param label {QString} tekst etykiety okna dialogowego
  * @param items {QStringList} lista elementów do wyboru
  * @param bieżący indeks {int} elementu, który należy wybrać (domyślnie: 0)
  * @param editable {bool} jeśli true tekst w oknie dialogowym można edytować (domyślnie: false)
  * @return {QString} tekst wybranego elementu
  */
QString ScriptingService::inputDialogGetItem(
         const QString &title, const QString &label, const QStringList &items,
         int bieżący, bool edytowalny);
1
2
3
4
5
6
7
8
9
10
11
12
13

# Przykład

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

# Otwieranie okna dialogowego wprowadzania danych z edycją linii

# Wywołanie metody i parametry

/**
  * Otwiera okno dialogowe wprowadzania danych z edycją linii
  *
  * @param title {QString} tytuł okna dialogowego
  * @param label {QString} tekst etykiety okna dialogowego
  * @param text {QString} tekst w oknie dialogowym (opcjonalnie)
  * @zwrócić
  */
QString ScriptingService::inputDialogGetText(
         const QString i tytuł, const QString i etykieta, const QString i tekst);
1
2
3
4
5
6
7
8
9
10

# Przykład

var result = script.inputDialogGetText(
    "line edit", "Proszę podać nazwę", "current text");
script.log(result);
1
2
3

# Sprawdzanie, czy plik istnieje

# Wywołanie metody i parametry

/**
 * Sprawdź, czy plik istnieje
 * @param filePath
 * @return
 */
bool ScriptingService::fileExists(QString &filePath);
1
2
3
4
5
6

# Przykład

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

# Czytanie tekstu z pliku

# Wywołanie metody i parametry

/**
  * Czytaj tekst z pliku
  *
  * @param filePath {QString} ścieżka pliku do załadowania
  * Kodek @param codec {QString} (domyślnie: UTF-8)
  * @zwróć dane pliku lub null, jeśli plik nie istnieje
  */
QString ScriptingService::readFromFile(const QString &filePath, const QString &codec)
1
2
3
4
5
6
7
8

# Przykład

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

# Zapisywanie tekstu do pliku

# Wywołanie metody i parametry

/**
 * Zapisuje tekst do pliku
 *
 * @param filePath {QString}
 * @param data {QString}
 * @param createParentDirs {bool} optional (default: false)
 * @return
 */
bool ScriptingService::writeToFile(const QString &filePath, const QString &data, bool createParentDirs);
1
2
3
4
5
6
7
8
9

# Przykład

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

# Zapisuje tekst do pliku

Możesz zdalnie sterować QOwnNotes za pomocą WebSocketServer.

Please take a look at the example websocket-server.qml (opens new window). Możesz przetestować serwer gniazd, łącząc się z nim w Websocket test (opens new window).

Możesz także słuchać gniazd za pomocą WebSocket. Please take look at the example websocket-client.qml (opens new window).

Pamiętaj, że potrzebujesz biblioteki QML websocket Qt zainstalowany, aby z tego korzystać. Na przykład pod Ubuntu Linux możesz zainstalować qml-module-qtwebsockets.

# Dodawanie reguły wyróżniania dla edytora

Możesz bezpośrednio wstrzyknąć reguły podświetlania do edytora, definiując wyrażenia regularne i przypisując je do stanu podświetlania.

# Metoda wywołania i parametry

/**
 * Dodaje wyróżnioną regułę dla podświetlenia składni edytora
 *
 * @param pattern {QString} wyrażenie regularne do wyróżnienia
 * @param shouldContain {QString} ciąg, który musi być zawarty w podświetlonym tekście, aby wzorzec mógł być analizowany
 * @param state {int} stan podświetlania składni, który ma być używany
 * @param capturingGroup {int} grupa przechwytywania dla wzorca, która ma być używana do wyróżniania (domyślnie: 0)
 * @param maskedGroup {int} grupa przechwytująca dla wzorca do użycia maskowania (domyślnie: 0)
 */
void ScriptingService::addHighlightingRule(const QString &pattern,
                                           const QString &shouldContain, 
                                           int state, 
                                           int capturingGroup, 
                                           int maskedGroup);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Wyróżnianie stanów

Nazwa Nr.
NoState -1
Łącze 0
Obraz 3
CodeBlock 4
CodeBlockComment 5
Kursywa 7
Pogrubienie 8
Lista 9
Komentarz 11
H1 12
H2 13
H3 14
H4 15
H5 16
H6 17
BlockQuote 18
HorizontalRuler 21
Tabela 22
InlineCodeBlock 23
MaskedSyntax 24
CurrentLineBackgroundColor 25
BrokenLink 26
FrontmatterBlock 27
TrailingSpace 28
CheckBoxUnChecked 29
CheckBoxChecked 30
StUnderline 31

# Przykład

// Highlight a text line like "BLOCK: some text" as blockquote (state 18)
script.addHighlightingRule("^BLOCK: (.+)", "BLOCK:", 18);

// Mask out (state 24) all characters after 32 characters in a line
// capturingGroup 1 means the expression from the first bracketed part of the pattern will be highlighted
// maskedGroup -1 means that no masking should be done
script.addHighlightingRule("^.{32}(.+)", "", 24, 1, -1);
1
2
3
4
5
6
7

You can also take a look at the examples in highlighting.qml (opens new window).