Le widget gtk.Ruler sert à indiquer la position du pointeur de la souris dans une fenêtre donnée. Une fenêtre peut être dotée d'une règle horizontale s'étendant sur sa largeur et d'une verticale dans sa hauteur. La position exacte du pointeur mesurée par la règle est matérialisé sur celle-ci par un petit indicateur triangulaire.
Le widget doit tout d'abord être créé. On utilisera à cet effet les fonctions suivantes :
regle_h = gtk.HRuler() # crée une règle horizontale regle_v = gtk.VRuler() # crée une règle verticale
Une fois qu'une règle est créée, on peut définir l'unité de mesure : PIXELS (pixels), INCHES (pouces) ou CENTIMETERS (centimètres). La méthode à utiliser est la suivante :
regle.set_metric(metric)
L'unité de mesure par défaut est PIXELS.
>regle.set_metric(gtk.PIXELS)
Les gtk.Ruler possèdent d'autres caractéristiques configurables, telles que la graduation de l'intervalle choisi et la position initiale de l'indicateur. Ces deux options se définissent avec la méthode suivante :
regle.set_range(lower, upper, position, max_size)
Les arguments lower (minimum) et upper (maximum) spécifient l'étendue de la règle, et max_size (taille maximum) représente le plus grand nombre qui puisse être affiché. Quant à position, il précise la position initiale de l'indicateur triangulaire dans la règle.
On peut donc faire s'étendre une règle verticale sur une fenêtre de 800 pixel de haut ainsi :
regle_v.set_range(0, 800, 0, 800)
Les graduations de la règle iront de 0 à 800, avec un nombre tous les 100 pixels. Si l'on voulait que la règle aille de 7 à 16, on coderait plutôt :
regle_v.set_range(7, 16, 0, 20)
L'indicateur, petite marque triangulaire présente sur la règle, indique la position du pointeur mesurée par cette dernière. Si l'on utilise une règle dans le but de suivre le pointeur de la souris, le signal "motion_notify_event" (évènement "notification de mouvement") devrait être connecté à la méthode "motion_notify_event" de la règle. Il nous faut définir une fonction de rappel du "motion_notify_event" pour la zone de dessin et utiliser connect_object() pour faire émettre à la règle un signal de notification de mouvement :
def notif_mouvement(regle, evnmt):
return regle.emit("motion_notify_event", evnmt)
zonedess.connect_object("motion_notify_event", notif_mouvement, regle)
Le programme d'exemple regles.py crée une zone de dessin encadrée par une règle horizontale en haut et une verticale à gauche. La zone de dessin fait 600 pixels de large pour 800 pixels de haut. La règle horizontale est graduée de 7 à 13 avec une marque tous les 100 pixels, tandis que la règle verticale est graduée de 0 à 400 avec une marque tous les 100 pixels. Le placement de la zone de dessin ainsi que des règles est effectué au moyen d'un tableau. La Figure 9.8 montre le résultat :
Le code source de regles.py est le suivant :
1 #!/usr/bin/env python
2
3 # exemple regles.py
4
5 import pygtk
6 pygtk.require('2.0')
7 import gtk
8
9 class ExempleRegles:
10 TAILLE_X = 400
11 TAILLE_Y = 400
12
13 # Cette routine prend le controle lorsque on clique sur le bouton fermer
14 def fermer_application(self, widget, evnmt, data=None):
15 gtk.main_quit()
16 return False
17
18 def __init__(self):
19 fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
20 fenetre.connect("delete_event", self.fermer_application)
21 fenetre.set_border_width(10)
22
23 # Creation d'un tableau pour le placement des regles et de la zone de dessin
24 tableau = gtk.Table(3, 2, False)
25 fenetre.add(tableau)
26
27 zonedess = gtk.DrawingArea()
28 zonedess.set_size_request(self.TAILLE_X, self.TAILLE_Y)
29 tableau.attach(zonedess, 1, 2, 1, 2,
30 gtk.EXPAND|gtk.FILL, gtk.FILL, 0, 0)
31 zonedess.set_events(gtk.gdk.POINTER_MOTION_MASK |
32 gtk.gdk.POINTER_MOTION_HINT_MASK )
33
34 # La regle horizontale va en haut. Quand la souris passe dans la zone de dessin,
35 # un "motion_notify-event" est transmis au gestionnaire d'evenement approprie,
36 # qui le passe a son tour a la regle.
37 regle_h = gtk.HRuler()
38 regle_h.set_metric(gtk.PIXELS)
39 regle_h.set_range(7, 13, 0, 20)
40 def notif_mouvmt(regle, evnmt):
41 return regle.emit("motion_notify_event", evnmt)
42 zonedess.connect_object("motion_notify_event", notif_mouvmt, regle_h)
43 tableau.attach(regle_h, 1, 2, 0, 1,
44 gtk.EXPAND|gtk.SHRINK|gtk.FILL, gtk.FILL, 0, 0 )
45
46 # La regle verticale va a gauche. Quand la souris passe dans la zone de dessin,
47 # un "motion_notify-event" est transmis au gestionnaire d'evenement approprie,
48 # qui le passe a son tour a la regle.
49 regle_v = gtk.VRuler()
50 regle_v.set_metric(gtk.PIXELS)
51 regle_v.set_range(0, self.TAILLE_Y, 10, self.TAILLE_Y)
52 zonedess.connect_object("motion_notify_event", notif_mouvmt, regle_v)
53 tableau.attach(regle_v, 0, 1, 1, 2,
54 gtk.FILL, gtk.EXPAND|gtk.SHRINK|gtk.FILL, 0, 0 )
55
56 # On affiche tout
57 zonedess.show()
58 regle_h.show()
59 regle_v.show()
60 tableau.show()
61 fenetre.show()
62
63 def main():
64 gtk.main()
65 return 0
66
67 if __name__ == "__main__":
68 ExempleRegles()
69 main()
Les lignes 42 et 52 connectent la fonction de rappel notif_mouvmt() à la zone de dessin, la première ligne passant regle_h et la seconde regle_v comme données utilisateur. La fonction de rappel notif_mouvmt() sera invoquée deux fois à chaque mouvement de la souris : une fois avec regle_h et une autre avec regle_v.