Los controles Ruler (Regla) se usan para indicar la posición del puntero del ratón en una ventana determinada. Una ventana puede tener una regla vertical a lo largo del ancho y una regla horizontal a lo largo del alto. Un pequeño triángulo indicador en la regla muestra la posición exacta del puntero respecto a la regla.

Antes de nada es necesario crear una regla. Las reglas horizontales y verticales se crean usando las siguientes funciones:

  hruler = gtk.HRuler()    # regla horizontal

  vruler = gtk.VRuler()    # regla vertical

Una vez que se crea una regla podemos definir la unidad de medida. Las unidades de medida para las reglas pueden ser PIXELS (píxeles), INCHES (pulgadas) o CENTIMETERS (centímetros). Esto se fija con el método:

  ruler.set_metric(metric)

La medida predeterminada es PIXELS.

  ruler.set_metric(gtk.PIXELS)

Otra característica importante de una regla es cómo marca las unidades de escala y donde se coloca el indicador de posición inicialmente. Esto se fija usando el método:

  ruler.set_range(lower, upper, position, max_size)

Los argumentos lower (bajo) y upper (alto) definen la extensión de la regla, y max_size (tamaño máximo) es el mayor número posible que se visualizará. La Position (Posición) define la posición inicial del indicador del puntero dentro de la regla.

Una regla vertical puede medir una ventana de 800 píxeles de ancho así:

  vruler.set_range(0, 800, 0, 800)

Las marcas mostradas en la regla irán desde 0 a 800, con un número cada 100 píxeles. Si en lugar de eso quisieramos una regla de 7 a 16, escribiríamos:

  vruler.set_range(7, 16, 0, 20)

El indicador de la regla es una pequeña marca triangular que indica la posición del puntero relativa a la regla. Si la regla se usa para seguir el puntero del ratón, la señal "motion_notify_event" debe conectarse al método "motion_notify_event" de la regla. Hay que configurar una retrollamada para "motion_notify_event" para el área y usar connect_object() para que la regla emita una señal "motion_notify_signal":

  def motion_notify(ruler, event):
      return ruler.emit("motion_notify_event", event)

  area.connect_object("motion_notify_event", motion_notify, ruler)

El programa de ejemplo rulers.py crea un área de dibujo con una regla horizontal en la parte de arriba y una regla vertical a su izquierda. El tamaño del área de dibujo es de 600 píxeles de ancho por 400 píxeles de alto. La regla horizontal va desde 7 hasta 13 con una marca cada 100 píxeles, mientras que la regla vertical va de 0 a 400 con una marca cada 100 píxeles. La colocación del área de dibujo y las reglas se hace con una tabla. La figura Figura 9.8, “Ejemplo de Reglas” ilustra el resultado:

Figura 9.8. Ejemplo de Reglas

El código fuente es rulers.py:

    1	#!/usr/bin/env python
    2	
    3	# ejemplo rulers.py
    4	
    5	import pygtk
    6	pygtk.require('2.0')
    7	import gtk
    8	
    9	class RulersExample:
   10	    XSIZE = 400
   11	    YSIZE = 400
   12	
   13	    # Esta rutina toma el control cuando se pulsa el botón de cerrar
   14	    def close_application(self, widget, event, data=None):
   15	        gtk.main_quit()
   16	        return gtk.FALSE
   17	
   18	    def __init__(self):
   19	        window = gtk.Window(gtk.WINDOW_TOPLEVEL)
   20	        window.connect("delete_event", self.close_application)
   21	        window.set_border_width(10)
   22	
   23	        # Crea una tabla para colocar la regla y el área de dibujo
   24	        table = gtk.Table(3, 2, gtk.FALSE)
   25	        window.add(table)
   26	
   27	        area = gtk.DrawingArea()
   28	        area.set_size_request(self.XSIZE, self.YSIZE)
   29	        table.attach(area, 1, 2, 1, 2,
   30	                     gtk.EXPAND|gtk.FILL, gtk.FILL, 0, 0 )
   31	        area.set_events(gtk.gdk.POINTER_MOTION_MASK |
   32	                        gtk.gdk.POINTER_MOTION_HINT_MASK )
   33	
   34	        # La regla horizontal está arriba. Cuando el ratón se mueve por el
   35	        # área de dibujo se pasa un evento motion_notify_event al manejador
   36	        # adecuado para la regla
   37	        hrule = gtk.HRuler()
   38	        hrule.set_metric(gtk.PIXELS)
   39	        hrule.set_range(7, 13, 0, 20)
   40	        def motion_notify(ruler, event):
   41	            return ruler.emit("motion_notify_event", event)
   42	        area.connect_object("motion_notify_event", motion_notify, hrule)
   43	        table.attach(hrule, 1, 2, 0, 1,
   44	                     gtk.EXPAND|gtk.SHRINK|gtk.FILL, gtk.FILL, 0, 0 )
   45	    
   46	        # La regla vertical está a la izquierda. Cuando el ratón se mueve por el
   47	        # área de dibujo se pasa un evento motion_notify_event al manejador
   48	        # adecuado para la regla
   49	        vrule = gtk.VRuler()
   50	        vrule.set_metric(gtk.PIXELS)
   51	        vrule.set_range(0, self.YSIZE, 10, self.YSIZE)
   52	        area.connect_object("motion_notify_event", motion_notify, vrule)
   53	        table.attach(vrule, 0, 1, 1, 2,
   54	                     gtk.FILL, gtk.EXPAND|gtk.SHRINK|gtk.FILL, 0, 0 )
   55	
   56	        # Ahora mostramos todo
   57	        area.show()
   58	        hrule.show()
   59	        vrule.show()
   60	        table.show()
   61	        window.show()
   62	
   63	def main():
   64	    gtk.main()
   65	    return 0
   66	
   67	if __name__ == "__main__":
   68	    RulersExample()
   69	    main()

Las lineas 42 y 52 conectan la retrollamada motion_notify() al área pasandole hrule en la linea 42 y vrule en la línea 52 como datos de usuario. La retrollamada motion_notify() se llamará dos veces cada vez que el ratón se mueva - una vez con hrule y otra vez con vrule.