# 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);
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"]);
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]}`);
}
}
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);
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");
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();
2
3
4
5
6
# Przykład
var path = script.currentNoteFolderPath();
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();
2
3
4
5
6
# Przykład
var note = script.currentNote();
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);
2
3
4
5
6
# Przykład
script.log("my text");
# 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);
2
3
4
5
6
7
# Przykład
var html = script.downloadUrlToString("https://www.qownnotes.org");
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);
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)}");
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);
2
3
4
5
6
7
8
9
10
# Przykład
var markdown = script.insertMediaFile("/path/to/your/image.png");
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);
2
3
4
5
6
7
8
9
10
11
12
13
# Przykład
var markdown = script.insertAttachmentFile("/path/to/your/file.png");
# Ponowne generowanie podglądu notatki
Odświeża podgląd notatki.
# Wywołanie metody i parametry
/**
* Regenerates the note preview
*/
QString ScriptingService::regenerateNotePreview();
2
3
4
# Przykład
script.regenerateNotePreview();
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);
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;
}
}
}
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);
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");
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);
2
3
4
5
6
7
# Przykład
script.setLabelText("counter-label", "counter text");
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).
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).
# Tworzenie nowej notatki
# Wywołanie metody i parametry
/**
* Tworzy nową notatkę
*
* @param text the note text
*/
void ScriptingService::createNote(QString text);
2
3
4
5
6
# Przykład
script.createNote("My note headline\n===\n\nMy text");
Może zechcesz rzucić okiem na przykład 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');
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);
2
3
4
5
6
# Przykład
var clipboardText = script.clipboard();
var clipboardHtml = script.clipboard(true);
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);
2
3
4
5
6
# Przykład
// napisz tekst do notatki edytuj tekst
script.noteTextEditWrite("My custom text");
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();
2
3
4
5
6
# Przykład
// read the selected text from the note text edit
var text = script.noteTextEditSelectedText();
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();
2
3
4
# Przykład
script.noteTextEditSelectAll();
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();
2
3
4
# Przykład
script.noteTextEditSelectCurrentLine();
# 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();
2
3
4
# Przykład
script.noteTextEditSelectCurrentWord();
# 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);
2
3
4
5
6
7
# Przykład
// rozszerza aktualny wybór o jeden znak
script.noteTextEditSetSelection(
script.noteTextEditSelectionStart() - 1,
script.noteTextEditSelectionEnd() + 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();
2
3
4
# Przykład
script.log(script.noteTextEditSelectionStart());
# 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();
2
3
4
# Przykład
script.log(script.noteTextEditSelectionEnd());
# 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);
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);
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();
2
3
4
5
# Przykład
script.log(script.noteTextEditCursorPosition());
# 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);
2
3
4
5
6
7
8
9
# Przykład
// odczytaj bieżące słowo w tekście notatki edytuj
var text = script.noteTextEditCurrentWord();
2
Może zechcesz rzucić okiem na przykład autocompletion.qml (opens new window).
# Read the current block from the note text edit
# Wywołanie metody i parametry
/**
* Reads the current block in the note text edit
*
* @return
*/
QString ScriptingService::noteTextEditCurrentBlock();
2
3
4
5
6
# Przykład
// Read the current block in the note text edit
var text = script.noteTextEditCurrentBlock();
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.
# Wywołanie metody i parametry
/**
* QML wrapper to use the AI Completer
*
* @param prompt
* @return {QString} the result of the completer
*/
QString ScriptingService::aiComplete(const QString& prompt);
2
3
4
5
6
7
# Przykład
// Ask the currently selected AI model to complete the prompt
var text = script.aiComplete("Tell me how do you feel today?");
2
You may want to take a look at the example ai-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();
2
3
# Przykład
if (script.platformIsLinux()) {
// Will be executed only if under Linux
}
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
2
3
4
5
6
7
8
# Przykład
// dodaj znacznik "ulubionych" do bieżącej notatki
script.tagCurrentNote("favorite");
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);
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"]);
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);
2
3
4
5
6
7
# Przykład
// wyszukuje wszystkie tagi zawierające słowo gra
var tags = script.searchTagsByName("game");
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);
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
});
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);
2
3
4
5
6
# Przykład
// zwiększ tekst na liście notatek
script.addStyleSheet("QTreeWidget#noteTreeWidget {font-size: 30px;}");
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();
2
3
4
# Przykład
// reload the scripting engine
script.reloadScriptingEngine();
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);
2
3
4
5
6
7
8
9
# Przykład
// fetch note by file name
script.fetchNoteByFileName("my note.md");
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);
2
3
4
5
6
7
# Przykład
// fetch note by id
script.fetchNoteById(243);
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);
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);
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);
2
3
4
5
6
7
# Przykład
// skopiuj tekst do schowka
script.setClipboardText("text to copy");
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);
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);
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 ¬eSubFolderPath,
separator QString);
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");
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);
2
3
4
5
6
7
# Przykład
// show a information message box
script.informationMessageBox("The text I want to show", "Some optional title");
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);
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);
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);
2
3
4
5
6
7
8
9
10
# Example
// pokaż okno dialogowe otwierania pliku
var fileName = script.getOpenFileName("Please select an image", "/home/user/images", "Images (*.png *.xpm *.jpg)");
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);
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)");
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"},
}
];
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"
}
}
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);
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"));
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);
2
3
4
5
6
7
8
9
# Przykład
// load and log an application settings variable
script.log(script.getApplicationSettingsVariable("gitExecutablePath"));
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;
2
3
4
5
6
7
# Przykład
// create the cache directory for my-script-id
var cacheDirForScript = script.cacheDir("my-script-id");
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;
2
3
4
5
6
7
# Przykład
// clear cache directory of my-script-id
script.clearCacheDir("my-script-id");
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);
}
}
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);
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"));
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);
2
3
4
5
6
7
8
9
# Przykład
// will return "c:/winnt/system32" on Windows
script.log(script.fromNativeDirSeparators("c:\\winnt\\system32"));
2
# Pobieranie natywnego separatora katalogów
# Wywołanie metody i parametry
/**
* Zwraca natywny separator katalogu "/" lub "\" w systemie Windows
*
* @return
*/
QString ScriptingService::dirSeparator();
2
3
4
5
6
# Przykład
// will return "\" on Windows
script.log(script.dirSeparator());
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();
2
3
4
5
6
# Przykład
// returns a list of the paths of all selected notes
script.log(script.selectedNotesPaths());
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();
2
3
4
5
6
# Przykład
// zwraca listę identyfikatorów wszystkich wybranych notatek
script.log(script.selectedNotesIds());
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);
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);
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);
2
3
4
5
6
7
8
9
10
11
12
13
An empty string will be returned, if Cancel
was clicked or Escape
was pressed.
# Przykład
var result = script.inputDialogGetItem(
"combo box", "Please select an item", ["Item 1", "Item 2", "Item 3"]);
script.log(result);
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);
2
3
4
5
6
7
8
9
10
An empty string will be returned, if Cancel
was clicked or Escape
was pressed.
# Przykład
var result = script.inputDialogGetText(
"line edit", "Proszę podać nazwę", "current text");
script.log(result);
2
3
# Opening an input dialog with a multi-line text edit
# Wywołanie metody i parametry
/**
* 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);
2
3
4
5
6
7
8
9
10
An empty string will be returned, if Cancel
was clicked or Escape
was pressed.
# Przykład
var result = script.inputDialogGetMultiLineText(
"multi-line edit", "Please enter a text", "current text");
script.log(result);
2
3
# Sprawdzanie, czy plik istnieje
# Metoda wywołania i parametry
/**
* Sprawdź, czy plik istnieje
* @param filePath
* @return
*/
bool ScriptingService::fileExists(QString &filePath);
2
3
4
5
6
# Przykład
var result = script.fileExists(filePath);
script.log(result);
2
# Czytanie tekstu z pliku
# Method call and parameters
/**
* 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)
2
3
4
5
6
7
8
# Example
if(script.fileExists(filePath)){
var data = script.readFromFile(filePath);
script.log(data);
}
2
3
4
# Zapisywanie tekstu do pliku
# Method call and parameters
/**
* 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);
2
3
4
5
6
7
8
9
# Example
var result = script.writeToFile(filePath, html);
script.log(result);
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.
# Method call and parameters
/**
* 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);
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 |
# Example
// 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);
2
3
4
5
6
7
You can also take a look at the examples in highlighting.qml (opens new window).