13.2. Vistas de Texto

Sólo hay una función para crear un control TextView (Vista de Texto).

  textview = gtk.TextView(buffer=None)

Cuando se crea una TextView también se creará un TextBuffer (Buffer de Texto) asociado y una TextTagTable (Tabla de Etiquetas de Texto) de forma predeterminada. Si quieres usar un TextBuffer ya existente en una vista de texto TextView puedes especificarlo en el método anterior. Para cambiar el TextBuffer que usa una TextView usa el siguiente método:

  textview.set_buffer(buffer)

Usa el siguiente método para obtener una referencia al TextBuffer a partir de una TextView:

  buffer = textview.get_buffer()

Un control de TextView no tiene barras de desplazamiento para ajustar la vista en caso de que el texto sea más grande que la ventana. Para incluir barras de desplazamiento, es necesario incluir la TextView en una ScrolledWindow (Ventana de Desplazamiento).

Una TextView se puede usar para permitir la edición de un cuerpo de texto, o para mostrar varias líneas de un texto de sólo lectura al usuario o usuaria. Para cambiar entre estos modos de operación se utiliza el método:

  textview.set_editable(setting)

El argumento setting puede ser TRUE o FALSE y especifica si se permite la edición del contenido del control TextView. El modo de edición de la TextView se puede cambiar por zonas de texto dentro del TextBuffer usando TextTags.

Puedes obtener el modo actual de edición usando el método:

  setting = textview.get_editable()

Cuando la TextView no es editable probablemente se debería ocultar el cursor usando el método:

  textview.set_cursor_visible(setting)

El argumento setting puede ser TRUE o FALSE y especifica si el cursor debe ser visible. La TextView puede ajustar las líneas de texto que son demasiado largas para que quepan en una única línea de la ventana. El comportamiento predeterminado es no ajustar las líneas. Es posible cambiarlo usando el método:

  textview.set_wrap_mode(wrap_mode)

Este método te permite especificar que el texto debe ajustarse en los límites de palabras o caracteres. El argumento word_wrap puede ser:

  gtk.WRAP_NONE # sin ajuste
  gtk.WRAP_CHAR # ajuste por caracteres
  gtk.WRAP_WORD # ajuste por palabras

La justificación predetermianda del texto en una TextView se puede establecer y obtener usando los métodos:

  textview.set_justification(justification)
  justification = textview.get_justification()

donde justification puede ser:

  gtk.JUSTIFY_LEFT   # justificación a la izquierda
  gtk.JUSTIFY_RIGHT  # justificación a la derecha
  gtk.JUSTIFY_CENTER # justificación al centro

Nota

La justificación será JUSTIFY_LEFT si el wrap_mode (modo de ajuste) es WRAP_NONE. Las etiquetas asociadas con un TextBuffer pueden cambiar la justificación predeterminada.

Se pueden modificar y ver otros atributos predeterminados en una TextView, tales como el margen izquierdo, el margen derecho, las tabulaciones y la indentación de párrafos, usando los siguientes métodos:

  # margen izquierdo
  textview.set_left_margin(left_margin)
  left_margin = textview.get_left_margin()
  
  # margen derecho
  textview.set_right_margin(right_margin)
  right_margin = textview.get_right_margin()
  
  # indentación
  textview.set_indent(indent)
  indent = textview.get_indent()
  
  #espacio anterior de línea (en píxeles)
  textview.set_pixels_above_lines(pixels_above_line)
  pixels_above_line = textview.get_pixels_above_lines()
  
  #espacio posterior de línea (en píxeles)
  textview.set_pixels_below_lines(pixels_below_line)
  pixels_below_line = textview.get_pixels_below_lines()
  
  # píxeles en ajuste
  textview.set_pixels_inside_wrap(pixels_inside_wrap)
  pixels_inside_wrap = textview.get_pixels_inside_wrap()

  # tabulaciones  
  textview.set_tabs(tabs)
  tabs = textview.get_tabs()

left_margin, right_margin, indent, pixels_above_lines, pixels_below_lines y pixels_inside_wrap se especifican en píxeles. Los valores predeterminados de estos parámetros se pueden modificar con etiquetas asociadas a un TextBuffer. tabs es un pango.TabArray.

El programa de ejemplo textview-basic.py ilustra el uso básico del control TextView:

Figura 13.1. Ejemplo básico de Vista de Texto

Ejemplo básico de Vista de Texto

El código fuente del programa es:

    1	#!/usr/bin/env python
    2	
    3	# example textview-basic.py
    4	
    5	import pygtk
    6	pygtk.require('2.0')
    7	import gtk
    8	
    9	class TextViewExample:
   10	    def toggle_editable(self, checkbutton, textview):
   11	        textview.set_editable(checkbutton.get_active())
   12	
   13	    def toggle_cursor_visible(self, checkbutton, textview):
   14	        textview.set_cursor_visible(checkbutton.get_active())
   15	
   16	    def toggle_left_margin(self, checkbutton, textview):
   17	        if checkbutton.get_active():
   18	            textview.set_left_margin(50)
   19	        else:
   20	            textview.set_left_margin(0)
   21	
   22	    def toggle_right_margin(self, checkbutton, textview):
   23	        if checkbutton.get_active():
   24	            textview.set_right_margin(50)
   25	        else:
   26	            textview.set_right_margin(0)
   27	
   28	    def new_wrap_mode(self, radiobutton, textview, val):
   29	        if radiobutton.get_active():
   30	            textview.set_wrap_mode(val)
   31	
   32	    def new_justification(self, radiobutton, textview, val):
   33	        if radiobutton.get_active():
   34	            textview.set_justification(val)
   35	
   36	    def close_application(self, widget):
   37	        gtk.main_quit()
   38	
   39	    def __init__(self):
   40	        window = gtk.Window(gtk.WINDOW_TOPLEVEL)
   41	        window.set_resizable(gtk.TRUE)  
   42	        window.connect("destroy", self.close_application)
   43	        window.set_title("TextView Widget Basic Example")
   44	        window.set_border_width(0)
   45	
   46	        box1 = gtk.VBox(gtk.FALSE, 0)
   47	        window.add(box1)
   48	        box1.show()
   49	
   50	        box2 = gtk.VBox(gtk.FALSE, 10)
   51	        box2.set_border_width(10)
   52	        box1.pack_start(box2, gtk.TRUE, gtk.TRUE, 0)
   53	        box2.show()
   54	
   55	        sw = gtk.ScrolledWindow()
   56	        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
   57	        textview = gtk.TextView()
   58	        textbuffer = textview.get_buffer()
   59	        sw.add(textview)
   60	        sw.show()
   61	        textview.show()
   62	
   63	        box2.pack_start(sw)
   64	        # Load the file textview-basic.py into the text window
   65	        infile = open("textview-basic.py", "r")
   66	
   67	        if infile:
   68	            string = infile.read()
   69	            infile.close()
   70	            textbuffer.set_text(string)
   71	
   72	        hbox = gtk.HButtonBox()
   73	        box2.pack_start(hbox, gtk.FALSE, gtk.FALSE, 0)
   74	        hbox.show()
   75	
   76	        vbox = gtk.VBox()
   77	        vbox.show()
   78	        hbox.pack_start(vbox, gtk.FALSE, gtk.FALSE, 0)
   79	        # check button to toggle editable mode
   80	        check = gtk.CheckButton("Editable")
   81	        vbox.pack_start(check, gtk.FALSE, gtk.FALSE, 0)
   82	        check.connect("toggled", self.toggle_editable, textview)
   83	        check.set_active(gtk.TRUE)
   84	        check.show()
   85	        # check button to toggle cursor visiblity
   86	        check = gtk.CheckButton("Cursor Visible")
   87	        vbox.pack_start(check, gtk.FALSE, gtk.FALSE, 0)
   88	        check.connect("toggled", self.toggle_cursor_visible, textview)
   89	        check.set_active(gtk.TRUE)
   90	        check.show()
   91	        # check button to toggle left margin
   92	        check = gtk.CheckButton("Left Margin")
   93	        vbox.pack_start(check, gtk.FALSE, gtk.FALSE, 0)
   94	        check.connect("toggled", self.toggle_left_margin, textview)
   95	        check.set_active(gtk.FALSE)
   96	        check.show()
   97	        # check button to toggle right margin
   98	        check = gtk.CheckButton("Right Margin")
   99	        vbox.pack_start(check, gtk.FALSE, gtk.FALSE, 0)
  100	        check.connect("toggled", self.toggle_right_margin, textview)
  101	        check.set_active(gtk.FALSE)
  102	        check.show()
  103	        # radio buttons to specify wrap mode
  104	        vbox = gtk.VBox()
  105	        vbox.show()
  106	        hbox.pack_start(vbox, gtk.FALSE, gtk.FALSE, 0)
  107	        radio = gtk.RadioButton(None, "WRAP__NONE")
  108	        vbox.pack_start(radio, gtk.FALSE, gtk.TRUE, 0)
  109	        radio.connect("toggled", self.new_wrap_mode, textview, gtk.WRAP_NONE)
  110	        radio.set_active(gtk.TRUE)
  111	        radio.show()
  112	        radio = gtk.RadioButton(radio, "WRAP__CHAR")
  113	        vbox.pack_start(radio, gtk.FALSE, gtk.TRUE, 0)
  114	        radio.connect("toggled", self.new_wrap_mode, textview, gtk.WRAP_CHAR)
  115	        radio.show()
  116	        radio = gtk.RadioButton(radio, "WRAP__WORD")
  117	        vbox.pack_start(radio, gtk.FALSE, gtk.TRUE, 0)
  118	        radio.connect("toggled", self.new_wrap_mode, textview, gtk.WRAP_WORD)
  119	        radio.show()
  120	
  121	        # radio buttons to specify justification
  122	        vbox = gtk.VBox()
  123	        vbox.show()
  124	        hbox.pack_start(vbox, gtk.FALSE, gtk.FALSE, 0)
  125	        radio = gtk.RadioButton(None, "JUSTIFY__LEFT")
  126	        vbox.pack_start(radio, gtk.FALSE, gtk.TRUE, 0)
  127	        radio.connect("toggled", self.new_justification, textview,
  128	                      gtk.JUSTIFY_LEFT)
  129	        radio.set_active(gtk.TRUE)
  130	        radio.show()
  131	        radio = gtk.RadioButton(radio, "JUSTIFY__RIGHT")
  132	        vbox.pack_start(radio, gtk.FALSE, gtk.TRUE, 0)
  133	        radio.connect("toggled", self.new_justification, textview,
  134	                      gtk.JUSTIFY_RIGHT)
  135	        radio.show()
  136	        radio = gtk.RadioButton(radio, "JUSTIFY__CENTER")
  137	        vbox.pack_start(radio, gtk.FALSE, gtk.TRUE, 0)
  138	        radio.connect("toggled", self.new_justification, textview,
  139	                      gtk.JUSTIFY_CENTER)
  140	        radio.show()
  141	
  142	        separator = gtk.HSeparator()
  143	        box1.pack_start(separator, gtk.FALSE, gtk.TRUE, 0)
  144	        separator.show()
  145	
  146	        box2 = gtk.VBox(gtk.FALSE, 10)
  147	        box2.set_border_width(10)
  148	        box1.pack_start(box2, gtk.FALSE, gtk.TRUE, 0)
  149	        box2.show()
  150	
  151	        button = gtk.Button("close")
  152	        button.connect("clicked", self.close_application)
  153	        box2.pack_start(button, gtk.TRUE, gtk.TRUE, 0)
  154	        button.set_flags(gtk.CAN_DEFAULT)
  155	        button.grab_default()
  156	        button.show()
  157	        window.show()
  158	
  159	def main():
  160	    gtk.main()
  161	    return 0       
  162	
  163	if __name__ == "__main__":
  164	    TextViewExample()
  165	    main()

Las líneas 10-34 definen las retrollamadas para los botones de exclusión mútua y los botones de activación que se usan para cambiar los atributos predeterminados de la TextView. Las líneas 55-63 crean una ScrolledWindow que contenga la TextView. La ScrolledWindow se empaqueta en una VBox con los botones que se crean en las líneas 72-140. El TextBuffer asociado con la TextView se rellena con el contenido del archivo fuente en las líneas 64-70.