# TextView (Python)

Sebastian Pölsterl
sebp@k-d-w.org 2011
Marta Maria Casetti
mmcasetti@gmail.com 2012
Un widget que muestra un GtkTextBuffer
Daniel Mustieles
daniel.mustieles@gmail.com 2011 - 2020
Nicolás Satragno
nsatragno@gmail.com 2012 - 2013
Jorge González
jorgegonz@svn.gnome.org 2011

# TextView

Esto es un ejemplo de Gtk.TextView.

Si se pulsa «Intro» se obtiene una línea nueva.

Pero también se puede obtener una línea nueva si se escribe una frase larga (el texto se ajustará a los saltos de línea entre palabras.

Si es escribe una palabra laaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarga

(esto es una palabra larga)

, aparecerá una barra de desplazamiento horizontal.

# Código usado para generar este ejemplo

from gi.repository import Gtk import sys

class MyWindow(Gtk.ApplicationWindow):

def __init__(self, app): Gtk.Window.__init__(self, title="TextView Example", application=app) self.set_default_size(300, 450)

# a scrollbar for the child widget (that is going to be the textview) scrolled_window = Gtk.ScrolledWindow() scrolled_window.set_border_width(5) # we scroll only if needed scrolled_window.set_policy( Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)

# a text buffer (stores text) buffer1 = Gtk.TextBuffer()

# a textview (displays the buffer) textview = Gtk.TextView(buffer=buffer1) # wrap the text, if needed, breaking lines in between words textview.set_wrap_mode(Gtk.WrapMode.WORD)

# textview is scrolled scrolled_window.add(textview)

self.add(scrolled_window)

class MyApplication(Gtk.Application):

def __init__(self): Gtk.Application.__init__(self)

def do_activate(self): win = MyWindow(self) win.show_all()

def do_startup(self): Gtk.Application.do_startup(self)

app = MyApplication() exit_status = app.run(sys.argv) sys.exit(exit_status)

# Métodos útiles para un widget «TextView»

Un `Gtk.TextView` muestra el texto almacenado en un `Gtk.TextBuffer`. Sin embargo, la mayor parte de la manipulación de texto se hace con iteradores, representados por un `Gtk.TextIter`: una posición entre dos caracteres en el búfer de texto. Los iteradores no son válidos indefinidamente; cada vez que se modifica el búfer de alguna manera que se altere su contenido, todos los iteradores relevantes dejan de ser válidos. Es por esto que no se pueden usar iteradores para mantener posiciones entre modificaciones del búfer. Para mantener una posición, se usa una `Gtk.TextMark`, que puede hacerse visible con `visible(True)`. Un búfer de texto contiene dos marcas empotradas: una marca «insert» (la posición del cursor) y la marca «selection_bound».

Métodos para un widget «TextView»:

El widget «TextView» es editable de manera predeterminada. Si prefiere que no lo sea, use `set_editable(False)`. Si el búfer no tiene texto editable, puede ser una buena idea usar `set_cursor_visible(False)` también.

La alineación del texto se establece con `set_justification(Gtk.Justification.JUSTIFICACIÓN)` donde `JUSTIFICACIÓN` puede ser `LEFT, RIGHT, CENTER, FILL`.

El ajuste de línea del texto se establece con `set_wrap_mode(Gtk.WrapMode.WRAP)` donde `WRAP` es uno de `NONE` (el área de texto se hace más ancha), `CHAR` (rompe líneas en cualquier lugar en que el cursor pueda aparecer), `WORD` (rompe líneas entre palabras), `WORD_CHAR` (rompe líneas entre palabras, pero si no es suficiente, entre caracteres).

Métodos para un widget «TextBuffer»:

`get_insert()` devuelve la `Gtk.TextMark` que representa al cursor, que es el punto de inserción.

`get_selection_bound()` devuelve la `Gtk.TextMark` que representa los límites de la selección.

`set_text("texto", longitud)` donde `longitud` es un entero positivo o `-1`, establece el contenido del búfer como los primeros `longitud` caracteres del `"texto"`. Si se omite `longitud` o es `-1`, se inserta todo el texto. El contenido del búfer, si existe, se destruye.

`insert(iter, "texto", longitud)`, donde `iter` es un iterador de texto y `longitud` es un entero positivo o `-1`, inserta en el búfer en `iter` los primeros `longitud` caracteres del `texto`. Si se omite `longitud` o es `-1`, se inserta todo el texto.

`insert_at_cursor("texto", longitud)` hace los mismo que `insert(iter, "texto", longitud)`, tomando el cursor actual como `iter`.

`create_mark("nombre_de_la_marca", iter, gravedad_izquierda)` donde `iter` es un `Gtk.TextIter` y `gravedad_izquierda` es un booleano, crea una `Gtk.TextMark` en la posición de `iter`. Si `"nombre_de_la_marca"` es `None`, la marca es anónima; de lo contrario, la marca puede obtenerse por su nombre usando `get_mark()`. Si una marca tiene gravedad izquierda, y el texto se inserta en la posición actual de la marca, esta se moverá a la izquierda del texto recién insertado. Si `gravedad_izquierda` se omite, su valor predeterminado es `False`.

Para especificar que algún texto en el búfer debe tener un formato específico, defina una etiqueta que contenga esa información de formato, y luego aplíquela a la región de texto usando `create_tag("nombre de la etiqueta", propiedad)` y `apply_tag(etiqueta, iter_inicial, iter_final)` como en, por ejemplo:

tag = textbuffer.create_tag("orange_bg", background="orange") textbuffer.apply_tag(tag, start_iter, end_iter)

A continuación se muestran algunos de los estilos comunes aplicados al texto:

Color de fondo (propiedad «background»)

Color de primer plano (propiedad «foreground»)

Subrayado (propiedad «underline»)

Negrita (propiedad «weight»)

Cursiva (propiedad «style»)

Tachado (propiedad «strikethrough»)

Justificación (propiedad «justification»)

Tamaño (propiedades «size» y «size-points»)

Ajuste de texto (propiedad «wrap-mode»)

También puede eliminar etiquetas particulares más tarde usando `remove_tag()` o eliminar todas las etiquetas en una región dada llamando a `remove_all_tags()`.

Métodos para un widget «TextIter»

`forward_search(cadena, banderas, límite)` busca `cadena` hacia delante. La búsqueda no continuará después del límite `Gtk.TextIter`. Las `banderas` pueden ser cualquier combinación de las siguientes, concatenándolas con el operador OR a nivel de bits `|`: `0` (la coincidencia debe ser exacta); `Gtk.TextSearchFlags.VISIBLE_ONLY` (la coincidencia puede tener texto invisible intercalado en «aguja»); `Gtk.TextSearchFlags.TEXT_ONLY` (la coincidencia puede tener «pixbufs» o widgets hijos mezclados dentro del rango coincidente); `Gtk.TextSearchFlags.CASE_INSENSITIVE` (el texto coincidirá sin importar su capitalización). El método devuelve una tupla que contiene un `Gtk.TextIter` apuntando al inicio y al primer carácter después de la coincidencia; si no se encuentra, se devuelve `None`.

`backward_search(cadena, banderas, límite)` hace lo mismo que `forward_search()`, pero hacia atrás.

# Referencias de la API

En este ejemplo se usa lo siguiente:

GtkTextView

GtkTextBuffer

GtkTextTag

GtkScrolledWindow

Enumeraciones estándar