zone_dessin = gtk.DrawingArea()

  zone_dessin.set_size_request(largeur, hauteur)

  dessinable = drawing_area.window

Il existe un grand nombre de méthodes pour dessiner sur la gtk.gdk.Window d'une zone de dessin . Toutes ces méthodes exigent un contexte graphique (gtk.gdk.GC) pour encapsuler l'information nécessaire au dessin sous forme d'attributs. Un gtk.gdk.GC dispose des attributs suivants :

background            # fond
cap_style             # style de fin de ligne
clip_mask             # masque de découpe
clip_x_origin         # origine x de la découpe
clip_y_origin         # origine y de la découpe
fill                  # remplissage
font                  # police
foreground            # couleur de premier plan
function              # fonction
graphics_exposures    # exposition graphique
join_style            # style de jointure de lignes
line_style            # style de ligne
line_width            # largeur de ligne
stipple               # style de pointillé
sub_window            # sous-fenêtre
tile                  # mosaïque
ts_x_origin           # origine x
ts_y_origin           # origine y

background définit la gtk.gdk.Color utilisée comme couleur de fond.

foreground définit la gtk.gdk.Color utilisée comme couleur de premier-plan.

Une gtk.gdk.Color est une couleur qui peut être allouée ou non allouée. Une couleur non allouée peut être créée avec le constructeur :

  couleur = gtk.gdk.Color(red=0, green=0, blue=0, pixel=0)

... où les paramètres red, green et blue sont des entiers compris entre 0 et 65535. Le paramètre pixel n'est pas souvent défini car il est réécrit lorsque la couleur est allouée.

Une gtk.gdk.Color non allouée peut aussi être créée par la fonction :

  couleur = gtk.gdk.color_parse(spec)

... où spec est une chaîne de spécification de couleur qui peut être :

Pour créer une gtk.gdk.Color représentant une couleur allouée, on utilise la méthode alloc_color() de gtk.gdk.Colormap qui possède trois variantes :

  couleur = colormap.alloc_color(color, writeable=FALSE, best_match=TRUE)

  couleur = colormap.alloc_color(spec, writeable=FALSE, best_match=TRUE)

  couleur = colormap.alloc_color(red, green, blue, writeable=FALSE, best_match=TRUE)

Le paramètre couleur est un gtk.gdk.Color non alloué, spec est une chaîne de spécification de couleur comme on l'a vu précèdemment dans la fonction gtk.gdk.color_parse(). Les paramètres red, green et blue sont des valeurs entières de couleur décrites dans la fonction constructeur gtk.gdk.Color(). On peut aussi indiquer si la couleur allouée peut être modifiable (cad, peut être modifiée plus tard mais ne peut pas être partagée) ou si une meilleure approximation avec des couleurs existantes peut se faire lorsque la couleur exacte n'est pas disponible.

Par exemple:

  navajowhite = colormap.alloc('navajo white')

  cyan = colormap.alloc(0, 65535, 65535)

  red = colormap.alloc_color('#FF0000', True, True)

On peut connaître la palette de couleurs associée à un widget par la méthode :

  palette = widget.get_colormap()

cap_style précise le style de fin de ligne utilisé pour une ligne qui se termine sans rejoindre une autre. Les différents styles disponibles sont :

clip_mask définit un gtk.gdk.Pixmap utilisé pour découper le dessin de la zone de dessin drawing_area.

clip_x_origin et clip_y_origin précise pour le découpage, l'origine en x et y par rapport au coin supérieur gauche de la zone de dessin

fill précise le style de remplissage utilisé dans le dessin. Les styles disponibles sont :

font est un gtk.gdk.Font qui est la police utilisée par défaut pour le texte du dessin.

function précise comment les valeurs de bit pour les pixels source sont combinées avec les valeurs de bit pour les pixels de destination pour produire les bits de pixels résultat. Les seize valeurs suivantes correspondent aux 16 différentes possibilités d'une table de vérité 2x2 mais deux ou trois de ces valeurs seulement sont réellement utiles. Pour les images en couleur, seul COPY, XOR et INVERT sont généralement utiles alors que pour les bitmaps AND et OR sont aussi utilisés. Voici les valeurs possibles de function :

  COPY           # copie
  INVERT         # inverser
  XOR            # OU exclusif
  CLEAR          # nettoyer
  AND            # ET
  AND_REVERSE    
  AND_INVERT     # ET inversé
  NOOP           # nul
  OR             # OU
  EQUIV          # équivalent
  OR_REVERSE     
  COPY_INVERT    # copie inversée
  OR_INVERT      # OU inversé
  NAND           # non ET
  SET            # afficher ?

graphics_exposures indique si l'affichage graphique est autorisé (TRUE) ou interdit (FALSE). Lorsque graphics_exposures vaut TRUE, l'échec de copie d'un pixel dans une action de dessin génère un évènement expose. Si la copie réussit, un évènement noexpose est généré.

join_style indique le style de croisement entre deux lignes. Les styles diponibles sont :

line_style indique le style de traçage d'une ligne. Les possibilités sont :

line_width indique l'épaisseur de la ligne.

stipple indique le gtk.gdk.Pixmap utilisé pour un dessin en pointillé quand le paramètre fill vaut STIPPLED ou OPAQUE_STIPPLED.

sub_window indique le mode de dessin dans une gtk.gdk.Window qui possède des enfants gtk.gdk.Window. Les valeurs possibles pour sub_window sont :

tile indique le gtk.gdk.Pixmap utilisé pour dessiner en mosaïque lorsque le paramètre fill vaut TILED.

ts_x_origin et ts_y_origin indiquent l'origine de la mosaïque ou du pointillé (la position de départ du bitmap).

Un nouveau contexte graphique est créé par un appel à la méthode gtk.gdk.Drawable.new_gc() :

contexte_graph = drawable.new_gc(foreground=None, background=None, font=None, 
                     function=-1, fill=-1, tile=None,
                     stipple=None, clip_mask=None, subwindow_mode=-1,
                     ts_x_origin=-1, ts_y_origin=-1, clip_x_origin=-1,
                     clip_y_origin=-1, graphics_exposures=-1,
                     line_width=-1, line_style=-1, cap_style=-1
                     join_style=-1)

Pour pouvoir créer un nouveau contexte graphique avec cette méthode, le drawable doit être :

Les différents attributs du contexte graphique possédent des valeurs par défaut lorsqu'elles ne sont pas précisées dans la méthode new_gc(). Lorsque l'on souhaite définir des attributs du contexte graphique par la méthode new_gc(), il est plus facile d'utiliser les arguments par mots-clés de Python.

On peut aussi définir les attributs individuels d'un gtk.gdk.GC en assignant une valeur aux attributs de l'objet GC. Par exemple

  gc.cap_style = CAP_BUTT
  gc.line_width = 10
  gc.fill = SOLD
  gc.foreground = macouleur

ou en utilisant les méthodes suivantes :

  gc.set_foreground(color)
  gc.set_background(color)
  gc.set_function(function)
  gc.set_fill(fill)
  gc.set_tile(tile)
  gc.set_stipple(stipple)
  gc.set_ts_origin(x, y)
  gc.set_clip_origin(x, y)
  gc.set_clip_mask(mask)
  gc.set_clip_rectangle(rectangle)
  gc.set_subwindow(mode)
  gc.set_exposures(exposures)
  gc.set_line_attributes(line_width, line_style, cap_style, join_style)

Le patron de segments utilisé lorsque le paramètre de style de ligne line_style est LINE_ON_OFF_DASH ou LINE_DOUBLE_DASH peut être défini par la méthode suivante :

  gc.set_dashes(offset, dash_list)

... où le paramètre offset est la position de la valeur du segment initial dans la dash_list et dash_list est une liste de tuples contenant le nombre de pixels à dessiner ou sauter pour réaliser les segments. Les segments sont dessinés en démarrant avec le nombre de pixels indiqué à la position de décalage (offset) ; ensuite le nombre suivant est le nombre de pixels sautés ; le nombre suivant est le nombre de pixels dessinés, et ainsi de suite, parcourant tous les nombres de la dash_list en recommençant au début quand on arrive à la fin de la liste. Par exemple, si la dash_list se compose de (2, 4, 8, 16) avec un décalage (offset) de 1, les segments sont dessinés ainsi : dessin sur 4 pixels, saut de 8 pixels, dessin sur 16 pixels, saut de 2 pixels, dessin sur 4 pixels etc.

On peut réaliser une copie d'un gtk.gdk.GC existant par la méthode :

  gc.copy(src_gc)

Les attributs du paramètre gc sont identiques à ceux du source src_gc.