MonacoEditorView

Plataforma: B4J / JavaFX WebView. Biblioteca revisada: jdashboardUI(20261108-154221).b4xlib. Alcance: lo que implementa MonacoEditorView, no lo que podría construir una aplicación externa.

MonacoEditorView incorpora el editor de código Monaco dentro de una aplicación B4J. Su función es mostrar, editar y administrar texto y pestañas de código. El paquete incluye un runtime local (monaco.zip), temas, modos de lenguaje, búsqueda, acciones de edición, snippets, algunas sugerencias integradas y tres métodos nuevos para ejecutar extensiones JavaScript creadas por ti.

Importante: este componente no crea aplicaciones, formularios visuales, asistentes de instalación ni proyectos completos. Mostrar un lenguaje en el selector o admitir un archivo de extensión no equivale a proporcionar un generador de ese lenguaje. Las acciones sobre archivos reales, bases de datos, compiladores y persistencia pertenecen a tu aplicación B4J.

1. Qué incluye y qué debes implementar tú

No confundas soporte para editar un texto con soporte para generar automáticamente ese tipo de archivo.

2. Primer editor: Visual Designer y evento Ready

Activa la biblioteca jdashboardUI en B4J, abre el Visual Designer y añade un CustomView de tipo MonacoEditorView. Nombra la vista Editor1 y guarda el layout como Main.

El Designer expone cuatro propiedades:

El WebView carga Monaco de forma asíncrona. Espera al evento Ready para abrir pestañas y ejecutar JavaScript:

Sub Process_Globals
    Private fx As JFX
    Private MainForm As Form
    Private Editor1 As MonacoEditorView
    Private DocumentId As String
End Sub

Sub AppStart(Form1 As Form, Args() As String)
    MainForm = Form1
    MainForm.RootPane.LoadLayout("Main")
    MainForm.Show
End Sub

Private Sub Editor1_Ready
    DocumentId = Editor1.OpenDocument("notas.md", "# Hola desde B4J", Editor1.LANG_MARKDOWN)
    Log("Documento abierto: " & DocumentId)
End Sub

Private Sub Editor1_DocumentActivated(Id As String, Nombre As String)
    Log("Pestaña activa: " & Nombre)
End Sub

Private Sub Editor1_DocumentClosed(Id As String, Nombre As String)
    Log("Pestaña cerrada: " & Nombre)
End Sub

OpenDocument devuelve el ID del documento, que no es necesariamente igual al título de la pestaña. Usa ese ID para consultar, actualizar o cerrar la pestaña correcta.

Creación mediante código

También puedes inicializar el control con Editor1.Initialize(Me, "Editor1") y añadirlo a un contenedor con Editor1.AddToParent(Parent, Left, Top, Width, Height). La creación de la vista tampoco significa que Ready ya haya ocurrido.

Antes de Ready

SetValue conserva el texto pendiente y InsertSnippet pone los fragmentos en cola. No asumas que los demás métodos se ejecutan anticipadamente: por ejemplo, OpenDocument devuelve un ID vacío y LoadJavaScriptFile devuelve False antes de Ready.

3. Editar y administrar varios documentos

MonacoEditorView gestiona varios modelos de texto con sus propias pestañas. Para trabajar con dos archivos de ejemplo:

Private Sub Editor1_Ready
    Dim FirstId As String = Editor1.OpenDocument("datos.json", "{}", Editor1.LANG_JSON)
    Dim SecondId As String = Editor1.OpenDocument("notas.md", "# Mis notas", Editor1.LANG_MARKDOWN)

    Editor1.SelectDocument(FirstId)
    Log(Editor1.GetDocumentValue(SecondId)) ' Lee la otra pestaña sin activarla
    Editor1.SetDocumentValue(SecondId, "# Notas actualizadas")
End Sub

GetDocuments devuelve la lista de documentos abiertos. GetActiveDocumentId y GetActiveDocumentName permiten saber cuál está seleccionado. RenameDocument cambia el nombre visible de la pestaña. CloseDocument cierra el modelo identificado. Esos métodos no guardan, renombran ni eliminan archivos físicos.

Guardar realmente un archivo

El contenido lo escribe tu aplicación con la API de archivos de B4J. Solo después debes indicar al editor que ese documento ya no tiene modificaciones pendientes:

Private Sub GuardarNotas
    Dim Texto As String = Editor1.GetDocumentValue(DocumentId)
    File.WriteString(File.DirApp, "notas.md", Texto)
    Editor1.MarkDocumentSavedFor(DocumentId)
End Sub

Este ejemplo supone que DocumentId identifica una pestaña abierta y que la aplicación tiene permisos de escritura en File.DirApp. Para un editor con varias pestañas, guarda el contenido del ID correspondiente y decide cómo avisar sobre cambios sin guardar antes de cerrar.

Metadatos opcionales

OpenDocument admite además SourcePath, WorkPath, EntryPath, ModuleName y DocumentType. Son cadenas de identidad que tu aplicación puede asociar a un documento, no instrucciones para abrir formatos, extraer archivos ni generar módulos. SetDocumentMetadata y GetDocumentMetadata permiten administrarlas. DocumentExists busca documentos abiertos por esa identidad; no reemplaza File.Exists.

4. Búsqueda, edición y apariencia

Puedes llamar directamente a estas operaciones sobre el documento activo:

Editor1.FindText("buscar")
Editor1.FocusSearch
Editor1.SelectAll
Editor1.CopySelection
Editor1.Undo
Editor1.Redo
Editor1.InsertSnippet("Sub MiMetodo" & CRLF & "End Sub")
Editor1.SetTheme("vs-dark")
Editor1.SetEditorUiLanguage("Spanish")

También están disponibles CutSelection, PasteSelection, ToggleComment, FormatDocument y FormatSelection. El formateo depende de que exista un proveedor de formato registrado para el lenguaje activo; no promete funcionar para todos.

SetLanguage cambia el lenguaje del documento; SetEditorUiLanguage cambia los textos de la interfaz. No hacen lo mismo. El paquete contiene identificadores como LANG_JSON, LANG_XML, LANG_B4X, LANG_JAVASCRIPT, LANG_PYTHON y LANG_VBA, entre otros. Cada identificador no garantiza el mismo nivel de autocompletado o análisis.

GoToProcedure es un método limitado a navegar por nombres de procedimientos Sub, Function o Property reconocidos en texto VBA; no es un buscador universal de símbolos para cualquier lenguaje.

5. IntelliSense personalizado: lo que realmente puedes agregar

El editor dispone de sugerencias integradas según su runtime. Para agregar tu propio IntelliSense puedes escribir un archivo local JavaScript que use las APIs públicas de Monaco. La biblioteca no inventa por sí sola los nombres de funciones o clases de tu proyecto.

Por ejemplo, crea el archivo mis-sugerencias.js en la pestaña Files de B4J:

(function () {
    "use strict";

    if (!window.monaco || !window.editor) return;

    // Evita registrar dos veces el mismo proveedor.
    if (window.miProveedor) window.miProveedor.dispose();

    window.miProveedor = monaco.languages.registerCompletionItemProvider("javascript", {
        provideCompletionItems: function (model, position) {
            var palabra = model.getWordUntilPosition(position);
            var rango = new monaco.Range(
                position.lineNumber, palabra.startColumn,
                position.lineNumber, palabra.endColumn
            );

            return {
                suggestions: [{
                    label: "mostrarMensaje",
                    kind: monaco.languages.CompletionItemKind.Function,
                    insertText: "console.log('Hola');",
                    detail: "Ejemplo de sugerencia aportada por mi aplicación",
                    range: rango
                }]
            };
        }
    });
})();

Desde B4J, carga esa extensión después de Ready:

Private Sub Editor1_Ready
    Editor1.OpenDocument("ejemplo.js", "", Editor1.LANG_JAVASCRIPT)
    Dim Cargado As Boolean = Editor1.LoadJavaScriptFile(File.DirAssets, "mis-sugerencias.js")
    Log("Extensión cargada: " & Cargado)
End Sub

Esto registra una sugerencia de ejemplo para documentos configurados como JavaScript. Para otro lenguaje debes implementar o adaptar su proveedor y datos. El archivo JavaScript y el comportamiento nuevo son tuyos: LoadJavaScriptFile solamente lo lee y ejecuta; no crea un sistema IntelliSense de manera automática.

Ejecutar JavaScript y recibir resultados

If Editor1.IsReady Then
    Dim Ejecutado As Boolean = Editor1.ExecuteJavaScript("console.log('Listo')")
    Dim Resultado As Object = Editor1.ExecuteJavaScriptWithResult("1 + 2")
    Log("Ejecutado: " & Ejecutado & ", valor: " & Resultado)
End If

ExecuteJavaScript devuelve si la ejecución no produjo una excepción, no el resultado del script. ExecuteJavaScriptWithResult evalúa expresiones sincrónicas: números, textos y booleanos se devuelven directamente; objetos y arrays como texto JSON. Los tres métodos requieren Monaco listo y el hilo JavaFX. El nombre del archivo en LoadJavaScriptFile debe ser local y terminar en .js. Cargar varias veces la misma ruta en la misma página no vuelve a registrar la extensión; al recrearse el WebView debe cargarse de nuevo.

6. Eventos auténticos y métodos internos del puente

Los eventos declarados para la aplicación B4J son:

• Editor1_Ready: el editor terminó de inicializarse.
• Editor1_DocumentActivated(DocumentId As String, DocumentName As String): cambió la pestaña activa.
• Editor1_DocumentClosed(DocumentId As String, DocumentName As String): se cerró un documento.

Aunque documentChanged es una Public Sub, en esta versión no está declarado como evento #Event para el consumidor. Junto con documentActivated y documentClosed forma parte del puente interno entre JavaScript y B4J. Los métodos públicos clipboardGet, clipboardSet y PasteTest existen para manejar o probar el portapapeles; normalmente se utilizan CopySelection, CutSelection y PasteSelection.

7. Lenguaje y tema incluidos

• LANG_setupstudio es un identificador de lenguaje personalizado incluido en el runtime. Permite seleccionar el modo de edición para scripts de instalación, con las reglas de resaltado y sugerencias disponibles en ese modo. No crea instaladores ni proyectos.
• ribbonEditorTheme es el identificador de un tema visual integrado. Se utiliza como valor predeterminado del Designer y se puede seleccionar con SetTheme("ribbonEditorTheme"). No requiere ninguna otra aplicación.

8. Errores frecuentes

• La pantalla aparece pero no puedo ejecutar acciones: espera Ready y comprueba IsReady.
• LoadJavaScriptFile devuelve False: verifica el hilo JavaFX, que el archivo esté en Files y que el nombre termine en .js.
• No aparecen mis sugerencias: comprueba el identificador del lenguaje, la carga de la extensión y el resultado de su proveedor.
• Guardé una pestaña pero el archivo no cambió: MarkDocumentSavedFor no escribe en disco; utiliza antes las funciones de archivo de B4J.
• FormatDocument no cambia nada: puede no existir un formateador para el lenguaje actual.
• Puedo editar un lenguaje pero no generar un proyecto: la edición y el resaltado no implican creación de proyectos, compilación o integración con herramientas externas.

9. Referencia completa de la API pública

La siguiente referencia documenta 50 métodos públicos para editar texto, administrar documentos y ampliar el editor, con firmas verificadas en la biblioteca indicada.

Declaraciones verificadas y explicación método por método

Para copiar los ejemplos: agrega Editor1 como CustomView en el Designer, espera a Editor1_Ready y ejecuta los fragmentos desde una Sub de tu aplicación. IdNotas/NotesId representa el ID real que devolvió OpenDocument. Los ejemplos con botones requieren crearlos en el Designer. File.DirApp es una ubicación de prueba: en una aplicación instalada usa una ruta con permiso de escritura y un nombre distinto por documento.

Initialize

Public Sub Initialize (Callback As Object, EventName As String)

Inicializa el objeto con el receptor de eventos y el prefijo de callback; no implica que el editor ya esté listo.

DesignerCreateView

Public Sub DesignerCreateView (Base As Pane, Lbl As Label, Props As Map)

Método de integración con el Designer de B4J. Normalmente lo llama la infraestructura de vistas personalizadas.

AddToParent

Public Sub AddToParent(Parent As B4XView, Left As Double, Top As Double, Width As Double, Height As Double)

Crea la vista de Monaco y la añade a un contenedor B4XView con posición y dimensiones.

SetValue

Public Sub SetValue(xml As String)

Establece el texto del editor activo. Si todavía no está listo, el contenido queda pendiente para aplicarse después. El nombre del parámetro xml es histórico: admite texto general.

Caso de uso: Escribir texto inicial en el editor activo.

Editor1.SetValue("Primera línea" & CRLF & "Segunda línea")

Resultado y precauciones: El parámetro se llama xml por razones históricas, pero admite texto general.

GetValue

Public Sub GetValue As String

Obtiene el texto del documento activo; antes de Ready devuelve una cadena vacía.

Caso de uso: Obtener el texto actual para procesarlo o guardarlo.

Dim Texto As String = Editor1.GetValue
Log(Texto)

Resultado y precauciones: Recupera contenido, no abre ni escribe archivos automáticamente.

GetDocumentValue

Public Sub GetDocumentValue(DocumentId As String) As String

Lee el texto de un documento identificado por DocumentId sin cambiar la pestaña activa.

Caso de uso: Leer una pestaña sin seleccionarla.

Dim Texto As String = Editor1.GetDocumentValue(IdNotas)
Log(Texto)

Resultado y precauciones: IdNotas representa el ID retornado por OpenDocument o NewDocument.

SetDocumentValue

Public Sub SetDocumentValue(DocumentId As String, Content As String) As Boolean

Sustituye el texto de un documento identificado por DocumentId sin activar su pestaña; devuelve True si tuvo éxito.

Caso de uso: Reemplazar el contenido de una pestaña identificada por su ID.

Dim Correcto As Boolean = Editor1.SetDocumentValue(IdNotas, "# Texto actualizado")
Log(Correcto)

Resultado y precauciones: No necesitas cambiar la pestaña activa. Comprueba el Boolean para detectar un ID incorrecto.

MarkDocumentDirty

Public Sub MarkDocumentDirty(DocumentId As String)

Marca un documento como modificado. Útil si la aplicación cambia contenido mediante otra interfaz.

Caso de uso: Marcar cambios pendientes cuando otra parte de tu interfaz modifica un documento.

Dim Id As String = Editor1.GetActiveDocumentId
If Id <> "" Then Editor1.MarkDocumentDirty(Id)

Resultado y precauciones: Solo actualiza el estado de edición, no modifica el texto ni escribe en disco.

NewDocument

Public Sub NewDocument(DocumentName As String) As String

Abre un documento nuevo vacío con el nombre indicado y el lenguaje predeterminado; devuelve su ID.

Caso de uso: Crear un documento vacío para redactar contenido nuevo.

Dim IdNuevo As String = Editor1.NewDocument("Sin título")
Log("ID del documento: " & IdNuevo)

Resultado y precauciones: Guarda el ID para poder trabajar luego con la pestaña, aunque su nombre visible cambie.

OpenDocument

Public Sub OpenDocument(DocumentName As String, Content As String, Language As String, SourcePath As String = "", WorkPath As String = "", EntryPath As String = "", ModuleName As String = "", DocumentType As String = "") As String

Abre una pestaña con nombre, contenido y lenguaje; devuelve un DocumentId. Los cinco parámetros adicionales son metadatos opcionales del host, no crean archivos físicos.

Caso de uso: Abrir un archivo JSON existente en una pestaña.

Dim Texto As String = File.ReadString(File.DirApp, "datos.json")
Dim Id As String = Editor1.OpenDocument("datos.json", Texto, Editor1.LANG_JSON)
Log("ID: " & Id)

Resultado y precauciones: El archivo debe existir. File.ReadString realiza la lectura física; OpenDocument únicamente crea el modelo/pestaña con ese contenido.

OpenDocumentEx

Public Sub OpenDocumentEx(DocumentName As String, Content As String, Language As String, SourcePath As String, WorkPath As String, EntryPath As String, ModuleName As String, DocumentType As String) As String

Alias de compatibilidad anterior, marcado como obsoleto. Para código nuevo utiliza OpenDocument.

SetDocumentMetadata

Public Sub SetDocumentMetadata(DocumentId As String, SourcePath As String, WorkPath As String, EntryPath As String, ModuleName As String, DocumentType As String) As Boolean

Asocia metadatos definidos por la aplicación a una pestaña existente; no escribe en disco.

Caso de uso: Guardar una ruta lógica y categoría asociadas a una pestaña.

Dim Ok As Boolean = Editor1.SetDocumentMetadata(IdNotas, "notas.md", "", "", "", "text")
Log("Metadatos: " & Ok)

Resultado y precauciones: Esto no cambia el contenido ni escribe el archivo; los campos son información aportada por tu aplicación.

GetDocumentMetadata

Public Sub GetDocumentMetadata(DocumentId As String) As Map

Devuelve un Map con los metadatos y estado conocidos para un DocumentId.

Caso de uso: Consultar la ruta lógica y otros datos asociados al documento.

Dim Info As Map = Editor1.GetDocumentMetadata(IdNotas)
Log(Info)

Resultado y precauciones: Revisa el Map devuelto antes de asumir nombres de claves; se refiere a una pestaña, no a un archivo abierto automáticamente.

GetActiveDocument

Public Sub GetActiveDocument As Map

Devuelve el Map de metadatos del documento activo.

Caso de uso: Mostrar los datos de la pestaña activa en un panel de propiedades.

Dim Info As Map = Editor1.GetActiveDocument
Log(Info)

Resultado y precauciones: El resultado es un Map con información del documento seleccionado.

DocumentExists

Public Sub DocumentExists(SourcePath As String, EntryPath As String, ModuleName As String, DocumentType As String) As Boolean

Comprueba si existe un documento abierto con una combinación de cuatro campos de identidad del host; no comprueba si existe un archivo en disco.

Caso de uso: Evitar volver a abrir una pestaña con la misma identidad.

Dim YaAbierto As Boolean = Editor1.DocumentExists("notas.md", "", "", "text")
Log("Pestaña existente: " & YaAbierto)

Resultado y precauciones: Comprueba identidades de pestañas abiertas que tu aplicación haya registrado con esos valores. Para comprobar el archivo físico usa File.Exists.

SelectDocument

Public Sub SelectDocument(DocumentId As String)

Activa la pestaña identificada por DocumentId.

Caso de uso: Cambiar a una pestaña conocida sin depender del texto de su título.

Editor1.SelectDocument(IdNotas)

Resultado y precauciones: Usa el ID retornado al abrir el documento.

CloseDocument

Public Sub CloseDocument(DocumentId As String) As Boolean

Solicita cerrar una pestaña y devuelve True cuando se cerró. Gestiona el guardado en tu aplicación antes de perder contenido.

Caso de uso: Cerrar un documento después de guardarlo, evitando perder el contenido por error.

Dim Id As String = Editor1.GetActiveDocumentId
If Id <> "" Then
    Try
        File.WriteString(File.DirApp, "documento.txt", Editor1.GetDocumentValue(Id))
        Editor1.MarkDocumentSavedFor(Id)
        Dim Cerrado As Boolean = Editor1.CloseDocument(Id)
        Log("Cerrado: " & Cerrado)
    Catch
        Log(LastException)
    End Try
End If

Resultado y precauciones: Esta es una ruta fija de demostración. En una aplicación real utiliza la ruta asignada a cada documento y solicita confirmación para descartar cambios.

RenameDocument

Public Sub RenameDocument(DocumentId As String, DocumentName As String) As Boolean

Renombra la etiqueta visible de una pestaña; no renombra archivos en disco.

Caso de uso: Cambiar la etiqueta de una pestaña después de modificar su título.

Dim Correcto As Boolean = Editor1.RenameDocument(IdNotas, "Notas revisadas.md")
Log(Correcto)

Resultado y precauciones: Renombra la pestaña, no un archivo físico.

GetActiveDocumentId

Public Sub GetActiveDocumentId As String

Devuelve el identificador de la pestaña actualmente activa.

Caso de uso: Saber qué documento debe recibir la acción Guardar o Cerrar.

Dim Id As String = Editor1.GetActiveDocumentId
If Id = "" Then Return
Log("Documento activo: " & Id)

Resultado y precauciones: El ID vacío indica que no existe una pestaña activa.

GetActiveDocumentName

Public Sub GetActiveDocumentName As String

Devuelve el nombre visible del documento activo.

Caso de uso: Mostrar el título de la pestaña activa en una barra de estado.

Log("Editando: " & Editor1.GetActiveDocumentName)

Resultado y precauciones: El título no siempre coincide con la ruta del archivo en disco.

GetDocuments

Public Sub GetDocuments As List

Devuelve la lista de documentos, con sus IDs, nombres, estados y metadatos.

Caso de uso: Mostrar en el Log qué pestañas siguen abiertas.

Dim Documentos As List = Editor1.GetDocuments
Log("Total de pestañas: " & Documentos.Size)
For Each Doc As Object In Documentos
    Log(Doc)
Next

Resultado y precauciones: Puedes usar esta lista para construir un selector propio de documentos sin asumir nombres de campos no comprobados.

MarkDocumentSaved

Public Sub MarkDocumentSaved

Marca como guardada la pestaña activa; no ejecuta ningún guardado físico.

Caso de uso: Guardar la pestaña activa y quitar su indicador de cambios solamente si el archivo se escribió correctamente.

Private Sub btnGuardar_Click
    If Editor1.IsReady = False Then Return
    If Editor1.GetActiveDocumentId = "" Then Return
    Try
        File.WriteString(File.DirApp, "notas.txt", Editor1.GetValue)
        Editor1.MarkDocumentSaved
        Log("Guardado correctamente")
    Catch
        Log("Error: " & LastException)
    End Try
End Sub

Resultado y precauciones: El archivo de prueba notas.txt se escribe primero; luego la pestaña activa queda marcada como guardada. MarkDocumentSaved por sí solo no guarda nada en disco. Crea un botón btnGuardar en el Designer para conectar este evento.

MarkDocumentSavedFor

Public Sub MarkDocumentSavedFor(DocumentId As String)

Marca como guardado un DocumentId específico; solo debe llamarse después de guardar realmente desde la aplicación.

Caso de uso: Guardar una pestaña concreta sin activarla; útil al manejar varios documentos.

Private Sub GuardarNotas(IdNotas As String)
    If Editor1.IsReady = False Or IdNotas = "" Then Return
    Try
        File.WriteString(File.DirApp, "notas.md", Editor1.GetDocumentValue(IdNotas))
        Editor1.MarkDocumentSavedFor(IdNotas)
    Catch
        Log("No se guardó: " & LastException)
    End Try
End Sub

Resultado y precauciones: A diferencia de MarkDocumentSaved, este método marca como guardada la pestaña cuyo ID indicas. Utiliza una ruta diferente para cada documento en tu aplicación.

documentActivated

Public Sub documentActivated(DocumentId As String, DocumentName As String)

Método público usado por el puente JavaScript interno para sincronizar la selección y reenviar el evento DocumentActivated; normalmente no se invoca desde la app.

documentChanged

Public Sub documentChanged(DocumentId As String, DocumentName As String, Dirty As Boolean)

Método público del puente interno que actualiza la caché y el indicador de cambios; no existe un evento de consumidor #Event DocumentChanged declarado en esta versión.

documentClosed

Public Sub documentClosed(DocumentId As String, DocumentName As String)

Método público del puente interno que actualiza la caché y reenvía DocumentClosed; normalmente no se llama desde B4J.

InsertSnippet

Public Sub InsertSnippet(snippet As String)

Inserta una plantilla de texto en el cursor. Si no está listo, la operación se coloca en cola.

Caso de uso: Insertar una plantilla que el usuario puede completar.

Editor1.InsertSnippet("Sub MiMetodo" & CRLF & "    Log(""Hola"")" & CRLF & "End Sub")

Resultado y precauciones: El código se inserta en la posición del cursor; no se genera un archivo de proyecto.

Undo

Public Sub Undo

Deshace la última operación de edición del documento activo.

Caso de uso: Conectar el botón Deshacer de tu interfaz.

Private Sub btnDeshacer_Click
    Editor1.Undo
End Sub

Resultado y precauciones: Actúa sobre la operación de edición previa del documento activo.

Redo

Public Sub Redo

Rehace una operación previamente deshecha.

Caso de uso: Permitir recuperar un cambio previamente deshecho.

Private Sub btnRehacer_Click
    Editor1.Redo
End Sub

Resultado y precauciones: El botón debe llamarse btnRehacer en el Designer para conectar el evento.

SelectAll

Public Sub SelectAll

Selecciona todo el texto del documento activo.

Caso de uso: Añadir una acción de menú Seleccionar todo.

Editor1.SelectAll

Resultado y precauciones: Selecciona el contenido del documento activo, no de todas las pestañas.

ToggleComment

Public Sub ToggleComment

Activa o desactiva comentarios en la selección según las reglas del lenguaje.

Caso de uso: Comentar o descomentar el código que el usuario seleccionó.

Editor1.ToggleComment

Resultado y precauciones: La operación depende del modo de lenguaje configurado y de sus reglas de comentarios.

CopySelection

Public Sub CopySelection

Copia la selección usando el puente del portapapeles JavaFX.

Caso de uso: Conectar la opción Copiar de un menú Editar.

Editor1.CopySelection

Resultado y precauciones: Usa el portapapeles de JavaFX; no copia todo el contenido cuando no existe selección.

CutSelection

Public Sub CutSelection

Corta la selección usando el portapapeles JavaFX.

Caso de uso: Conectar la acción Cortar.

Editor1.CutSelection

Resultado y precauciones: Elimina la selección del editor y la coloca en el portapapeles.

PasteSelection

Public Sub PasteSelection

Inserta el texto disponible en el portapapeles JavaFX.

Caso de uso: Conectar la acción Pegar.

Editor1.PasteSelection

Resultado y precauciones: Inserta el contenido del portapapeles en la posición de edición.

FormatDocument

Public Sub FormatDocument

Solicita formatear el documento; requiere que el lenguaje activo tenga un proveedor de formato disponible.

Caso de uso: Ofrecer una acción Formatear desde tu toolbar.

Editor1.FormatDocument

Resultado y precauciones: Solo habrá cambios si el lenguaje actual dispone de un proveedor compatible.

FormatSelection

Public Sub FormatSelection

Solicita formatear la selección; su funcionamiento depende del proveedor registrado.

Caso de uso: Agregar un botón Formatear selección.

Editor1.FormatSelection

Resultado y precauciones: Necesita que el lenguaje disponga de un formateador de rangos; puede no producir cambios.

FocusSearch

Public Sub FocusSearch

Abre o enfoca la búsqueda integrada de Monaco.

Caso de uso: Abrir el cuadro integrado de búsqueda desde un botón.

Private Sub btnBuscar_Click
    Editor1.FocusSearch
End Sub

Resultado y precauciones: Conecta la Sub a un botón btnBuscar de tu layout.

SetEditorUiLanguage

Public Sub SetEditorUiLanguage(Language As String)

Configura las etiquetas de la interfaz integrada como English o Spanish; no modifica el lenguaje del documento.

Caso de uso: Poner las etiquetas del editor en español.

Editor1.SetEditorUiLanguage("Spanish")

Resultado y precauciones: No traduce el código del usuario ni cambia LANG_JSON, LANG_VBA, etc.

FindText

Public Sub FindText(Query As String)

Busca el texto indicado en el documento activo y selecciona la primera coincidencia.

Caso de uso: Buscar una palabra sin construir tu propio motor de búsqueda.

Editor1.FindText("configuración")

Resultado y precauciones: Selecciona la primera coincidencia reconocida en el documento activo.

GoToProcedure

Public Sub GoToProcedure(ProcedureName As String) As Boolean

Navega a una Sub, Function o Property de código VBA cuando el analizador del runtime reconoce el nombre; devuelve True si se encontró.

Caso de uso: Localizar un procedimiento VBA que ya existe.

Dim Encontrado As Boolean = Editor1.GoToProcedure("CalcularTotal")
Log("Encontrado: " & Encontrado)

Resultado y precauciones: No crea procedimientos; necesita contenido VBA reconocible.

clipboardGet

Public Sub clipboardGet As String

Lee texto del portapapeles JavaFX; método público utilizado por el puente.

clipboardSet

Public Sub clipboardSet(text As String) As Boolean

Escribe texto en el portapapeles JavaFX y comprueba el contenido; método público del puente.

PasteTest

Public Sub PasteTest As String

Método auxiliar de diagnóstico que devuelve el texto del portapapeles; no es un comando de inserción.

SetTheme

Public Sub SetTheme(themeName As String)

Aplica por nombre un tema registrado en el runtime de Monaco; el nombre debe existir realmente.

Caso de uso: Cambiar entre un tema oscuro y el tema visual incluido por defecto.

Editor1.SetTheme("vs-dark")
' También disponible:
Editor1.SetTheme("ribbonEditorTheme")

Resultado y precauciones: ribbonEditorTheme es solo un estilo de Monaco; no implica funciones de otros programas.

SetLanguage

Public Sub SetLanguage(language As String)

Cambia el identificador de lenguaje del modelo activo. Esto no implica IntelliSense completo para todos los lenguajes.

Caso de uso: Seleccionar el resaltado y comportamiento de lenguaje de la pestaña activa.

Editor1.SetLanguage(Editor1.LANG_JSON)
' Modo adicional incorporado:
Editor1.SetLanguage(Editor1.LANG_setupstudio)

Resultado y precauciones: El modo de lenguaje no crea proyectos ni aporta automáticamente un compilador.

IsReady

Public Sub IsReady As Boolean

Devuelve True cuando la página Monaco se ha inicializado correctamente.

Caso de uso: Evitar ejecutar operaciones cuando el WebView todavía está cargando.

If Editor1.IsReady = False Then
    Log("Esperando inicialización")
    Return
End If

Resultado y precauciones: Especialmente importante antes de abrir pestañas y cargar archivos JavaScript.

LoadJavaScriptFile

Public Sub LoadJavaScriptFile(Dir As String, FileName As String) As Boolean

Lee y ejecuta un archivo JavaScript local .js después de Ready. Evita volver a cargar la misma ruta en una instancia de página; devuelve True o False.

Caso de uso: Cargar un proveedor propio de sugerencias desde la carpeta Files.

Private Sub Editor1_Ready
    Dim Ok As Boolean = Editor1.LoadJavaScriptFile(File.DirAssets, "mis-sugerencias.js")
    Log("Cargado: " & Ok)
End Sub

Resultado y precauciones: El archivo JavaScript debe existir y contener el código de la función o proveedor; cargarlo no lo crea.

ExecuteJavaScript

Public Sub ExecuteJavaScript(Script As String) As Boolean

Ejecuta un bloque JavaScript en la página cargada; devuelve Boolean indicando ejecución sin excepción, no el valor retornado por el código.

Caso de uso: Invocar código JavaScript integrado o cargado mediante una extensión.

Dim Ok As Boolean = Editor1.ExecuteJavaScript("console.log('Hola')")
Log(Ok)

Resultado y precauciones: El Boolean indica si la ejecución finalizó sin excepción; no es el valor retornado por el script.

ExecuteJavaScriptWithResult

Public Sub ExecuteJavaScriptWithResult(Script As String) As Object

Evalúa una expresión JavaScript sincrónica; retorna valores simples o texto JSON para objetos y arreglos. Antes de Ready devuelve Null.

Caso de uso: Recuperar un valor sincrónico que devuelve JavaScript.

Dim Valor As Object = Editor1.ExecuteJavaScriptWithResult("2 + 3")
Log(Valor)

Resultado y precauciones: El resultado es 5. Los objetos y listas complejas se devuelven como texto JSON.

GetBase

Public Sub GetBase As Pane

Devuelve el Pane base que contiene la vista.

Caso de uso: Consultar las dimensiones reales del contenedor del editor.

Dim P As Pane = Editor1.GetBase
Log(P.Width & " x " & P.Height)

Resultado y precauciones: Útil para diagnosticar distribuciones o ajustar controles adyacentes; no cambia el contenido.

Constantes y configuración de compatibilidad

Los identificadores públicos de lenguaje de esta versión son: LANG_XML, LANG_VBA, LANG_VBNET, LANG_B4X, LANG_JAVASCRIPT, LANG_PYTHON, LANG_SQL, LANG_JSON, LANG_HTML, LANG_CSS, LANG_MARKDOWN, LANG_TYPESCRIPT, LANG_CSHARP, LANG_JAVA, LANG_CPP y LANG_setupstudio. Los identificadores de idioma visual son UI_LANGUAGE_ENGLISH y UI_LANGUAGE_SPANISH. Aparecen aquí por fidelidad al código fuente; por sí solos no incorporan generadores o herramientas externas.

Los únicos #Event del consumidor son Ready, DocumentActivated y DocumentClosed.

Resumen: MonacoEditorView es el componente editor. Tu aplicación proporciona archivos, formatos, lógica y extensiones avanzadas.