# Métodos y objetos que proporciona QOwnNotes

# Iniciar un programa externo en segundo plano

# Llamada y parámetros del método

/**
  * Envoltorio de QML para iniciar un proceso separado
  *
  * @param executablePath la ruta del ejecutable
  * @param parámetros una lista de cadenas de parámetros
  * @param callbackIdentifier un identificador que se usará en la función onDetachedProcessCallback() (opcional)
  * @param callbackParameter un parámetro adicional para bucles o similares (opcional)
  * @param processData datos escritos en el proceso si se utiliza la devolución de llamada (opcional)
  * @param workingDirectory el directorio de trabajo para ejecutar el proceso (opcional, solo funciona sin devolución de llamada)
  * @return verdadero en caso de éxito, falso en caso contrario
  */
bool startDetachedProcess(QString executablePath, parámetros QStringList,
                             QString callbackIdentifier, QVariant callbackParameter,
                             QByteArray processData, QString directorio de trabajo);

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Ejemplo

Ejemplo simple:

script.startDetachedProcess("/ruta/a/mi/programa", ["mi parámetro"]);

Ejecutando muchos procesos:

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

Puede que quiera echar un vistazo al ejemplo custom-actions.qml (opens new window), callback.qml (opens new window) o execute-command-after-note-update.qml (opens new window).

También es posible que desee echar un vistazo al gancho onDetachedProcessCallback.

# Iniciar un programa externo y esperar la salida

# Llamada y parámetros del método

/**
 * Envoltorio de QML para iniciar un proceso sincrónico
 *
 * @param executablePath la ruta del ejecutable
 * @param parameters una lista de cadenas de parámetros
 * @param data los datos que se escribirán en el proceso (opcional)
 * @param workingDirectory el directorio de trabajo para ejecutar el proceso (opcional)
 * @return el texto que devolvió el proceso
QByteArray startSynchronousProcess(QString executablePath, QStringList parameters, QByteArray data, QString workingDirectory);

1
2
3
4
5
6
7
8
9

# Ejemplo

var resultado = script.startSynchronousProcess("/ruta/a/mi/programa", ["mi parámetro"], "datos", "/ruta/en/la/cual/ejecutar");

Puede que quiera echar un vistazo al ejemplo encryption-keybase.qml (opens new window).

# Obtener la ruta de la carpeta de notas actual

# Llamada y parámetros del método

/**
 * Envoltorio de QML para obtener la ruta de la carpeta de notas actual
 *
 * @return la ruta de la carpeta de notas actual
 */
QString currentNoteFolderPath ();

1
2
3
4
5
6

# Ejemplo

var path = script.currentNoteFolderPath();

Puede que quiera echar un vistazo al ejemplo absolute-media-links.qml (opens new window).

# Obtener la nota actual

# Llamada y parámetros del método

/**
 * Envoltorio de QML para obtener la nota actual
 *
 * @returns {NoteApi} el objeto de nota actual
 */
NoteApi currentNote();

1
2
3
4
5
6

# Ejemplo

var note = script.currentNote();

Puede que quiera echar un vistazo al ejemplo custom-actions.qml (opens new window).

# Llamada y parámetros del método

/**
 * Envoltorio de QML para iniciar sesión en el widget de registro
 *
 * @param text texto
 */
void log(QString text);

1
2
3
4
5
6

# Ejemplo

script.log("mi texto");

# Descarga de una URL a una cadena

# Llamada y parámetros del método

/**
 * Envoltorio de QML para descargar una URL y devolverla como texto
 *
 * @param url
 * @return {QString} el contenido de la URL descargada
 */
QString downloadUrlToString(QUrl url);

1
2
3
4
5
6
7

# Ejemplo

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

Puede que quiera echar un vistazo al ejemplo insert-headline-with-link-from-github-url.qml (opens new window).

# Descarga de una URL a la carpeta multimedia

# Llamada y parámetros del método

/**
 * Envoltorio de QML para descargar una URL a la carpeta multimedia y devolver la URL
 * de los medios o el texto de la imagen de Markdown de los medios relativo a la nota actual
 *
 * @param {QString} URL
 * @param {bool} returnUrlOnly si es verdadero, solo se devolverá la URL del medio (por defecto es falso)
 * @return {QString} el Markdown o URL de los medios
 */
QString downloadUrlToMedia(QUrl url, bool returnUrlOnly);

1
2
3
4
5
6
7
8
9

# Ejemplo

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

Puede que quiera echar un vistazo al ejemplo paste-latex-image.qml (opens new window).

# Insertar un archivo multimedia en la carpeta multimedia

# Llamada y parámetros del método

/**
  * Envoltorio de QML para insertar un archivo multimedia en la carpeta multimedia y regresar
  * la URL de medios o el texto de la imagen de Markdown de los medios en relación con la nota actual
  *
  * @param {QString} mediaFilePath
  * @param {bool} returnUrlOnly si es verdadero, solo se devolverá la URL del medio (por defecto es falso)
  * @return {QString} el Markdown o URL de los medios
  */
QString ScriptingService::insertMediaFile (QString mediaFilePath,
                                         bool returnUrlOnly);

1
2
3
4
5
6
7
8
9
10

# Ejemplo

var markdown = script.insertMediaFile("/ruta/a/tu/imagen.png");

Puede que quiera echar un vistazo al ejemplo scribble.qml (opens new window).

# Insertar un archivo adjunto en la carpeta de archivos adjuntos

# Llamada y parámetros del método

 * Envoltorio de QML para instartar un archivo adjunto en la carpeta `attachments`
 * devolviendo la URL del adjunto o el texto de Markdown del adjunto
 * relativo a la nota actual
 *
 * @param {QString} attachmentFilePath
 * @param {QString} fileName para usar en el Markdown
 * @param {bool} returnUrlOnly si es verdadero, solo se devolverá la URL del adjunto
 * (por defecto es falso)
 * @return {QString} el Markdown o URL de los medios
 */
QString ScriptingService::insertAttachmentFile(const QString &attachmentFilePath,
                                               const QString &fileName,
                                               bool returnUrlOnly);

1
2
3
4
5
6
7
8
9
10
11
12
13

# Ejemplo

var markdown = script.insertAttachmentFile("/ruta/a/tu/archivo.png");

# Regenerar la vista previa de la nota

Actualiza la vista previa de la nota.

# Llamada y parámetros del método

/**
 * Regenera la vista previa de la nota
 */
QString ScriptingService::regenerateNotePreview();

1
2
3
4

# Ejemplo

script.regenerateNotePreview();

Puede que quiera echar un vistazo al ejemplo scribble.qml (opens new window).

# Registro de una acción personalizada

# Llamada y parámetros del método

/**
 * Registra una acción personalizada
 *
 * @param identifier el identificador de la acción
 * @param menuText el texto que se muestra en el menú
 * @param button Envía el texto que se muestra en el botón
 * (no se verá ningún botón si está vacío)
 * @param icon la ruta del archivo del icono o el nombre de un icono de tema de freedesktop
 * encontrará una lista de iconos aquí:
 * https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
 * @param useInNoteEditContextMenu si es verdadero, usar la acción del menú contextual
 * de la edición de la nota (por defecto: falso)
 * @param hideButtonInToolbar si es verdadero, el botón no se mostrará en el
 * barra de herramientas de acciones personalizadas (por defecto: falso)
 * @param useInNoteListContextMenu si es verdadero, usar la acción del menú contextual 
 * de la lista de la nota (por defecto: falso)
 */
void ScriptingService:: registerCustomAction (identificador QString,
                                            QString menuText,
                                            QString buttonText,
                                            Icono de 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

También puede asignar accesos directos locales y globales a sus acciones personalizadas en la Configuración de accesos directos.

WARNING

Tenga en cuenta que los iconos de los temas de escritorio gratuitos (opens new window) están disponibles en su mayoría solamente en Linux. Entonces, si realmente desea usar un icono en macOS o Windows, debe proporcionar uno con su script. Para obtener la ruta de su secuencia de comandos para establecer una ruta adecuada para su icono, puede usar la propiedad scriptDirPath.

# Ejemplo

import QtQml 2.0
import QOwnNotesTypes 1.0

Script {
    /**
     * Inicializa las acciones personalizadas
     */
    function init() {
        // añadir una acción personalizada sin un botón
        script.registerCustomAction("miaccionpersonalizada1", "Texto del menú");

        // añadir una acción personalizada con un botón
        script.registerCustomAction("miaccionpersonalizada2", "Texto del menú", "Texto del botón");

        // añadir una acción personalizada con un botón y un icono de un tema de freedesktop
        script.registerCustomAction("miaccionpersonalizada3", "Texto del menú", "Texto del botón", "task-new");

        // añadir una acción personalizada con un botón y un icono desde un archivo
        script.registerCustomAction("miaccionpersonalizada4", "Texto del menú", "Texto del botón", "/usr/share/icons/breeze/actions/24/view-calendar-tasks.svg");
    }

    /**
     * Esta función se invoca cuando se desencadena una acción personalizada
     * en el menú o por medio de un botón
     * 
     * @param identifier string el identificador definido en registerCustomAction
     */
    function customActionInvoked(identifier) {
        switch (identifier) {
            case "miaccionpersonalizada1":
                script.log("Acción 1");
            break;
            case "miaccionpersonalizada2":
                script.log("Acción 2");
            break;
            case "miaccionpersonalizada3":
                script.log("Acción 3");
            break;
            case "miaccionpersonalizada4":
                script.log("Acción 4");
            break;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

Para más ejemplos, por favor revise custom-actions.qml (opens new window).

TIP

También puede activar una acción personalizada después de iniciar la aplicación con el parámetro --action customAction_<identifier>. Para mayor información, por favor consulte Activar acciones del menú después del inicio.

# Registrar una etiqueta

# Llamada y parámetros del método

/**
  * Registra una etiqueta para escribir
  *
  * @param identifier el identificador de la etiqueta
  * @param text el texto que se muestra en la etiqueta (opcional)
  */
void ScriptingService::registerLabel(QString identifier, QString text);

1
2
3
4
5
6
7

# Ejemplo

script.registerLabel("html-label", "Texto HTML <strong>fuerte</strong> <br />con tres líneas<br />y un <a href='https://www.qownnotes.org'>enlace a un sitio web</a>.");

script.registerLabel("long-label", "otro texto muy largo, otro texto muy largo, otro texto muy largo, otro texto muy largo, otro texto muy largo, otro texto muy largo, otro texto muy largo, otro texto muy largo, otro texto muy largo, otro texto muy largo, otro texto muy largo que se envolverá");

script.registerLabel("counter-label");

1
2
3
4
5

Las etiquetas serán visibles en el Panel de secuencia de órdenes, el cual necesita habilitar en el menú Ventanas/Paneles.

Puede utilizar texto sin formato o html en las etiquetas. Se podrá seleccionar el texto y se podrá hacer clic en los enlaces.

Puede que después quiera echar un vistazo al script de ejemplo scripting-label-demo.qml (opens new window).

# Configurar el texto de una etiqueta registrada

# Llamada y parámetros del método

/**
 * Establece el texto de una etiqueta registrada
 *
 * @param identifier el identificador de la etiqueta
 * @param text el texto que se muestra en la etiqueta
 */
void ScriptingService::setLabelText(QString identifier, QString text);

1
2
3
4
5
6
7

# Ejemplo

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

Puede utilizar texto sin formato o html en las etiquetas. Se podrá seleccionar el texto y se podrá hacer clic en los enlaces.

Puede que después quiera echar un vistazo al script de ejemplo scripting-label-demo.qml (opens new window).

TIP

La secuencia de órdenes también soporta enlaces externos, así como enlaces internos en notas, tareas, barajas de tarjetas y más. Es posible que comprenda lo que se admite tomando un vistazo al manejo de URL (opens new window).

# Crear una nota nueva

# Llamada y parámetros del método

/**
 * Crea una nota nueva
 *
 * @param text el texto de la nota
 */
void ScriptingService::createNote(QString text);

1
2
3
4
5
6

# Ejemplo

script.createNote("Titulo de mi nota\n===\n\nMi texto");

Puede que quiera echar un vistazo al ejemplo custom-actions.qml (opens new window).

TIP

Si desactivó que el título de su nota determine el nombre del archivo de la nota, debe luego renombrar archivo de nota por su cuenta de la siguiente manera:

var note = script.currentNote();
note.renameNoteFile('su-nombre-de-archivo');

1
2

# Acceder al portapapeles

# Llamada y parámetros del método

/**
 * Devuelve el contenido del portapapeles como texto o html
 *
 * @param asHtml devuelve el contenido del portapapeles como html en vez de texto
 */
QString ScriptingService::clipboard(bool asHtml);

1
2
3
4
5
6

# Ejemplo

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

1
2

Puede que quiera echar un vistazo al ejemplo custom-actions.qml (opens new window).

# Escribir texto en la edición de texto de la nota

# Llamada y parámetros del método

/**
 * Escribe texto en la posición actual del cursor en la edición de texto de la nota
 *
 * @param text
 */
void ScriptingService::noteTextEditWrite(QString text);

1
2
3
4
5
6

# Ejemplo

// escribir texto en la edición de texto de la nota
script.noteTextEditWrite("Mi texto personalizado");

1
2

Puede que quiera echar un vistazo a la acción personalizada transformTextRot13 en el ejemplo custom-actions.qml (opens new window).

Puede usar esto junto con noteTextEditSelectAll para sobrescribir todo el texto de la nota actual.

# Leer el texto seleccionado en la edición de texto de la nota

# Llamada y parámetros del método

/**
 * Lee el texto seleccionado en la edición de texto de la nota
 *
 * @return
 */
QString ScriptingService::noteTextEditSelectedText();

1
2
3
4
5
6

# Ejemplo

// leer el texto seleccionado desde la edición de texto de la nota
var text = script.noteTextEditSelectedText();

1
2

Puede que quiera echar un vistazo a la acción personalizada transformTextRot13 en el ejemplo custom-actions.qml (opens new window).

# Seleccionar todo el texto en la edición de texto de la nota

# Llamada y parámetros del método

/ **
 * Selecciona todo el texto en la edición de texto de la nota
 */
void ScriptingService::noteTextEditSelectAll();

1
2
3
4

# Ejemplo

script.noteTextEditSelectAll();

Puede usar esto junto con noteTextEditWrite para sobrescribir todo el texto de la nota actual.

# Seleccionar la línea actual en la edición de texto de la nota

# Llamada y parámetros del método

/**
 * Selecciona la línea actual en la edición de texto de la nota
 */
void ScriptingService::noteTextEditSelectCurrentLine();

1
2
3
4

# Ejemplo

script.noteTextEditSelectCurrentLine();

# Seleccionar la palabra actual en la edición de texto de la nota

# Llamada y parámetros del método

/**
 * Selecciona la palabra actual en la edición de texto de la nota
 */
void ScriptingService::noteTextEditSelectCurrentWord();

1
2
3
4

# Ejemplo

script.noteTextEditSelectCurrentWord();

# Establecer el texto actualmente seleccionado en la edición de texto de nota

# Llamada y parámetros del método

/**
 * Establece el texto seleccionado actualmente en la edición de texto de la nota
 *
 * @param start
 * @param end
 */
void ScriptingService::noteTextEditSetSelection(int start, int end);

1
2
3
4
5
6
7

# Ejemplo

// expande la selección actual en un carácter
script.noteTextEditSetSelection(
    script.noteTextEditSelectionStart() - 1,
    script.noteTextEditSelectionEnd() + 1);

1
2
3
4

# Obtener la posición inicial de la selección actual en la edición de texto de la nota

# Llamada y parámetros del método

/**
 * Devuelve la posición inicial de la selección actual en la edición de texto de la nota
 */
int ScriptingService::noteTextEditSelectionStart();

1
2
3
4

# Ejemplo

script.log(script.noteTextEditSelectionStart());

# Obtener la posición final de la selección actual en la edición de texto de la nota

# Llamada y parámetros del método

/**
 * Devuelve la posición final de la selección actual en la edición de texto de la nota
 */
int ScriptingService::noteTextEditSelectionEnd();

1
2
3
4

# Ejemplo

script.log(script.noteTextEditSelectionEnd());

# Establecer el cursor de texto en la edición de texto de la nota en una posición determinada

# Llamada y parámetros del método

/**
 * Establece el cursor de texto en la edición de texto de la nota en una posición determinada
 * 0 sería el comienzo de la nota
 * caso especial: -1 sería el final de la nota
 *
 * @param position
 */
void ScriptingService::noteTextEditSetCursorPosition(int position);

1
2
3
4
5
6
7
8

# Ejemplo

// salta al undécimo carácter de la nota
script.noteTextEditSetCursorPosition(10);

// salta al final de la nota
script.noteTextEditSetCursorPosition(-1);

1
2
3
4
5

# Obtener la posición actual del cursor de texto en la edición de texto de la nota

# Llamada y parámetros del método

/**
 * Devuelve la posición actual del cursor de texto en la edición de texto de la nota
 * 0 sería el comienzo de la nota
 */
int ScriptingService::noteTextEditCursorPosition();

1
2
3
4
5

# Ejemplo

script.log(script.noteTextEditCursorPosition());

# Leer la palabra actual desde el editor de texto de notas

# Llamada y parámetros del método

/**
  * Lee la palabra actual en la edición de texto de la nota
  *
  * @param withPreviousCharacters también obtiene más caracteres al principio
  *                               para obtener caracteres como "@" que no son
  *                               caracteres de palabra
  * @return
  */
QString ScriptingService::noteTextEditCurrentWord(bool withPreviousCharacters);

1
2
3
4
5
6
7
8
9

# Ejemplo

// lee la palabra actual en la edición de texto de la nota
var text = script.noteTextEditCurrentWord();

1
2

Puede que quiera echar un vistazo al ejemplo autocompletion.qml (opens new window).

# Leer el bloque actual desde la edición de texto de la nota

# Llamada y parámetros del método

/**
 * Lee el bloque actual en la edición de texto de la nota
 *
 * @return
 */
QString ScriptingService::noteTextEditCurrentBlock();

1
2
3
4
5
6

# Ejemplo

// Lee el bloque actual en la edición de texto de la nota
var text = script.noteTextEditCurrentBlock();

1
2

Puede que quiera echar un vistazo al ejemplo ai-autocompletion.qml (opens new window).

# Usar un prompt de finalización en el modelo de IA seleccionado actualmente

El prompt de finalización de IA es una característica que le permite usar un prompt en el modelo de IA seleccionado actualmente.

El sistema de IA necesita ser activado en la barra de herramientas de IA o en el menú principal para que esto funcione.

# Llamada y parámetros del método

/**
 * Envoltorio de QML para usar el Finalizador de IA
 *
 * @param prompt
 * @return {QString} el resultado del finalizador
 */
QString ScriptingService::aiComplete(const QString& prompt);

1
2
3
4
5
6
7

# Ejemplo

// Solicita al modelo de IA seleccionado actualmente que complete el prompt
var text = script.aiComplete("Dime, ¿cómo te sientes hoy?");

1
2

Puede que quiera echar un vistazo al ejemplo ai-autocompletion.qml (opens new window).

# Comprobar si la plataforma es Linux, OS X o Windows

# Llamada y parámetros del método

bool ScriptingService::platformIsLinux();
bool ScriptingService::platformIsOSX();
bool ScriptingService::platformIsWindows();

1
2
3

# Ejemplo

if (script.platformIsLinux()) {
    // Solo se ejecutará si se está en Linux
}

1
2
3

# Etiquetar la nota actual

# Llamada y parámetros del método

/**
  * Etiqueta la nota actual con una etiqueta llamada tagName
  *
  * @param tagName
  */
void ScriptingService::tagCurrentNote(QString tagName);

1
2
3
4
5
6

# Ejemplo

// agrega una etiqueta "favorito" a la nota actual
script.tagCurrentNote("favorito");

1
2

Puede que quiera echar un vistazo a la acción personalizada favoriteNote en el ejemplo favorite-note.qml (opens new window).

# Crear o recuperar una etiqueta por su nombre lista de ruta de navegación

# Llamada y parámetros del método

/**
  * Obtiene o crea una etiqueta por su "lista de ruta de navegación" de nombres de etiquetas
  * Element nameList [0] sería el más alto en el árbol (con parentId: 0)
  *
  * @param nameList
  * @param createMissing {bool} si es verdadero (por defecto) se crearán todas las etiquetas faltantes
  * @return TagApi objeto de la etiqueta más profunda de la lista de ruta de navegación de nombres
  */
TagApi *ScriptingService::getTagByNameBreadcrumbList(
    const QStringList &nameList, bool createMissing);

1
2
3
4
5
6
7
8
9
10

# Ejemplo

// crea todas las etiquetas hasta el tercer nivel y devuelve el objeto de etiqueta para
// la etiqueta "nivel3", que se vería así en el árbol de etiquetas:
// nivel1 > nivel2 > nivel3
var tag = script.getTagByNameBreadcrumbList (["nivel1", "nivel2", "nivel3"]);

1
2
3
4

# Buscar etiquetas por nombre

# Llamada y parámetros del método

/**
  * Obtiene todas las etiquetas haciendo una búsqueda de subcadenas en el campo de nombre
  *
  * @param name {QString} nombre para buscar
  * @return {QStringList} lista de nombres de etiquetas
  */
QStringList ScriptingService::searchTagsByName(QString name);

1
2
3
4
5
6
7

# Ejemplo

// busca todas las etiquetas que contengan la palabra juego en ellas
var tags = script.searchTagsByName("juego");

1
2

Puede que quiera echar un vistazo al ejemplo autocompletion.qml (opens new window).

# Buscar notas por texto de nota

# Llamada y parámetros del método

/**
  * Devuelve una lista de ID de nota de todas las notas con un texto determinado en el texto de la nota
  *
  * Desafortunadamente, no hay una manera fácil de usar QList<NoteApi*> en QML, por lo que
  * solo se pueden transferir los ID de las notas
  *
  * @return {QList<int>} lista de ID de notas
  */
QList<int> ScriptingService::fetchNoteIdsByNoteTextPart(QString text);

1
2
3
4
5
6
7
8
9

# Ejemplo

var noteIds = script.fetchNoteIdsByNoteTextPart("mi texto");

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

    // hacer algo más con la nota
});

1
2
3
4
5
6
7

Puede que quiera echar un vistazo al ejemplo unique-note-id.qml (opens new window).

# Agregar una hoja de estilo personalizada

# Llamada y parámetros del método

/**
 * Agrega una hoja de estilo personalizada a la aplicación.
 *
 * @param stylesheet
 */
void ScriptingService::addStyleSheet(QString stylesheet);

1
2
3
4
5
6

# Ejemplo

// agranda el texto en la lista de notas
script.addStyleSheet("QTreeWidget#noteTreeWidget {font-size: 30px;}");

1
2

Puede que quiera echar un vistazo al ejemplo custom-stylesheet.qml (opens new window).

Puede obtener los nombres de los widgets a partir de los archivos *.ui. Por ejemplo, la ventana principal se encuentra en mainwindow.ui (opens new window).

La documentación de Qt (por ejemplo QMainWindow (opens new window)) puede ayudarle a visualizar cómo los widgets se relacionan entre sí (busque Hereda en las páginas).

El widget base para casi todo es QWidget (opens new window). Así que simplemente estilizar QWidget con, por ejemplo, QWidget {background-color: black; color: blanco; significaría que todo tiene un color de fondo negro y un color de primer plano blanco.

TIP

El style.qss (opens new window) de qdarkstyle (opens new window) también podría ser una buena referencia para los estilos que puede cambiar.

Eche un vistazo a la Hoja de referencia de estilo (opens new window) para obtener una referencia de los estilos que se encuentran disponibles.

Si desea inyectar estilos en la vista previa de html para alterar la forma en que se previsualizan las notas, por favor eche un vistazo a notetomarkdownhtmlhook.

TIP

Si realmente desea ver cómo se ven los cuadros de diálogo y cuáles son sus nombres puede descargar Qt Creator (opens new window) y abrir los archivos *.ui en él.

# Recargar el motor de secuencias de órdenes

# Llamada y parámetros del método

/**
 * Recarga el motor de secuencias de órdenes
 */
void ScriptingService::reloadScriptingEngine();

1
2
3
4

# Ejemplo

// recarga el motor de secuencias de órdenes
script.reloadScriptingEngine();

1
2

# Obtener una nota por su nombre de archivo

# Llamada y parámetros del método

/**
  * Obtiene una nota por su nombre de archivo
  *
  * @param fileName string el nombre del archivo de la nota (obligatorio)
  * @param noteSubFolderId integer ID de la subcarpeta de notas
  * @return NoteApi *
  */
NoteApi * ScriptingService::fetchNoteByFileName (QString fileName,
                                                 int noteSubFolderId);

1
2
3
4
5
6
7
8
9

# Ejemplo

// busca nota por nombre de archivo
script.fetchNoteByFileName("mi nota.md");

1
2

# Obtener una nota por su ID

# Llamada y parámetros del método

/**
 * Obtiene una nota por su identificador
 *
 * @param id int el identificador de la nota
 * @return NoteApi*
 */
NoteApi* ScriptingService::fetchNoteById(int id);

1
2
3
4
5
6
7

# Ejemplo

// busca nota por ID
script.fetchNoteById(243);

1
2

Puede que quiera echar un vistazo al ejemplo export-notes-as-one-html.qml (opens new window).

# Comprobar si una nota existe por su nombre de archivo

# Llamada y parámetros del método

/**
  * Comprueba si existe un archivo de notas por su nombre de archivo
  *
  * @param fileName string el nombre del archivo de la nota (obligatorio)
  * @param ignoreNoteId integer ID de una nota para ignorar en el cheque
  * @param noteSubFolderId integer ID de la subcarpeta de notas
  * @return bool
  */
bool ScriptingService::noteExistsByFileName(QString fileName,
                                            int ignoreNoteId,
                                            int noteSubFolderId);

1
2
3
4
5
6
7
8
9
10
11

# Ejemplo

// verifica si la nota existe, pero ignora el ID de "note"
script.noteExistsByFileName("mi nota.md", note.id);

1
2

Puede que quiera echar un vistazo al ejemplo use-tag-names-in-filename.qml (opens new window).

# Copiar texto en el portapapeles

# Llamada y parámetros del método

/**
 * Copia texto en el portapapeles como texto sin formato o datos MIME HTML
 *
 * @param text string texto a poner en el portapapeles
 * @param asHtml bool si es verdadero, el texto se establecerá como datos MIME HTML
 */
void ScriptingService::setClipboardText(QString text, bool asHtml);

1
2
3
4
5
6
7

# Ejemplo

// copia texto al portapapeles
script.setClipboardText("texto a copiar");

1
2

Puede que quiera echar un vistazo al ejemplo selected-markdown-to-bbcode.qml (opens new window).

# Ir a una nota

# Llamada y parámetros del método

/**
 * Establece la nota actual si la nota es visible en la lista de notas
 *
 * @param note NoteApi nota a la que ir
 * @param asTab bool si es verdadero, la nota será abierta en una nueva pestaña (si no está ya abierta)
 */
void ScriptingService::setCurrentNote(NoteApi *note, bool asTab = false);

1
2
3
4
5
6
7

# Ejemplo

// ir a la nota
script.setCurrentNote(note);

// abrir nota en una nueva pestaña (si no está ya abierta)
script.setCurrentNote(note, true);

1
2
3
4
5

Puede que quiera echar un vistazo al ejemplo journal-entry.qml (opens new window).

# Saltar a una subcarpeta de notas

# Llamada y parámetros del método

/**
  * Salta a una subcarpeta de notas
  *
  * @param noteSubFolderPath {QString} ruta de la subcarpeta, relativa a la carpeta de notas
  * @param separator {QString} separador entre partes de la ruta, por defecto "/"
  * @return verdadero si el salto fue exitoso
  */
bool ScriptingService::jumpToNoteSubFolder(const QString &noteSubFolderPath,
                                            QString separator);

1
2
3
4
5
6
7
8
9

# Ejemplo

// salta a la subcarpeta de notas "una subcarpeta"
script.jumpToNoteSubFolder("una subcarpeta");

// salta a la subcarpeta de notas "sub" dentro de "una subcarpeta"
script.jumpToNoteSubFolder("una subcarpeta/sub");

1
2
3
4
5

TIP

Puede crear una nueva subcarpeta de notas en la subcarpeta actual llamando a mainWindow.createNewNoteSubFolder.

# Mostrar un cuadro de mensaje de información

# Llamada y parámetros del método

/**
 * Muestra un cuadro de mensaje de información
 *
 * @param text
 * @param title (opcional)
 */
void ScriptingService::informationMessageBox(QString text, QString title);

1
2
3
4
5
6
7

# Ejemplo

// muestra un cuadro de mensaje de información
script.informationMessageBox ("El texto que quiero mostrar", "Algún título opcional");

1
2

# Mostrar un cuadro de mensaje de pregunta

# Llamada y parámetros del método

/**
  * Muestra un cuadro de mensaje de pregunta
  *
  * Para obtener información sobre los botones, consulte:
  * https://doc.qt.io/qt-5/qmessagebox.html#StandardButton-enum
  *
  * @param texto
  * @param title (opcional)
  * @param buttons botones que deben mostrarse (opcional)
  * @param defaultButton botón predeterminado que se seleccionará (opcional)
  * @return id del botón presionado
  */
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

# Ejemplo

// mostrar un cuadro de mensaje de pregunta con una solicitud y un botón de ayuda
// vease: https://doc.qt.io/qt-5/qmessagebox.html#StandardButton-enum
var result = script.questionMessageBox(
"El texto que quiero mostrar", "Algún título opcional", 0x01000000|0x02000000, 0x02000000);
script.log(result);

1
2
3
4
5

Para obtener información sobre los botones, consulte StandardButton (opens new window).

Puede que quiera echar un vistazo al ejemplo input-dialogs.qml (opens new window).

# Mostrar un cuadro de diálogo de archivo abierto

# Llamada y parámetros del método

/**
  * Muestra un cuadro de diálogo para abrir un archivo
  *
 * @param caption (opcional)
 * @param dir (opcional)
 * @param filter (opcional)
 * @return QString
 */
QString ScriptingService::getOpenFileName(QString caption, QString dir,
                                            QString filter);

1
2
3
4
5
6
7
8
9
10

# Ejemplo

// mostrar un diálogo de archivo abierto
var fileName = script.getOpenFileName("Por favor seleccione una imagen", "/home/user/images", "Images (*.png *.xpm *.jpg)");

1
2

# Mostrar un cuadro de diálogo para guardar un archivo

# Llamada y parámetros del método

/**
 * Muestra un cuadro de diálogo para guardar un archivo
 *
 * @param caption (opcional)
 * @param dir (opcional)
 * @param filter (opcional)
 * @return QString
 */
QString ScriptingService::getSaveFileName(QString caption, QString dir,
                                            QString filter);

1
2
3
4
5
6
7
8
9
10

# Ejemplo

// mostrar un cuadro de diálogo para guardar archivos
var fileName = script.getSaveFileName("Seleccione el archivo HTML para guardar", "output.html", "HTML (*.html)");

1
2

Puede que quiera echar un vistazo al ejemplo export-notes-as-one-html.qml (opens new window).

# Variables de la configuración del script de registro

Debe definir sus variables de configuración como propiedades en su script y registrarlas en una propiedad llamada settingsVariables.

Luego, el usuario puede establecer estas propiedades en la configuración del script.

# Ejemplo

// debe definir sus variables registradas para que pueda acceder a ellas más tarde
property string miCadena;
property string miCadenaSecreta;
property bool miBooleano;
property string miTexto;
property int miEntero;
property string miArchivo;
property string miDirectorio;
property string miSelección;

// registre sus variables de configuración para que el usuario pueda establecerlas en la configuración del script
//
// desafortunadamente QVariantHash no existe en Qt, solamente podemos usar
// QVariantMap (que no tiene un orden arbitrario) o QVariantList (que por
// lo menos puede ser ordenado arbitrariamente)
property variant settingsVariables: [
    {
        "identifier": "miCadena",
        "name": "Soy una edición de línea",
        "description": "Por favor introduzca una cadena válida:",
        "type": "string",
        "default": "Mi valor predeterminado",
    },
    {
        "identifier": "miCadenaSecreta",
        "name": "Soy un campo de contraseña",
        "description": "Por favor introduzca una cadena válida:",
        "type": "string-secret",
    },
    {
        "identifier": "miBooleano",
        "name": "Soy una casilla",
        "description": "Algo de descripción",
        "text": "Marque esta casilla",
        "type": "boolean",
        "default": true,
    },
    {
        "identifier": "miTexto",
        "name": "Soy una caja de texto",
        "description": "Por favor introduzca su texto:",
        "type": "text",
        "default": "Este puede ser un texto realmente muy largo\ncon múltiples líneas.",
    },
    {
        "identifier": "miEntero",
        "name": "Soy un selector de número",
        "description": "Por favor introduzca un número:",
        "type": "integer",
        "default": 42,
    },
    {
        "identifier": "miArchivo",
        "name": "Soy un selector de archivo",
        "description": "Por favor seleccione el archivo:",
        "type": "file",
        "default": "pandoc",
    },
    {
        "identifier": "miDirectorio",
        "name": "Soy un selector de directorio",
        "description": "Por favor seleccione el directorio:",
        "type": "directory",
        "default": "/home",
    },
    {
        "identifier": "miSelección",
        "name": "Soy un selector de elemento",
        "description": "Por favor seleccione un elemento:",
        "type": "selection",
        "default": "option2",
        "items": {"option1": "Texto para opción 1", "option2": "Texto para opción 2", "option3": "Texto para opción 3"},
    }
];

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

Además, puede sobreescribir settingsVariables con una función especial registerSettingsVariables () como esta:

# Ejemplo

/**
 * Registra las variables de configuración nuevamente
 *
 * Use este método si desea usar código para anular sus variables, como al establecer
 * valores predeterminados dependiendo del sistema operativo.
 */
function registerSettingsVariables() {
    if (script.platformIsWindows()) {
        // sobreescribir el valor predeterminado de miArchivo
        settingsVariables[3].default = "pandoc.exe"
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

Puede que quiera echar un vistazo al ejemplo variables.qml (opens new window).

# Almacenar y cargar variables persistentes

# Llamada y parámetros del método

/**
 * Guarda una variable persistente
 * Estas variables son accesibles globalmente en todos los scripts
 * Por favor use un prefijo significativo en su clave, como "PersistentVariablesTest/myVar"
 *
 * @param key {QString}
 * @param value {QVariant}
 */
void ScriptingService::setPersistentVariable(const QString &key,
                                             const QVariant &value);

/**
 * Carga una variable persistente
 * Estas variables son accesibles globalmente en todos los scripts
 *
 * @param key {QString}
 * @param defaultValue {QVariant} return valor si la configuración no existe (opcional)
 * @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

# Ejemplo

// almacenar variable persistente
script.setPersistentVariable("PersistentVariablesTest/myVar", result);

// cargar y registrar variable persistente
script.log(script.getPersistentVariable("PersistentVariablesTest/myVar", "no hay nada todavía"));

1
2
3
4
5

Asegúrese de usar un prefijo significativo en su clave como PersistentVariablesTest/myVar porque las variables son accesibles desde todos los scripts.

Puede que quiera echar un vistazo al ejemplo persistent-variables.qml (opens new window).

# Cargar variables de configuración de la aplicación

# Llamada y parámetros del método

/**
 * Carga una variable de configuración de la aplicación
 *
 * @param key {QString}
 * @param defaultValue {QVariant} valor de retorno si la configuración no existe (opcional)
 * @return
 */
QVariant ScriptingService::getApplicationSettingsVariable(const QString &key,
                                                          const QVariant &defaultValue);

1
2
3
4
5
6
7
8
9

# Ejemplo

// cargar y registrar una variable de configuración de la aplicación
script.log(script.getApplicationSettingsVariable ("gitExecutablePath"));

1
2

Tenga en cuenta que la configuración en realidad puede estar vacía. Debe ocuparse de eso por su propia cuenta. defaultValue solo se usa si la configuración no existe en absoluto.

# Crear un directorio de caché

Puede almacenar en caché los archivos en la ubicación de caché predeterminada de su sistema.

# Llamada y parámetros del método

/**
 * Devuelve un directorio de caché para un script
 *
 * @param {QString} subDir la subcarpeta a crear y usar
 * @return {QString} la ruta del directorio de caché
 */
QString ScriptingService::cacheDir(const QString &subDir) const;

1
2
3
4
5
6
7

# Ejemplo

// crear el directorio de caché para my-script-id
var cacheDirForScript = script.cacheDir("my-script-id");

1
2

# Borrar un directorio de caché

Puede borrar el directorio de caché de su script pasando su nombre a clearCacheDir().

# Llamada y parámetros del método

/**
 * Borra el directorio de caché de un script
 *
 * @param {QString} subDir la subcarpeta a limpiar
 * @return {bool} verdadero en caso de éxito
 */
bool ScriptingService::clearCacheDir (const QString & subDir) const;

1
2
3
4
5
6
7

# Ejemplo

// borrar el directorio de caché de my-script-id
script.clearCacheDir("my-script-id");

1
2

# Leer la ruta al directorio de su script

Si necesita obtener la ruta al directorio donde se coloca su script para por ejemplo, cargar otros archivos, debe registrar una cadena de propiedad scriptDirPath;. Esta propiedad se establecerá con la ruta al directorio del script.

# Ejemplo

import QtQml 2.0
import QOwnNotesTypes 1.0

Script {
     // la ruta al directorio del script se establecerá aquí
     property string scriptDirPath;

     function init () {
         script.log (scriptDirPath);
     }
}

1
2
3
4
5
6
7
8
9
10
11

# Conversión de separadores de ruta en nativos

# Llamada y parámetros del método

/**
 * Devuelve la ruta con los separadores '/' convertidos en separadores que son
 * apropiados para el sistema operativo subyacente.
 *
 * En Windows, toNativeDirSeparators("c:/winnt/system32") devuelve
 * "c:\winnt\system32".
 *
 * @param path
 * @return
 */
QString ScriptingService::toNativeDirSeparators(QString path);

1
2
3
4
5
6
7
8
9
10
11

# Ejemplo

// Devolverá "c:\winnt\system32" en Windows
script.log(script.toNativeDirSeparators("c:/winnt/system32"));

1
2

# Conversión de separadores de ruta a partir de los nativos

# Llamada y parámetros del método

/**
 * Devuelve la ruta usando '/' como separador de archivos.
 * En Windows, por ejemplo, fromNativeDirSeparators("c:\\winnt\\system32")
 * devuelve "c:/winnt/system32".
 *
 * @param path
 * @return
 */
QString ScriptingService::fromNativeDirSeparators(QString path);

1
2
3
4
5
6
7
8
9

# Ejemplo

// Devolverá "c:/winnt/system32" en Windows
script.log(script.fromNativeDirSeparators("c:\\winnt\\system32"));

1
2

# Obtener el separador de directorios nativo

# Llamada y parámetros del método

/**
 * Devuelve el separador de directorio nativo "/" o "\" en Windows
 *
 * @return
 */
QString ScriptingService::dirSeparator();

1
2
3
4
5
6

# Ejemplo

// Devolverá "\" en Windows
script.log(script.dirSeparator());

1
2

# Obtener una lista de las rutas de todas las notas seleccionadas

# Llamada y parámetros del método

/**
 * Devuelve una lista de las rutas de todas las notas seleccionadas
 *
 * @return {QStringList} lista de rutas de las notas seleccionadas
 */
QStringList ScriptingService::selectedNotesPaths();

1
2
3
4
5
6

# Ejemplo

// Devuelve una lista de las rutas de todas las notas seleccionadas
script.log(script.selectedNotesPaths());

1
2

Puede que quiera echar un vistazo al ejemplo external-note-diff.qml (opens new window).

# Obtener una lista de los ID de todas las notas seleccionadas

# Llamada y parámetros del método

/**
 * Regresa una lista de todos los ID de todas las notas seleccionadas
 *
 * @return {QList<int>} lista de los ID de las notas seleccionadas
 */
QList<int> ScriptingService::selectedNotesIds();

1
2
3
4
5
6

# Ejemplo

// devuelve una lista de los ID de todas las notas seleccionadas
script.log(script.selectedNotesIds());

1
2

Puede que quiera echar un vistazo al ejemplo export-notes-as-one-html.qml (opens new window).

# Llamada y parámetros del método

/**
 * Activa una acción del menú
 *
 * @param objectName {QString} nombre del objeto de la acción a invocar
 * @param checked {QString} solamente invocar la acción si el estado verificado es
 *                          diferente a este parámetro (opcional, puede ser 0 o 1)
 */
void ScriptingService::triggerMenuAction(QString objectName, QString checked);

1
2
3
4
5
6
7
8

# Ejemplo

// alterna el modo de solo lectura
script.triggerMenuAction("actionAllow_note_editing");

// deshabilita el modo de solo lectura
script.triggerMenuAction("actionAllow_note_editing", 1);

1
2
3
4
5

Puede que quiera echar un vistazo al ejemplo disable-readonly-mode.qml (opens new window).

TIP

Puede obtener los nombres de los objetos de la acción del menú desde mainwindow.ui (opens new window). Simplemente busque el título del menú en inglés. Tenga en cuenta que estos textos pueden cambiar con el tiempo.

# Abrir un diálogo de entrada con un cuadro de selección

# Llamada y parámetros del método

/**
  * Abre un cuadro de diálogo de entrada con un cuadro de selección
  *
  * @param title {QString} título del diálogo
  * @param label {QString} texto de la etiqueta del diálogo
  * @param items {QStringList} lista de elementos para seleccionar
  * @param current {int} índice actual del elemento que debe estar seleccionado (predeterminado: 0)
  * @param editable {bool} si es verdadero, el texto del cuadro de diálogo puede ser editado (predeterminado: falso)
  * @return {QString} texto del elemento seleccionado
  */
QString ScriptingService::inputDialogGetItem(
         const QString &título, const QString &etiqueta, const QStringList &elementos,
         int actual, bool editable);

1
2
3
4
5
6
7
8
9
10
11
12
13

Se devolverá una cadena vacía si se pulsa en Cancelar o se presiona Escape.

# Ejemplo

var result = script.inputDialogGetItem(
    "cuadro combinado", "Por favor seleccione un elemento", ["Elemento 1", "Elemento 2", "Elemento 3"]);
script.log(result);

1
2
3

Puede que quiera echar un vistazo al ejemplo input-dialogs.qml (opens new window).

# Abrir un diálogo de entrada con una edición de línea

# Llamada y parámetros del método

/**
 * Abre un cuadro de diálogo de entrada con una edición de línea.
 *
 * @param title {QString} título del diálogo
 * @param label {QString} texto de etiqueta del diálogo
 * @param text {QString} texto en el diálogo (opcional)
 * @return
 */
QString ScriptingService::inputDialogGetText(
        const QString &title, const QString &label, const QString &text);

1
2
3
4
5
6
7
8
9
10

Se devolverá una cadena vacía si se pulsa en Cancelar o se presiona Escape.

# Ejemplo

var result = script.inputDialogGetText(
    "line edit", "Por favor ingrese un nombre", "current text");
script.log(result);

1
2
3

# Abrir un diálogo de entrada con un editor de texto multirrenglón

# Llamada y parámetros del método

/**
 * Abre un cuadro de diálogo de entrada con una edición de texto multilínea.
 *
 * @param title {QString} título del diálogo
 * @param label {QString} texto de etiqueta del diálogo
 * @param text {QString} texto en el diálogo (opcional)
 * @return
 */
QString ScriptingService::inputDialogGetMultiLineText(
        const QString &title, const QString &label, const QString &text);

1
2
3
4
5
6
7
8
9
10

Se devolverá una cadena vacía si se pulsa en Cancelar o se presiona Escape.

# Ejemplo

var result = script.inputDialogGetMultiLineText(
    "edición multi línea", "Por favor ingrese un texto", "texto actual");
script.log(result);

1
2
3

# Abrir un diálogo para mostrar las diferencias entre dos textos

# Llamada y parámetros del método

/**
* Abre un diálogo para mostrar las diferencias entre dos textos y permite que el usuario edite el resultado
*
* @param title {QString} título del diálogo
* @param label {QString} texto de etiqueta del diálogo
* @param text1 {QString} primer texto
* @param text2 {QString} segundo texto
* @return
  */
  QString ScriptingService::textDiffDialog(const QString &title, const QString &label,
                                           const QString &text1, const QString &text2);

1
2
3
4
5
6
7
8
9
10
11

text2 es el texto que será capaz de editar en el diálogo. Se devolverá una cadena vacía si se pulsa en Cancelar o se presiona Escape.

# Ejemplo

const text = script.noteTextEditSelectedText();
const aiPrompt = "Traduce el texto a inglés";
const aiResult = script.aiComplete(aiPrompt + ":\n\n" + text);

var result = script.textDiffDialog("Herramienta de texto de IA", "Texto resultante", text, aiResult);
script.log(result);

1
2
3
4
5
6

# Comprobar si un archivo existe

# Llamada y parámetors del método

/**
 * Comprueba si existe un archivo
 * @param filePath
 * @return
 */
bool ScriptingService::fileExists(QString &filePath);

1
2
3
4
5
6

# Ejemplo

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

1
2

# Leer texto de un archivo

# Llamada y parámetros del método

/**
 * Lee texto de un archivo
 *
 * @param filePath {QString} ruta del archivo a cargar
 * @param codec {QString} codificación del archivo (por defecto: UTF-8)
 * @return los datos del archivo o null si el archivo no existe
 */
QString ScriptingService::readFromFile(const QString &filePath, const QString &codec)

1
2
3
4
5
6
7
8

# Ejemplo

if(script.fileExists(filePath)){
    var data = script.readFromFile(filePath);
    script.log(data);
}

1
2
3
4

# Escribir texto en un archivo

# Llamada y parámetors del método

/**
 * Escribe un texto en un archivo
 *
 * @param filePath {QString}
 * @param data {QString}
 * @param createParentDirs {bool} opcional (por defecto: falso)
 * @return
 */
bool ScriptingService::writeToFile(const QString &filePath, const QString &data, bool createParentDirs);

1
2
3
4
5
6
7
8
9

# Ejemplo

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

1
2

Puede que quiera echar un vistazo al ejemplo export-notes-as-one-html.qml (opens new window).

# Trabajar con zócalos web

Puede controlar QOwnNotes de forma remota utilizando WebSocketServer.

Por favor eche un vistazo al ejemplo websocket-server.qml (opens new window). Puede probar el servidor de zócalos conectándose a él en Prueba de zócalos web (opens new window).

También puede escuchar los zócalos con WebSocket. Por favor eche un vistazo al ejemplo websocket-client.qml (opens new window).

Tenga en cuenta que debe tener instalada la biblioteca QML websocket de Qt para usar esto. Por ejemplo, en Ubuntu Linux puede instalar qml-module-qtwebsockets.

# Agregar una regla de resaltado para el editor

Puede inyectar directamente reglas de resaltado en el editor definiendo expresiones regulares y asignándolas a un estado de resaltado.

# Llamada y parámetros del método

/**
 * Agrega una regla de resaltado al resaltador de sintaxis del editor
 *
 * @param pattern {QString} el patrón de expresión regular a ser subrayado
 * @param shouldContain {QString} string una cadena que el texto subrayado debe contener para que el patrón sea analizado
 * @param state {int} el estado del resaltador de sintaxis que será usado
 * @param capturingGroup {int} el grupo de captura del patrón que se utilizará para resaltar (por defecto: 0)
 * @param maskedGroup {int} el grupo de captura del patrón que se utilizará para el enmascaramiento (por defecto: 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

# Estados del resaltador

Nombre	No.
NoState	-1
Enlace	0
Imagen	3
CodeBlock	4
CodeBlockComment	5
Cursiva	7
Negrita	8
Liza	9
Comentario	11
H1	12
H2	13
H3	14
H4	15
H5	16
H6	17
Cita en bloque	18
HorizontalRuler	21
Tabla	22
InlineCodeBlock	23
MaskedSyntax	24
CurrentLineBackgroundColor	25
BrokenLink	26
FrontmatterBlock	27
TrailingSpace	28
CheckBoxUnChecked	29
CheckBoxChecked	30
StUnderline	31

# Ejemplo

// Subraya una línea de texto como "BLOQUE: algún texto" como cita en bloque (estado 18)
script.addHighlightingRule("^BLOQUE: (.+)", "BLOQUE:", 18);

// Enmascara (estado 24) todos los caracteres después de 32 caracteres en una línea
// capturingGroup 1 significa que la expresión de la primera parte entre corchetes del patrón se resaltará
// maskedGroup -1 significa que no se debería hacer ningún enmascaramiento
script.addHighlightingRule("^.{32}(.+)", "", 24, 1, -1);

1
2
3
4
5
6
7

También puede echar un vistazo a los ejemplos en highlighting.qml (opens new window).

← Scripts de QOwnNotes Ganchos →

Crafted by Patrizio Bekerle with ❤️

# Métodos y objetos que proporciona QOwnNotes

# Iniciar un programa externo en segundo plano

# Llamada y parámetros del método

# Ejemplo

# Iniciar un programa externo y esperar la salida

# Llamada y parámetros del método

# Ejemplo

# Obtener la ruta de la carpeta de notas actual

# Llamada y parámetros del método

# Ejemplo

# Obtener la nota actual

# Llamada y parámetros del método

# Ejemplo

# Iniciar sesión en el widget de registro

# Llamada y parámetros del método

# Ejemplo

# Descarga de una URL a una cadena

# Llamada y parámetros del método

# Ejemplo

# Descarga de una URL a la carpeta multimedia

# Llamada y parámetros del método

# Ejemplo

# Insertar un archivo multimedia en la carpeta multimedia

# Llamada y parámetros del método

# Ejemplo

# Insertar un archivo adjunto en la carpeta de archivos adjuntos

# Llamada y parámetros del método

# Ejemplo

# Regenerar la vista previa de la nota

# Llamada y parámetros del método

# Ejemplo

# Registro de una acción personalizada

# Llamada y parámetros del método

# Ejemplo

# Registrar una etiqueta

# Llamada y parámetros del método

# Ejemplo

# Configurar el texto de una etiqueta registrada

# Llamada y parámetros del método

# Ejemplo

# Crear una nota nueva

# Llamada y parámetros del método

# Ejemplo

# Acceder al portapapeles

# Llamada y parámetros del método

# Ejemplo

# Escribir texto en la edición de texto de la nota

# Llamada y parámetros del método

# Ejemplo

# Leer el texto seleccionado en la edición de texto de la nota

# Llamada y parámetros del método

# Ejemplo

# Seleccionar todo el texto en la edición de texto de la nota

# Llamada y parámetros del método

# Ejemplo

# Seleccionar la línea actual en la edición de texto de la nota

# Llamada y parámetros del método

# Ejemplo

# Seleccionar la palabra actual en la edición de texto de la nota

# Llamada y parámetros del método

# Ejemplo

# Establecer el texto actualmente seleccionado en la edición de texto de nota

# Llamada y parámetros del método

# Ejemplo

# Obtener la posición inicial de la selección actual en la edición de texto de la nota

# Llamada y parámetros del método

# Ejemplo

# Obtener la posición final de la selección actual en la edición de texto de la nota

# Llamada y parámetros del método

# Ejemplo

# Establecer el cursor de texto en la edición de texto de la nota en una posición determinada

# Llamada y parámetros del método

# Ejemplo

# Obtener la posición actual del cursor de texto en la edición de texto de la nota

# Llamada y parámetros del método

# Ejemplo

# Leer la palabra actual desde el editor de texto de notas

# Llamada y parámetros del método

# Ejemplo

# Leer el bloque actual desde la edición de texto de la nota