En esta página

TextEdit QML Type

Muestra varias líneas de texto formateado y editable. Más...

Import Statement: import QtQuick
Inherits:

Item

Inherited By:

TextArea

Propiedades

Señales

Métodos

Descripción detallada

El elemento TextEdit muestra un bloque de texto formateado y editable.

Puede mostrar tanto texto sin formato como texto con formato. Por ejemplo:

TextEdit {
    width: 240
    text: "<b>Hello</b> <i>World!</i>"
    font.family: "Helvetica"
    font.pointSize: 20
    color: "blue"
    focus: true
}

Al establecer ` focus ` en ` true `, se permite que el elemento TextEdit reciba el foco del teclado.

Ten en cuenta que TextEdit no implementa el desplazamiento, el seguimiento del cursor ni otros comportamientos específicos de una apariencia gráfica. Por ejemplo, para añadir un desplazamiento con gesto que siga al cursor:

Flickable {
     id: flick

     width: 300; height: 200;
     contentWidth: edit.contentWidth
     contentHeight: edit.contentHeight
     clip: true

     function ensureVisible(r)
     {
         if (contentX >= r.x)
             contentX = r.x;
         else if (contentX+width <= r.x+r.width)
             contentX = r.x+r.width-width;
         if (contentY >= r.y)
             contentY = r.y;
         else if (contentY+height <= r.y+r.height)
             contentY = r.y+r.height-height;
     }

     TextEdit {
         id: edit
         width: flick.width
         focus: true
         wrapMode: TextEdit.Wrap
         onCursorRectangleChanged: flick.ensureVisible(cursorRectangle)
     }
 }

Un aspecto y comportamiento concreto podría utilizar el desplazamiento suave (por ejemplo, mediante SmoothedAnimation), podría tener una barra de desplazamiento visible o una barra de desplazamiento que aparezca gradualmente para mostrar la ubicación, etc.

La compatibilidad con el portapapeles se proporciona mediante las funciones cut(), copy() y paste(). El texto se puede seleccionar con el ratón de la forma habitual, a menos que selectByMouse esté establecido en false; y con el teclado mediante las combinaciones de teclas Shift+arrow, a menos que selectByKeyboard esté establecido en false. Para seleccionar texto mediante programación, puede establecer las propiedades selectionStart y selectionEnd, o utilizar selectAll() o selectWord().

Se puede convertir entre posiciones del cursor (caracteres desde el inicio del documento) y puntos de píxel utilizando positionAt() y positionToRectangle().

Véase también Text, TextInput, TextArea y Qt Quick Controles: Editor de texto.

Documentación de propiedades

activeFocusOnPress : bool

Si el elemento « TextEdit » debe recibir el foco activo al pulsar el botón del ratón. Por defecto, esta opción está configurada en «true».

baseUrl : url

Esta propiedad especifica una URL base que se utiliza para resolver las URL relativas que aparecen en el texto.

El valor por defecto es la URL del archivo QML que crea la instancia del elemento « TextEdit ».

bottomPadding : real

leftPadding : real

padding : real

rightPadding : real

topPadding : real

Estas propiedades definen el relleno que rodea el contenido. Este espacio se reserva además de los valores « contentWidth » y « contentHeight ».

canPaste : bool [read-only]

Devuelve «true» si el objeto « TextEdit » es escribible y el contenido del portapapeles es adecuado para pegarlo en el objeto « TextEdit ».

canRedo : bool [read-only]

Devuelve «true» si el objeto « TextEdit » es grabable y hay operaciones de « undone » que se pueden deshacer.

canUndo : bool [read-only]

Devuelve «true» si el « TextEdit » es modificable y hay operaciones anteriores que se pueden deshacer.

color : color

El color del texto.

// green text using hexadecimal notation
TextEdit { color: "#00FF00" }
// steelblue text using SVG color name
TextEdit { color: "steelblue" }

contentHeight : real [read-only]

Devuelve la altura del texto, incluida la parte que sobresale de la altura establecida en caso de que el texto no quepa dentro de dicha altura.

contentWidth : real [read-only]

Devuelve la anchura del texto, incluida la anchura que sobresale más allá de la anchura cubierta debido a un ajuste de línea insuficiente, si se ha establecido la opción « wrapMode ».

cursorDelegate : Component

El delegado del cursor en ` TextEdit`.

Si se establece un cursorDelegate para un TextEdit, este delegado se utilizará para dibujar el cursor en lugar del cursor estándar. El creará y gestionará una instancia del delegado cuando se necesite un cursor, y las propiedades x e y de la instancia del delegado se establecerán de modo que se sitúen un píxel antes de la esquina superior izquierda del carácter actual.

Ten en cuenta que el elemento raíz del componente delegado debe ser un elemento derivado de ` QQuickItem ` o ` QQuickItem `.

cursorPosition : int

La posición del cursor en el objeto ` TextEdit`. El cursor se sitúa entre caracteres.

Nota: En este caso,los caracteres se refieren a la cadena de objetos ` QChar `, es decir, caracteres Unicode de 16 bits, y la posición se considera un índice dentro de esta cadena. Esto no se corresponde necesariamente con grafemas individuales del sistema de escritura, ya que un solo grafema puede estar representado por varios caracteres Unicode, como ocurre en el caso de los pares sustitutos, las ligaduras lingüísticas o los signos diacríticos.

cursorRectangle : rectangle [read-only]

El rectángulo en el que se muestra el cursor de texto estándar dentro del campo de edición de texto. Solo lectura.

La posición y la altura de un « cursorDelegate » personalizado se actualizan para seguir automáticamente el «cursorRectangle» cuando este cambia. La anchura del delegado no se ve afectada por los cambios en el rectángulo del cursor.

cursorSelection : QtQuick::TextSelection [read-only, technology preview]

Esta propiedad se encuentra en fase de vista previa tecnológica y está sujeta a cambios.

Esta propiedad es un objeto que proporciona las propiedades del texto seleccionado actualmente, si las hay, junto al cursor de texto.

Esta propiedad se introdujo en Qt 6.7.

Véase también selectedText, selectionStart y selectionEnd.

cursorVisible : bool

Si el valor es «true», el campo de texto muestra un cursor.

Esta propiedad se activa y desactiva cuando el campo de texto obtiene el foco activo, pero también se puede establecer directamente (lo cual resulta útil, por ejemplo, si un KeyProxy pudiera reenviarle teclas).

effectiveHorizontalAlignment : enumeration [read-only]

horizontalAlignment : enumeration

verticalAlignment : enumeration

Establece la alineación horizontal y vertical del texto dentro del ancho y la altura del elemento « TextEdit ». Por defecto, la alineación del texto sigue la alineación natural del mismo; por ejemplo, el texto que se lee de izquierda a derecha se alineará a la izquierda.

Los valores válidos para ` horizontalAlignment ` son:

ConstanteDescripción
TextEdit.AlignLeftalineación a la izquierda con bordes irregulares a la derecha (por defecto)
TextEdit.AlignRightalinea cada línea a la derecha con bordes irregulares a la izquierda
TextEdit.AlignHCenteralineación de cada línea al centro
TextEdit.AlignJustifyAlinea cada línea tanto a la derecha como a la izquierda, separando las palabras según sea necesario

Los valores válidos para « verticalAlignment » son:

ConstanteDescripción
TextEdit.AlignTopempezar por la parte superior del elemento (por defecto)
TextEdit.AlignBottomAlinea la última línea a la parte inferior y las demás líneas por encima
TextEdit.AlignVCenterAlinea el centro verticalmente

Al utilizar la propiedad asociada LayoutMirroring::enabled para reflejar los diseños de la aplicación, la alineación horizontal del texto también se reflejará. Sin embargo, la propiedad horizontalAlignment permanecerá sin cambios. Para consultar la alineación horizontal efectiva de TextEdit, utilice la propiedad de solo lectura effectiveHorizontalAlignment.

font.bold : bool

Establece si el peso de la fuente es negrita.

font.capitalization : enumeration

Establece el uso de mayúsculas en el texto.

ConstanteDescripción
Font.MixedCaseno se aplica ningún cambio en las mayúsculas
Font.AllUppercasemodifica el texto para que se muestre todo en mayúsculas
Font.AllLowercasemodifica el texto para que se muestre todo en minúsculas
Font.SmallCapscambia el texto para que se muestre en versalitas
Font.Capitalizemodifica el texto para que se muestre con la primera letra de cada palabra en mayúscula
TextEdit { text: "Hello"; font.capitalization: Font.AllLowercase }

font.contextFontMerging : bool [since 6.8]

Si la fuente seleccionada no contiene un carácter determinado, Qt elige automáticamente una fuente alternativa de aspecto similar que sí lo contenga. Por defecto, esto se hace carácter por carácter.

Esto significa que, en ciertos casos poco habituales, pueden utilizarse muchas fuentes diferentes para representar una misma cadena de texto, incluso si pertenece al mismo alfabeto. Al establecer ` contextFontMerging ` en «true», se intentará encontrar, en su lugar, la fuente alternativa que coincida con el mayor subconjunto de la cadena de entrada. Esto supondrá un mayor coste para las cadenas en las que falten glifos, pero puede ofrecer resultados más coherentes. Por defecto, « contextFontMerging » tiene el valor « false ».

Esta propiedad se introdujo en Qt 6.8.

Véase también « QFont::StyleStrategy ».

font.family : string

Establece el nombre de la familia de la fuente.

El nombre de la familia no distingue entre mayúsculas y minúsculas y puede incluir, opcionalmente, el nombre de la fundición, por ejemplo, «Helvetica [Cronyx]». Si la familia está disponible en más de una fundición tipográfica y no se especifica ninguna, se elige una fundición al azar. Si la familia no está disponible, se establecerá una utilizando el algoritmo de coincidencia de fuentes.

font.features : object [since 6.6]

Aplica valores enteros a características específicas de OpenType al dar forma al texto en función del contenido. Esto proporciona un acceso avanzado al proceso de modelado de la fuente y puede utilizarse para admitir características de fuente que, de otro modo, no estarían cubiertas por la API.

Las características de la fuente se representan mediante una correspondencia entre etiquetas de cuatro letras y valores enteros. Este valor entero, que en la mayoría de los casos se pasa junto con la etiqueta, representa un valor booleano: un valor cero significa que la característica está desactivada, y un valor distinto de cero significa que está activada. Sin embargo, en el caso de determinadas características de fuente, puede tener otras interpretaciones. Por ejemplo, cuando se aplica a la característica « salt », el valor es un índice que especifica la alternativa estilística que se debe utilizar.

Por ejemplo, la característica tipográfica « frac » convertirá las fracciones diagonales separadas por una barra (como 1/2) en una representación diferente. Normalmente, esto implicará integrar la fracción completa en un solo ancho de carácter (como ½).

Si una fuente admite la característica « frac », se puede habilitar en el shaper tal y como se muestra en el siguiente código:

Text {
    text: "One divided by two is 1/2"
    font.family: "MyFractionFont"
    font.features: { "frac": 1 }
}

Se pueden asignar valores a varias características en la misma asignación. Por ejemplo, si también deseas desactivar el kerning de la fuente, puedes desactivarlo explícitamente de la siguiente manera:

Text {
    text: "One divided by two is 1/2"
    font.family: "MyFractionFont"
    font.features: { "frac": 1, "kern": 0 }
}

También puedes recopilar las propiedades de la fuente en un objeto:

Text {
    text: "One divided by two is 1/2"
    font: {
        family: "MyFractionFont"
        features: { "frac": 1, "kern": 0 }
    }
}

Nota: De forma predeterminada, Qt activará y desactivará determinadas características de las fuentes en función de otras propiedades de las mismas. En concreto, la característica « kern » se activará o desactivará en función de la propiedad « font::kerning ». Además, todas las características de ligaduras (liga, clig,

dlig, hlig) se desactivarán si se establece font.letterSpacing, pero solo para los sistemas de escritura en los que el uso de ligaduras es meramente estético. En los sistemas de escritura en los que se requieren ligaduras, las características se mantendrán en su estado predeterminado. Los valores establecidos mediante font.features anularán el comportamiento predeterminado. Si, por ejemplo, "kern" se establece en 1, el kerning estará siempre activado, independientemente de si la propiedad font::kerning está establecida en false. Del mismo modo,

si se establece en 0, siempre estará desactivado.

Esta propiedad se introdujo en Qt 6.6.

Véase también QFont::setFeature().

font.hintingPreference : enumeration

Establece el «hinting» preferido para el texto.

Se trata de una indicación al sistema de representación de texto subyacente para que utilice un determinado nivel de ajuste, y su compatibilidad varía según las plataformas. Consulte la tabla de la documentación de QFont::HintingPreference para obtener más detalles.

Nota: Esta propiedad solo surte efecto cuando se utiliza junto con el tipo de representación Text.NativeRendering.

ConstanteDescripción
Font.PreferDefaultHintingUtiliza el nivel de hinting predeterminado para la plataforma de destino.
Font.PreferNoHintingSi es posible, representa el texto sin aplicar hints a los contornos de los glifos. La composición del texto será tipográficamente precisa, utilizando las mismas métricas que se emplean, por ejemplo, en la impresión.
Font.PreferVerticalHintingSi es posible, renderiza el texto sin hinting horizontal, pero alinea los glifos con la cuadrícula de píxeles en dirección vertical. El texto aparecerá más nítido en pantallas cuya densidad sea demasiado baja para ofrecer una representación precisa de los glifos. Sin embargo, dado que las métricas horizontales de los glifos no están ajustadas, la maquetación del texto será escalable a dispositivos de mayor densidad (como impresoras) sin que ello afecte a detalles como los saltos de línea.
Font.PreferFullHintingSi es posible, representa el texto con hinting tanto en dirección horizontal como vertical. El texto se modificará para optimizar la legibilidad en el dispositivo de destino, pero, dado que las métricas dependerán del tamaño de destino del texto, las posiciones de los glifos, los saltos de línea y otros detalles tipográficos no se adaptarán, lo que significa que el diseño del texto puede verse diferente en dispositivos con distintas densidades de píxeles.
Text { text: "Hello"; renderType: Text.NativeRendering; font.hintingPreference: Font.PreferVerticalHinting }

font.italic : bool

Establece si la fuente tiene estilo cursivo.

font.kerning : bool

Activa o desactiva la característica OpenType de kerning al dar forma al texto. Desactivarla puede mejorar el rendimiento al crear o modificar el texto, aunque a costa de perder algunas características estéticas. El valor por defecto es « true ».

Text { text: "OATS FLAVOUR WAY"; font.kerning: false }

font.letterSpacing : real

Establece el espaciado entre letras de la fuente.

El espaciado entre letras modifica el espaciado predeterminado entre las letras individuales de la fuente. Un valor positivo aumenta el espaciado entre letras en los píxeles correspondientes; un valor negativo lo reduce.

font.pixelSize : int

Establece el tamaño de la fuente en píxeles.

El uso de esta función hace que la fuente dependa del dispositivo. Utiliza ` TextEdit::font.pointSize ` para establecer el tamaño de la fuente de forma independiente del dispositivo.

font.pointSize : real

Establece el tamaño de la fuente en puntos. El tamaño en puntos debe ser mayor que cero.

font.preferShaping : bool

A veces, una fuente aplica reglas complejas a un conjunto de caracteres para que se muestren correctamente. En algunos sistemas de escritura, como las escrituras brahmicas, esto es necesario para que el texto sea legible, pero en la escritura latina, por ejemplo, se trata simplemente de una característica estética. Al establecer la propiedad « preferShaping » en «false», se desactivarán todas estas características cuando no sean necesarias, lo que mejorará el rendimiento en la mayoría de los casos.

El valor por defecto es « true ».

Text { text: "Some text"; font.preferShaping: false }

font.preferTypoLineMetrics : bool [since 6.8]

Conjuntos alternativos de métricas de línea vertical que proporcionan el ascent, descent y leading de la fuente. A menudo se les conoce como métricas «win» (de Windows) y métricas «typo» (tipográficas). Aunque la especificación recomienda utilizar las métricas typo para el interlineado, muchas aplicaciones prefieren las métricas win, a menos que se haya establecido el indicador USE_TYPO_METRICS en el campo fsSelection de la fuente. Por motivos de compatibilidad con versiones anteriores, esto también se aplica a las aplicaciones Qt. Esto no supone ningún problema para las fuentes que establecen el indicador « USE_TYPO_METRICS » para indicar que las métricas « typo » son válidas, ni para aquellas en las que las métricas « win » y « typo » coinciden. Sin embargo, en determinadas fuentes, las métricas « win » pueden ser mayores que el interlineado preferido y el indicador « USE_TYPO_METRICS » puede estar desactivado por error. En el caso de estas fuentes, establecer « font.preferTypoLineMetrics » puede ofrecer mejores resultados.

Por defecto, ` preferTypoLineMetrics ` es ` false`.

Esta propiedad se introdujo en Qt 6.8.

Véase también « QFont::StyleStrategy ».

font.strikeout : bool

Establece si la fuente tiene estilo tachado.

font.styleName : string

Establece el nombre del estilo de la fuente.

El nombre del estilo no distingue entre mayúsculas y minúsculas. Si se establece, la fuente se buscará por el nombre del estilo en lugar de por las propiedades de fuente font.weight, font.bold y font.italic.

font.underline : bool

Establece si el texto aparece subrayado.

font.variableAxes : object [since 6.7]

Aplica valores de coma flotante a los ejes variables en las fuentes variables.

Las fuentes variables permiten almacenar múltiples variaciones (con diferentes grosores, anchos o estilos) en un mismo archivo de fuente. Las variaciones se especifican como valores de coma flotante para un conjunto predefinido de parámetros, denominados «ejes variables». El diseñador de la fuente suele asignar nombres a las instancias específicas y, en Qt, estas se pueden seleccionar mediante setStyleName(), al igual que las subfamilias tradicionales.

En algunos casos, también resulta útil proporcionar valores arbitrarios para los diferentes ejes. Por ejemplo, si una fuente tiene una subfamilia Regular y otra Negrita, es posible que se desee un grosor intermedio entre ambas. En ese caso, se podría solicitar manualmente proporcionando un valor personalizado para el eje «wght» de la fuente.

Text {
    text: "Foobar"
    font.family: "MyVariableFont"
    font.variableAxes: { "wght": (Font.Normal + Font.Bold) / 2.0 }
}

Si la fuente admite el eje «wght» y el valor proporcionado se encuentra dentro de su rango definido, se proporcionará una fuente correspondiente al peso 550,0.

Existen algunos ejes estándar que ofrecen muchas fuentes, como «wght» (peso), «wdth» (anchura), «ital» (cursiva) y «opsz» (tamaño óptico). Cada uno de ellos tiene rangos individuales definidos en la propia fuente. Por ejemplo, «wght» puede oscilar entre 100 y 900 (QFont::Thin a QFont::Black), mientras que «ital» puede oscilar entre 0 y 1 (de no cursiva a totalmente cursiva).

Una fuente también puede optar por definir ejes personalizados; la única limitación es que el nombre debe cumplir los requisitos de un QFont::Tag (secuencia de cuatro caracteres Latin-1).

Por defecto, no se establecen ejes variables.

Nota: En Windows, los ejes variables no son compatibles si se utiliza el backend de fuentes GDI opcional.

Esta propiedad se introdujo en Qt 6.7.

Véase también QFont::setVariableAxis().

font.weight : int

El grosor solicitado de la fuente. El grosor solicitado debe ser un número entero comprendido entre 1 y 1000, o uno de los valores predefinidos:

ConstanteDescripción
Font.Thin100
Font.ExtraLight200
Font.Light300
Font.Normal400 (por defecto)
Font.Medium500
Font.DemiBold600
Font.Bold700
Font.ExtraBold800
Font.Black900
Text { text: "Hello"; font.weight: Font.DemiBold }

font.wordSpacing : real

Establece el espaciado entre palabras de la fuente.

El espaciado entre palabras modifica el espaciado predeterminado entre palabras individuales. Un valor positivo aumenta el espaciado entre palabras en la cantidad correspondiente de píxeles, mientras que un valor negativo lo reduce en la misma proporción.

Esta propiedad contiene la cadena del enlace cuando el usuario pasa el cursor por encima de un enlace incrustado en el texto. El enlace debe estar en formato de texto enriquecido o HTML, y la cadena del enlace permite acceder a dicho enlace.

Véase también linkHovered y linkAt().

inputMethodComposing : bool [read-only]

Esta propiedad indica si el objeto ` TextEdit ` contiene texto parcial introducido mediante un método de entrada.

Durante la redacción, un método de entrada puede basarse en eventos del ratón o del teclado procedentes del « TextEdit » para editar o confirmar el texto parcial. Esta propiedad se puede utilizar para determinar cuándo desactivar los controladores de eventos que puedan interferir en el correcto funcionamiento de un método de entrada.

inputMethodHints : enumeration

Proporciona indicaciones al método de entrada sobre el contenido esperado del campo de edición de texto y cómo debe funcionar.

El valor es una combinación bit a bit de indicadores o Qt.ImhNone si no se ha establecido ninguna indicación.

Los indicadores que modifican el comportamiento son:

ConstanteDescripción
Qt.ImhHiddenTextLos caracteres deben ocultarse, como suele hacerse al introducir contraseñas.
Qt.ImhSensitiveDataEl texto escrito no debe ser almacenado por el método de entrada activo en ningún almacenamiento persistente, como el diccionario predictivo del usuario.
Qt.ImhNoAutoUppercaseEl método de entrada no debe intentar cambiar automáticamente a mayúsculas al finalizar una frase.
Qt.ImhPreferNumbersSe prefieren los números (aunque no son obligatorios).
Qt.ImhPreferUppercaseSe prefieren las mayúsculas (aunque no son obligatorias).
Qt.ImhPreferLowercaseSe prefieren las letras minúsculas (aunque no son obligatorias).
Qt.ImhNoPredictiveTextNo utilices el texto predictivo (es decir, la búsqueda en el diccionario) mientras escribes.
Qt.ImhDateEl editor de texto funciona como un campo de fecha.
Qt.ImhTimeEl editor de texto funciona como un campo de hora.

Los indicadores que restringen la entrada (indicadores exclusivos) son:

ConstanteDescripción
Qt.ImhDigitsOnlySolo se permiten dígitos.
Qt.ImhFormattedNumbersOnlySolo se permite la introducción de números. Esto incluye el punto decimal y el signo menos.
Qt.ImhUppercaseOnlySolo se permite la introducción de letras mayúsculas.
Qt.ImhLowercaseOnlySolo se permite introducir letras minúsculas.
Qt.ImhDialableCharactersOnlySolo se permiten caracteres aptos para marcar un número de teléfono.
Qt.ImhEmailCharactersOnlySolo se permiten caracteres adecuados para direcciones de correo electrónico.
Qt.ImhUrlCharactersOnlySolo se permiten caracteres aptos para direcciones URL.

Máscaras:

ConstanteDescripción
Qt.ImhExclusiveInputMaskEsta máscara devuelve un valor distinto de cero si se utiliza cualquiera de los indicadores exclusivos.

length : int [read-only]

Devuelve el número total de caracteres de texto sin formato del elemento TextEdit.

Dado que este número no incluye ningún marcador de formato, es posible que no coincida con la longitud de la cadena devuelta por la propiedad ` text `.

Esta propiedad puede resultar más rápida que consultar la longitud mediante la propiedad ` text `, ya que no requiere copiar ni convertir los datos de cadena internos de ` TextEdit`.

lineCount : int [read-only]

Devuelve el número total de líneas del elemento « TextEdit ».

mouseSelectionMode : enumeration

Especifica cómo se debe seleccionar el texto con el ratón.

ConstanteDescripción
TextEdit.SelectCharacters(por defecto) La selección se actualiza con caracteres individuales.
TextEdit.SelectWordsLa selección se actualiza con palabras completas.

Esta propiedad solo se aplica cuando « selectByMouse » es «true».

overwriteMode : bool

Si el texto introducido por el usuario sobrescribirá el texto existente.

Al igual que en muchos editores de texto, el widget del editor de texto se puede configurar para insertar o sobrescribir el texto existente con el nuevo texto introducido por el usuario.

Si esta propiedad se establece en « true », el texto existente se sobrescribe, carácter por carácter, con el nuevo texto; de lo contrario, el texto se inserta en la posición del cursor, desplazando el texto existente.

Por defecto, esta propiedad tiene el valor « false » (el nuevo texto no sobrescribe el texto existente).

persistentSelection : bool

Si el « TextEdit » debe mantener visible la selección cuando pierde el foco activo en favor de otro elemento de la escena. Por defecto, este valor está establecido en «false».

preeditText : string [read-only]

Esta propiedad contiene texto introducido parcialmente mediante un método de entrada.

Para desactivar el texto parcial resultante de las predicciones, configura el indicador « Qt.ImhNoPredictiveText » en inputMethodHints.

Véase también inputMethodHints.

readOnly : bool

Indica si el usuario puede interactuar con el elemento ` TextEdit `. Si esta propiedad se establece en `true`, el usuario no podrá editar el texto.

Por defecto, esta propiedad tiene el valor «false».

renderType : enumeration

Sobrescribir el tipo de representación predeterminado para este componente.

Los tipos de representación admitidos son:

ConstanteDescripción
TextEdit.QtRenderingEl texto se representa utilizando un campo de distancia escalable para cada glifo.
TextEdit.NativeRenderingEl texto se representa utilizando una técnica específica de la plataforma.
TextEdit.CurveRenderingEl texto se renderiza utilizando un rasterizador de curvas que se ejecuta directamente en el hardware gráfico. (Introducido en Qt 6.7.0.)

Selecciona « TextEdit.NativeRendering » si prefieres que el texto tenga un aspecto nativo en la plataforma de destino y no necesitas funciones avanzadas, como la transformación del texto. El uso de dichas funciones en combinación con el tipo de renderizado «NativeRendering» dará lugar a resultados de baja calidad y, en ocasiones, pixelados.

Tanto « TextEdit.QtRendering » como « TextEdit.CurveRendering » son técnicas aceleradas por hardware. « QtRendering » es la más rápida de las dos, pero consume más memoria y presenta artefactos de renderizado en tamaños grandes. « CurveRendering » debe considerarse como alternativa en los casos en que « QtRendering » no ofrezca buenos resultados visuales o cuando sea prioritario reducir el consumo de memoria gráfica.

El tipo de renderizado predeterminado viene determinado por QQuickWindow::textRenderType().

selectByKeyboard : bool

Por defecto, es «true» cuando el editor es editable y «false» cuando es de solo lectura.

Si es «true», el usuario puede utilizar el teclado para seleccionar texto aunque el editor sea de solo lectura. Si es «false», el usuario no puede utilizar el teclado para seleccionar texto aunque el editor sea editable.

Véase también readOnly.

selectByMouse : bool

El valor por defecto es « true » desde Qt 6.4.

Si se establece en « true », el usuario puede utilizar el ratón para seleccionar texto de la forma habitual.

Nota: En versiones anteriores a la 6.4, el valor por defecto era false; pero si se habilitaba esta propiedad, también se podía seleccionar texto en una pantalla táctil deslizando el dedo por ella. Esto interfería con el movimiento rápido (flicking) cuando se utilizaba TextEdit dentro de un Flickable. Sin embargo, Qt admite los controladores de selección de texto en plataformas móviles y en plataformas embebidas que utilizan Qt Virtual Keyboard, desde la versión 5.7, a través de QInputMethod. A la mayoría de los usuarios les sorprendería que al arrastrar con el dedo se seleccionara el texto en lugar de deslizar el Flickable padre. Por lo tanto, «selectByMouse» ahora significa realmente lo que dice: si se establece « true », se puede seleccionar texto arrastrando solo con el ratón, mientras que se espera que la plataforma proporcione controles de selección en pantallas táctiles. Si este cambio no se adapta a tu aplicación, puedes establecer « selectByMouse » en « false », o importar una versión anterior de la API (por ejemplo, « import QtQuick 6.3 ») para volver al comportamiento anterior. La opción de revertir el comportamiento cambiando la versión de importación se eliminará en una versión posterior de Qt.

selectedText : string [read-only]

Esta propiedad de solo lectura proporciona el texto seleccionado actualmente en el campo de texto.

Es equivalente al siguiente fragmento de código, pero es más rápido y fácil de usar.

//myTextEdit is the id of the TextEdit
myTextEdit.text.toString().substring(myTextEdit.selectionStart,
        myTextEdit.selectionEnd);

selectedTextColor : color

El color del texto seleccionado, que se utiliza en las selecciones.

selectionColor : color

El color de resaltado del texto, que se utiliza detrás de las selecciones.

selectionEnd : int [read-only]

La posición del cursor tras el último carácter de la selección actual.

Esta propiedad es de solo lectura. Para modificar la selección, utiliza select(start,end), selectAll() o selectWord().

Véase también selectionStart, cursorPosition y selectedText.

selectionStart : int [read-only]

La posición del cursor antes del primer carácter de la selección actual.

Esta propiedad es de solo lectura. Para modificar la selección, utiliza select(start,end), selectAll() o selectWord().

Véase también ` selectionEnd`, ` cursorPosition` y ` selectedText`.

tabStopDistance : real

La distancia predeterminada, en unidades del dispositivo, entre los puntos de tabulación.

Véase también QTextOption::setTabStopDistance().

text : string

El texto que se va a mostrar. Si el formato de texto es «AutoText», el editor de texto determinará automáticamente si el texto debe tratarse como texto con formato. Esta determinación se realiza mediante la función Qt::mightBeRichText(). Sin embargo, la detección de Markdown no es automática.

La propiedad «text» resulta especialmente adecuada para establecer el contenido inicial y gestionar modificaciones en contenidos de texto relativamente pequeños. Los métodos append(), insert() y remove() proporcionan un control más preciso y un rendimiento notablemente mejor a la hora de modificar contenidos de texto enriquecido especialmente grandes.

Ten en cuenta que algunos teclados utilizan una función predictiva. En este caso, el texto que se está componiendo mediante el método de entrada no forma parte de esta propiedad. La parte del texto relacionada con las predicciones aparece subrayada y se almacena en la propiedad preeditText.

Si has utilizado ` TextDocument::source ` para cargar texto, puedes recuperar el texto cargado a partir de esta propiedad. En ese caso, puedes cambiar ` textFormat ` para realizar conversiones de formato que modificarán el valor de la propiedad ` text `. Por ejemplo, si ` textFormat ` es ` RichText ` o ` AutoText ` y cargas un archivo HTML, y después estableces ` textFormat ` en ` MarkdownText `, la propiedad ` text ` contendrá la conversión de HTML a Markdown.

Véase también clear(), preeditText y textFormat.

textDocument : TextDocument [read-only]

Devuelve el objeto ` QQuickTextDocument ` de este ` TextEdit`. Desde Qt 6.7, cuenta con funciones para cargar y guardar archivos. También se puede utilizar en C++ como medio para acceder a la instancia subyacente de ` QTextDocument `, por ejemplo, para instalar un ` QSyntaxHighlighter`.

Véase también QQuickTextDocument.

textFormat : enumeration

La forma en que debe mostrarse la propiedad « text ».

Los formatos de texto admitidos son:

ConstanteDescripción
TextEdit.PlainText(por defecto) todas las etiquetas de estilo se tratan como texto sin formato
TextEdit.AutoTextdetectado mediante la heurística Qt::mightBeRichText() o el formato de archivo de TextDocument::source
TextEdit.RichTextun subconjunto de HTML 4
TextEdit.MarkdownTextCommonMark más las extensiones de GitHub para tablas y listas de tareas (desde la versión 5.14)

El valor por defecto es TextEdit.PlainText. Si el formato de texto se establece en TextEdit.AutoText, el editor de texto determinará automáticamente si el texto debe tratarse como texto enriquecido. Si se establece la propiedad text, esta determinación se realiza mediante Qt::mightBeRichText(), que puede detectar la presencia de una etiqueta HTML en la primera línea de texto, pero no puede distinguir Markdown del texto sin formato. Si se establece la propiedad ` TextDocument::source `, esta determinación se realiza a partir de ` mime type of the file`.

Column {
    TextEdit {
        font.pointSize: 24
        textFormat: TextEdit.AutoText
        text: "<b>Hello</b> <i>World!</i>"
    }
    TextEdit {
        font.pointSize: 24
        textFormat: TextEdit.RichText
        text: "<b>Hello</b> <i>World!</i>"
    }
    TextEdit {
        font.pointSize: 24
        textFormat: TextEdit.PlainText
        text: "<b>Hello</b> <i>World!</i>"
    }
    TextEdit {
        font.pointSize: 24
        textFormat: TextEdit.MarkdownText
        text: "**Hello** *World!*"
    }
}

Ejemplos de visualización en varios formatos de texto: AutoText, HTML, texto sin formato y Markdown

Con « TextEdit.MarkdownText », las casillas de selección que se obtienen al utilizar la extensión de casillas de selección de GitHub se pueden marcar de forma interactiva.

Si se establece la propiedad ` TextDocument::source `, cambiar la propiedad ` textFormat ` tras la carga tiene como efecto la conversión del formato detectado al formato solicitado. Por ejemplo, puedes convertir entre HTML y Markdown. Sin embargo, si se carga cualquiera de esos formatos «enriquecidos» y, a continuación, se establece textFormat en PlainText, el TextEdit mostrará el código sin formato. Así, unos enlaces adecuados (por ejemplo, a un control que se pueda marcar) pueden permitir al usuario alternar entre la edición «sin formato» y la edición WYSIWYG.

Nota: No se admite la introduccióninteractiva de código de marcado o formato Markdown en modo WYSIWYG; sin embargo, puedes cambiar a PlainText, realizar los cambios y, a continuación, volver a la configuración adecuada en textFormat.

Nota: Con Text.MarkdownText y con el subconjunto de HTML compatible, algunos elementos decorativos no se representan tal y como lo harían en un navegador web:

  • los bloques de código utilizan el default monospace font, pero sin un recuadro de resaltado a su alrededor
  • las citas en bloque están sangradas, pero no hay una línea vertical junto a la cita

textMargin : real

El margen, en píxeles, que rodea el texto en TextEdit.

wrapMode : enumeration

Establece esta propiedad para que el texto se ajuste al ancho del elemento « TextEdit ». El texto solo se ajustará si se ha establecido un ancho explícito.

ConstanteDescripción
TextEdit.NoWrap(por defecto) no se realizará ningún ajuste de línea. Si el texto no contiene suficientes saltos de línea, « implicitWidth » superará el ancho establecido.
TextEdit.WordWrapEl ajuste se realiza únicamente en los límites de las palabras. Si una palabra es demasiado larga, « implicitWidth » superará el ancho establecido.
TextEdit.WrapAnywhereEl ajuste de línea se realiza en cualquier punto de una línea, incluso si se produce en medio de una palabra.
TextEdit.WrapSi es posible, el ajuste de línea se realiza en el límite de una palabra; de lo contrario, se realizará en el punto adecuado de la línea, incluso en medio de una palabra.

El valor por defecto es « TextEdit.NoWrap ». Si estableces un ancho, considera utilizar « TextEdit.Wrap ».

Documentación de Signal

editingFinished()

Esta señal se emite cuando el campo de edición de texto pierde el foco.

Nota: El controlador correspondiente es onEditingFinished.

linkActivated(string link)

Esta señal se emite cuando el usuario hace clic en un enlace incrustado en el texto. El enlace debe estar en formato de texto enriquecido o HTML, y la cadena « link » permite acceder a dicho enlace.

Nota: El controlador correspondiente es onLinkActivated.

linkHovered(string link)

Esta señal se emite cuando el usuario pasa el cursor por encima de un enlace incrustado en el texto. El enlace debe estar en formato de texto enriquecido o HTML, y la cadena « link » permite acceder a ese enlace concreto.

Nota: El controlador correspondiente es onLinkHovered.

Véase también hoveredLink y linkAt().

[since 6.9] textEdited()

Esta señal se emite cada vez que se edita el texto. A diferencia de textChanged(), esta señal no se emite cuando el texto se modifica mediante código, por ejemplo, al cambiar el valor de la propiedad text o al llamar a clear().

Nota: El controlador correspondiente es onTextEdited.

Esta señal se introdujo en Qt 6.9.

Documentación de métodos

void append(string text)

Añade un nuevo párrafo con ` text ` al final de ` TextEdit`.

Para añadir el texto sin insertar un nuevo párrafo, utiliza en su lugar la función ` myTextEdit.insert(myTextEdit.length, text) `.

void clear()

Borra el contenido del campo de edición de texto y restablece la entrada parcial de texto procedente de un método de entrada.

Utiliza este método en lugar de establecer la propiedad « text » en una cadena vacía.

Véase también QInputMethod::reset().

void copy()

Copia el texto seleccionado actualmente al portapapeles del sistema.

void cut()

Copia el texto seleccionado actualmente al portapapeles del sistema.

void deselect()

Elimina la selección de texto activa.

string getFormattedText(int start, int end)

Devuelve la sección de texto que se encuentra entre las posiciones « start » y « end ».

El texto devuelto se formateará según la propiedad textFormat.

string getText(int start, int end)

Devuelve la sección de texto que se encuentra entre las posiciones start y end.

El texto devuelto no incluye ningún formato de texto enriquecido.

void insert(int position, string text)

Inserta « text » en la base de datos « TextEdit » en position.

bool isRightToLeft(int start, int end)

Devuelve « true » si la dirección natural de lectura del texto del editor que se encuentra entre las posiciones start y end es de derecha a izquierda.

string linkAt(real x, real y)

Devuelve la cadena del enlace en el punto x, y en coordenadas de contenido, o una cadena vacía si no existe ningún enlace en ese punto.

Véase también hoveredLink.

void moveCursorSelection(int position, SelectionMode mode)

Mueve el cursor a position y actualiza la selección según el parámetro opcional mode. (Para mover únicamente el cursor, configura la propiedad cursorPosition ).

Cuando se invoca este método, además establece el « selectionStart » o el « selectionEnd » (el que se encontrara en la posición anterior del cursor) en la posición especificada. Esto permite ampliar y reducir fácilmente el rango de texto seleccionado.

El modo de selección especifica si la selección se actualiza carácter a carácter o palabra a palabra. Si no se especifica, el modo de selección será, por defecto, « TextEdit.SelectCharacters ».

ConstanteDescripción
TextEdit.SelectCharactersEstablece « selectionStart » o « selectionEnd » (el que se encontrara en la posición anterior del cursor) en la posición especificada.
TextEdit.SelectWordsEstablece « selectionStart » y « selectionEnd » para que incluyan todas las palabras entre la posición especificada y la posición anterior del cursor. Se incluyen las palabras que se encuentren parcialmente dentro del rango.

Por ejemplo, consideremos esta secuencia de comandos:

cursorPosition = 5
moveCursorSelection(9, TextEdit.SelectCharacters)
moveCursorSelection(7, TextEdit.SelectCharacters)

Esto mueve el cursor a la posición 5, amplía el final de la selección de 5 a 9 y, a continuación, reduce el final de la selección de 9 a 7, dejando seleccionado el texto desde la posición 5 hasta la 7 (los caracteres 6.º y 7.º).

La misma secuencia con ` TextEdit.SelectWords` ampliará el inicio de la selección hasta un límite de palabra anterior o en la posición 5 y ampliará el final de la selección hasta un límite de palabra en la posición 9 o más allá de ella.

void paste()

Sustituye el texto seleccionado actualmente por el contenido del portapapeles del sistema.

int positionAt(int x, int y)

Devuelve la posición del texto más cercana a la posición del píxel (x, y).

La posición 0 se encuentra antes del primer carácter, la posición 1, después del primero pero antes del segundo, y así sucesivamente hasta la posición text.length, que se encuentra después de todos los caracteres.

rectangle positionToRectangle(position)

Devuelve el rectángulo situado en la « position » indicada en el texto. Las propiedades x, y y altura corresponden al cursor que describiría esa posición.

void redo()

Vuelve a realizar la última operación si la opción «redo» es « available ».

string remove(int start, int end)

Elimina de « TextEdit » el fragmento de texto que se encuentra entre las posiciones « start » y « end ».

void select(int start, int end)

Hace que se seleccione el texto comprendido entre start y end.

Si el punto inicial o el final están fuera del rango, la selección no se modifica.

Tras llamar a este método, selectionStart pasará a ser el menor y selectionEnd el mayor (independientemente del orden en que se pasen los parámetros a este método).

Véase también selectionStart y selectionEnd.

void selectAll()

Hace que se seleccione todo el texto.

void selectWord()

Hace que se seleccione la palabra más cercana a la posición actual del cursor.

void undo()

Deshace la última operación si la opción «Deshacer» está activada ( available). Desmarca cualquier selección actual y actualiza el punto de inicio de la selección a la posición actual del cursor.

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