Apprendre à utiliser le module Python PyGTK 2.0

Un grand nombre des widgets qui utilisent des ajustements le font de manière automatique. Cependant, certains cas peuvent se présenter où il vous faudra en créer un vous-même. Vous utiliserez alors la méthode suivante :

  ajustement = gtk.Adjustment(value=0, lower=0, upper=0, step_incr=0, page_incr=0, page_size=0)

L'argument value (valeur) est la valeur initiale que vous voulez donner à votre ajustement, elle correspondra généralement à la position la plus haute ou la plus à gauche d'un widget ajustable. L'argument lower (minimale) spécifie la valeur la plus basse que peut prendre ajustement. L'argument step_incr (incrémentation par pas) spécifie le plus petit des deux incréments par lequel l'utilisateur peut modifier la valeur, et page_incr (incrémentation par page) le plus grand. L'argument page_size (taille de la page) correspond en quelque sorte à la partie visible d'un widget à défilement. Enfin, upper (maximale) représente la coordonnée la plus basse ou la plus à droite de l'enfant d'un widget à défilement. Il ne s'agit donc pas forcément de la valeur la plus grande que peut prendre value ,car dans ces widgets, l'argument page_size est généralement différent de zéro.

On pourrait diviser grossièrement les widgets ajustables en deux catégories : ceux qui utilisent et nécessitent des unités spécifiques pour les valeurs dont on vient de parler, et ceux qui les traitent comme des nombres arbitraires. Ce dernier groupe inclut les widgets d'intervalle (barre de défilement et gradateur), la barre de progression et les boutons fléchés. Il s'agit de l'ensemble des widgets qui, de par leur nature même, sont ajustés directement par l'utilisateur au moyen de la souris ou du clavier. Ils traitent toujours les valeurs données aux arguments lower et upper d'un ajustement comme un intervalle à l'intérieur duquel l'utilisateur peut manipuler la valeur (l'argument value) de l'ajustement. Par défaut, ils ne modifient que cette dernière.

L'autre groupe inclut la zone de texte, la vue orientable, la liste composée et la fenêtre à défilement. Tous ces widgets utilisent des valeurs en pixels pour leurs ajustements. Il s'agit, de plus, de l'ensemble des widgets qui sont ajustés indirectement, par l'intermédiaire de barres de défilement. Même si tous les widgets qui utilisent des ajustements peuvent soit créer les leurs, soit utiliser ceux qu'on leur fournit, il vaut mieux, en règle générale, laisser cette catégorie-là créer les siens. La plupart du temps, ils finissent par ne tenir compte d'aucune valeur provenant des ajustements qu'on leur a affectés, excepté la valeur elle-même (value) ; les résultats sont, en général, indéfinis (il vous faudra chercher dans les codes sources, et ils peuvent être différents d'un widget à l'autre).

Vous devez être en train de vous dire que puisque les zones de texte et les vues orientables insistent pour tout définir excepté la valeur de leurs ajustements, et puisque les barres de défilement ne touchent qu'à la valeur de l'ajustement, alors si l'on partage un ajustement entre une barre de défilement et une zone de texte, manipuler la barre de défilement devrait ajuster comme par magie la zone de texte. Parfaitement ! Ça se passe comme ça :

  # Elle crée ses propres ajustements
  vue_orientable = gtk.Viewport()
  # l'ajustement qui vient d'être créé servira aussi pour la barre de défilement
  barredef_v = gtk.VScrollbar(vue_orientable.get_vadjustment())

Vous devez penser : « C'est bien beau tout ça, mais qu'est-ce qui se passe si je veux créer mes propres gestionnaires pour réagir quand l'utilisateur règle un widget d'intervalle ou un bouton fléché ? Et comment je récupère la valeur d'un ajustement dans ces gestionnaires ? » Afin de répondre à ces questions et à bien d'autres, commençons par jeter un œil aux attributs de l'objet gtk.Adjustment :

  lower
  upper
  value
  step_increment
  page_increment
  page_size

Pour une instance donnée ajust de gtk.Adjustment, on définit ou récupère chacun de ses attributs avec ajust.lower, ajust.value, etc.

En règle générale, lorsque l'on définit la valeur d'un ajustement, on veut que le changement soit reflété par chaque widget qui l'utilise. À cet effet, PyGTK fournit la méthode suivante :

  ajustement.set_value(value)

La classe gtk.Adjustment, nous l'avons vu plus haut, est une sous-classe de gtk.Object au même titre que n'importe quel widget, et peut donc émettre des signaux. Voilà pourquoi les modifications sont reflétées automatiquement lorsque vous partagez un ajustement entre une barre de défilement et un autre widget ajustable ; tous les widgets ajustables connectent des gestionnaires au signal "value_changed" de leur ajustement, ce que peut aussi faire votre programme. Voici comment définir la fonction de rappel de ce signal :

  def value_changed(ajustement):

Les différents widgets qui utilisent un ajustement lui font émettre ce signal à chaque fois qu'ils modifient sa valeur. Cela arrive lorsqu'une action de l'utilisateur fait se déplacer le curseur dans un widget d'intervalle, mais aussi lorsque le programme change explicitement la valeur grâce à la méthode set_value(). Imaginons, par exemple, que vous ayez un gradateur et que vous vouliez changer la rotation d'une image à chaque fois que sa valeur est modifiée. Vous écririez alors une fonction de rappel semblable à celle-ci :

  def rpl_rotation_img(ajust, image):
      rotation_image (image, ajust.value)
  ...

Puis il vous faudrait la connecter à l'ajustement du gradateur ainsi :

  ajust.connect("value_changed", rpl_rotation_img, image)

Et si un widget reconfigure les champs upper ou lower de son ajustement ? Ça arrive, par exemple quand un utilisateur ajoute du texte à une zone de texte. L'ajustement émet alors le signal "changed", qui ressemble à ça :

  def changed(ajustement):

Les widgets d'intervalle connectent tous automatiquement un gestionnaire à ce signal, qui reflète le changement en modifiant leur apparence. La taille du curseur d'une barre de défilement est, par exemple, inversement proportionnelle à la différence entre les valeurs des arguments lower et upper de son ajustement.

Il est peu probable que vous ayez un jour besoin d'attacher un gestionnaire à ce signal, à moins que vous n'écriviez un nouveau type de widget d'intervalle. Dans tous les cas, si vous modifiez directement une des valeurs d'un ajustement, vous devriez lui faire émettre ce signal afin de reconfigurer tous les widgets qui l'utilisent. Utilisez pour cela cette méthode :

  ajustement.emit("changed")

Maintenant, en avant, et ajustez !