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