En esta página

Qt Quick Controles: editor de texto

Una aplicación de editor de texto enriquecido que utiliza los controles « Qt Quick ».

El ejemplo del editor de texto permite la edición WYSIWYG de archivos HTML, Markdown o de texto sin formato. La aplicación incluye dos interfaces de usuario: una para pantallas más grandes y otra simplificada para dispositivos táctiles pequeños. Ambas están escritas en QML «puro». texteditor.cpp contiene la función main(), que llama a QFontDatabase::addApplicationFont() para añadir una fuente de iconos. (FontLoader sería una forma alternativa de conseguir el mismo resultado.)

Interfaz de usuario de escritorio

Editor de texto con barra de menús, barra de herramientas y contenido del documento formateado

La versión de escritorio es un editor de texto completo con funciones para dar formato al texto, así como para abrir y guardar archivos HTML, Markdown y de texto sin formato.

En el patrón de diseño modelo-vista-control (MVC), la capa de control incluye el conjunto de operaciones que se pueden realizar. En Qt Quick Controls, el tipo Action se utiliza para encapsular una única operación o comando. Por consiguiente, comenzamos con un conjunto de objetos Action:

    Action {
        id: openAction
        text: qsTr("&Open")
        shortcut: StandardKey.Open
        onTriggered: {
            if (textArea.textDocument.modified)
                discardDialog.open()
            else
                openDialog.open()
        }
    }

El ` Action ` para abrir un archivo debe preguntar primero al usuario si se han realizado cambios en el documento existente, para evitar perder los cambios del usuario. De lo contrario, simplemente abre el ` FileDialog ` que se declara más adelante.

El « Action » para guardar el archivo solo se activa si hay cambios que guardar:

    Action {
        id: saveAction
        text: qsTr("&Save…")
        shortcut: StandardKey.Save
        enabled: textArea.textDocument.modified
        onTriggered: textArea.textDocument.save()
    }

La acción « Action » para copiar el texto seleccionado solo se activa si hay texto seleccionado:

    Action {
        id: copyAction
        text: qsTr("&Copy")
        shortcut: StandardKey.Copy
        enabled: textArea.selectedText
        onTriggered: textArea.copy()
    }

Cada acción para cambiar el formato del texto (como negrita, cursiva y alineación) es un « checkable », y su estado booleano « checked » está sincronizado con la propiedad correspondiente en el « selected text ». Dado que la sincronización bidireccional declarativa resulta complicada, utilizamos un script « onTriggered » para cambiar la propiedad cuando se activa la acción. La propiedad cursorSelection es una novedad de Qt 6.7 y hace que esto resulte mucho más sencillo de lo que era.

    Action {
        id: boldAction
        text: qsTr("&Bold")
        shortcut: StandardKey.Bold
        checkable: true
        checked: textArea.cursorSelection.font.bold
        onTriggered: textArea.cursorSelection.font.bold = checked
    }

    Action {
        id: alignCenterAction
        text: qsTr("&Center")
        shortcut: "Ctrl+|"
        checkable: true
        checked: textArea.cursorSelection.alignment === Qt.AlignCenter
        onTriggered: textArea.cursorSelection.alignment = Qt.AlignCenter
    }

Disponemos de un ` MenuBar ` que contiene la jerarquía de ` Menus ` y `MenuItems`. Cada ` MenuItem ` solo tiene que vincular el ` action` correspondiente, que encapsula la representación de la interfaz de usuario y la implementación.

    menuBar: MenuBar {
        Menu {
            title: qsTr("&File")

            MenuItem {
                action: openAction
            }
            MenuItem {
                action: saveAction
            }
            MenuItem {
                action: saveAsAction
            }
            MenuItem {
                action: quitAction
            }
        }

        Menu {
            title: qsTr("&Edit")

            MenuItem {
                action: copyAction
            }
        ...

Los mismos objetos ` Action ` se reutilizan en el ` ToolBar`; pero aquí sobrescribimos la propiedad ` text ` de cada `Action` para elegir un icono textual de nuestra fuente de iconos:

    header: ToolBar {
        Flow {
            width: parent.width

            Row {
                id: fileRow
                ToolButton {
                    id: openButton
                    text: "\uF115" // icon-folder-open-empty
                    font.family: "fontello"
                    action: openAction
                    focusPolicy: Qt.TabFocus
                }
                ToolButton {
                    id: saveButton
                    text: "\uE80A" // icon-floppy-disk
                    font.family: "fontello"
                    action: saveAction
                    focusPolicy: Qt.TabFocus
                }
                ToolSeparator {
                    contentItem.visible: fileRow.y === editRow.y
                }
            }

            Row {
                id: editRow
                ToolButton {
                    id: copyButton
                    text: "\uF0C5" // icon-docs
                    font.family: "fontello"
                    focusPolicy: Qt.TabFocus
                    action: copyAction
                }
            ...

La parte principal del editor de texto es un ` TextArea ` dentro de un ` Flickable`:

    Flickable {
        id: flickable
        flickableDirection: Flickable.VerticalFlick
        anchors.fill: parent

        ScrollBar.vertical: ScrollBar {}

        TextArea.flickable: TextArea {
            id: textArea
            textFormat: Qt.AutoText
            wrapMode: TextArea.Wrap
            focus: true
            selectByMouse: true
            persistentSelection: true
            ...

Un ScrollBar está vinculado al eje vertical. Dado que el ajuste de línea está habilitado mediante wrapMode, no necesitamos una propiedad ScrollBar horizontal.

La propiedad adjunta TextArea.flickable se utiliza para que, cuando el cursor de texto se salga del área de visualización (por ejemplo, mediante las teclas de flecha o al escribir mucho texto), TextArea desplace el Flickable para mantener el cursor visible.

Tomamos las mismas acciones que declaramos en MenuBar y ToolBar y las añadimos a los elementos existentes en el context menu estándar proporcionado por TextArea:

                const menu = textArea.ContextMenu.menu
                menu.addItem(menuSeparatorComponent.createObject(menu.contentItem))
                menu.addAction(fontDialogAction)
                menu.addAction(colorDialogAction)

Utilizamos de forma sistemática la función qsTr() para permitir la traducción del texto de la interfaz de usuario, de modo que la aplicación resulte comprensible independientemente del idioma nativo del usuario final.

Utilizamos varios tipos de dialogs:

    FileDialog {
        id: openDialog
        fileMode: FileDialog.OpenFile
        selectedNameFilter.index: 1
        nameFilters: ["Text files (*.txt)", "HTML files (*.html *.htm)", "Markdown files (*.md *.markdown)"]
        currentFolder: StandardPaths.writableLocation(StandardPaths.DocumentsLocation)
        onAccepted: {
            textArea.textDocument.modified = false // we asked earlier, if necessary
            textArea.textDocument.source = selectedFile
        }
    }

    FileDialog {
        id: saveDialog
        fileMode: FileDialog.SaveFile
        nameFilters: openDialog.nameFilters
        currentFolder: StandardPaths.writableLocation(StandardPaths.DocumentsLocation)
        onAccepted: textArea.textDocument.saveAs(selectedFile)
    }

    FontDialog {
        id: fontDialog
        onAccepted: textArea.cursorSelection.font = selectedFont
    }

    ColorDialog {
        id: colorDialog
        selectedColor: textArea.cursorSelection.color
        onAccepted: textArea.cursorSelection.color = selectedColor
    }

    MessageDialog {
        title: qsTr("Error")
        id: errorDialog
    }

    MessageDialog {
        id : quitDialog
        title: qsTr("Quit?")
        text: qsTr("The file has been modified. Quit anyway?")
        buttons: MessageDialog.Yes | MessageDialog.No
        onButtonClicked: function (button, role) {
            if (role === MessageDialog.YesRole) {
                textArea.textDocument.modified = false
                Qt.quit()
            }
        }
    }

    MessageDialog {
        id : discardDialog
        title: qsTr("Discard changes?")
        text: qsTr("The file has been modified. Open a new file anyway?")
        buttons: MessageDialog.Yes | MessageDialog.No
        onButtonClicked: function (button, role) {
            if (role === MessageDialog.YesRole)
                openDialog.open()
        }
    }

Por lo general, resulta más sencillo declarar instancias independientes para cada finalidad. Contamos con dos instancias de ` FileDialog`, una para abrir archivos y otra para guardarlos, respectivamente. Esto se ha simplificado en Qt 6.7, gracias a las nuevas funciones de ` TextDocument`.

Un ` FontDialog ` y un ` ColorDialog ` permiten modificar el formato del texto. (En formato Markdown, no existe sintaxis para representar opciones específicas de fuente y color; sin embargo, se guardan características de la fuente como negrita, cursiva y monoespaciado. En formato HTML, se guarda todo el formato).

Contamos con un « MessageDialog » para mostrar mensajes de error y otros dos para indicar al usuario qué debe hacer cuando se ha modificado un archivo.

Interfaz de usuario táctil

Interfaz de editor de texto para dispositivos táctiles con barra de herramientas de formato

La interfaz de usuario táctil es una versión simplificada del editor de texto. Es adecuada para dispositivos táctiles con un tamaño de pantalla limitado. El ejemplo utiliza selectores de archivos para cargar automáticamente la interfaz de usuario adecuada.

Ejecución del ejemplo

Puedes ejecutar el ejemplo desde:

Proyecto de ejemplo en code.qt.io

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.