Retrouvez cet article dans : Linux Magazine HS 19

Si vous pensez que la grande variété d'outils proposés par Gimp ne suffit pas, il est possible de créer vos propres scripts exploitant toute la puissance du logiciel, et d'étendre ainsi ses capacités. Cela peut être fait en différents langages, du C à Scheme en passant par Perl. Nous allons nous intéresser ici au langage Python.À première vue, Gimp-Python (le nom de code des modules Python permettant de créer des plugins pour Gimp) ressemble fortement au traditionnel Script-Fu. Mais il y a quelques différences notables :

• un plugin Python est un véritable programme, exécuté par l'interpréteur Python du système, et non par un autre plugin de Gimp : toutes les extensions du langage sont donc disponibles ;
• là où Script-Fu utilise un identifiant pour manipuler les images, calques et autres objets, Gimp-Python stocke ceux-ci en tant qu'objets, exploitant les aspects orienté objet de Python ;
• enfin, l'ensemble de la bibliothèque libgimp est accessible depuis le script Python, donnant ainsi accès à des fonctions de bas niveau inconnues pour Script-Fu.

Le premier point est particulièrement intéressant : à la limite, il est possible d'ouvrir une fenêtre Tkinter durant l'exécution du script ! (J'ai essayé, ça fonctionne). Les possibilités sont donc beaucoup plus étendues. Nous allons découvrir tout cela sur un exemple, dont la fonction triviale est de créer un texte contenu dans un cadre. L'utilisateur aura la possibilité de choisir la police de caractère, la taille du texte, etc. La fenêtre de notre scripte ressemblera à ceci : Mais avant, il convient de nous préparer.

Mise en place et outils

Pour commencer, il faut installer le module de Gimp qui permet l'exécution du code Python. Selon votre distribution, le nom du paquetage correspondant devrait ressembler à quelque chose comme gimp-python (Debian) ou gimp2_0-python (Mandrake).

Vous pouvez aussi le télécharger à partir du site [1], et l'installer manuellement en suivant la documentation. Cela fait, nous allons commencer par créer un script de test, juste pour vérifier que cela fonctionne. Créez un fichier test.py avec le contenu suivant :

01: #!/usr/bin/python
02: from gimpfu import *
03: def test() :
04:   pass
05: register(
06:   "nom_de_la_fonction",
07:   "description",
08:   "texte d'aide",
09:   "auteur",
10:   "copyright",
11:   "date",
12:   "<Toolbox>/Xtns/Python-Fu/LinuxMag/test",
13:   "RGB*",
14:   [], # liste de parametres
15:   [], # resultats
16:   test) # fonction appellee
17: main()

Inutile de préciser que ce programme ne fait à peu près rien. Normalement, dans votre répertoire personnel vous avez un répertoire caché dédié à Gimp : .gimp-2.0. Placez le fichier précédemment créé dans le sous-répertoire plug-ins, et donnez-lui l'attribut exécutable :

yves@kafka plug-ins $ pwd
/home/yves/.gimp-2.0/plug-ins
yves@kafka plug-ins $ chmod +x test.py

Maintenant, lancez Gimp. Dans le menu Xtns|Python-Fu, vous devriez voir apparaître un sous-menu LinuxMag, qui contient une entrée test : le nom de cette entrée est celui du fichier, c'est celui que nous venons de créer ! Dans ce répertoire Xtns|Python-Fu devrait également se trouver une entrée PDB Browser : elle donne accès à la liste complète des fonctions disponibles. Sélectionnez-la, normalement vous devriez trouvez notre fonction dans la liste, préfixée par python_fu :

Voyons la structure de notre minuscule programme d'un peu plus près.

Structure générale

Au minimum, un script Gimp-Python se compose :

• de l'import du module gimpfu (ligne 2) ;
• d'une fonction Python tout ce qu'il y a de plus classique, où se déroulent les traitements voulus (lignes 3-4) ;
• d'un appel à la fonction register(), fournie par gimpfu, pour référencer notre fonction dans Gimp (lignes 5 à 16) ;
• d'un appel à la fonction main() (également dans gimpfu), qui sera effectivement appelée au moment où le script sera exécuté (ligne 17).

Les paramètres passés à register() exigent le plus grand soin. Le premier définit le nom sous lequel la commande référencée sera connu de Gimp, et éventuellement des autres commandes. Les cinq suivants apparaissent dans la liste des fonctions, comme le montre la capture d'écran précédente. Ils ne sont pas véritablement critiques, mais permettent de donner des informations parfois bien utiles pour d'autres utilisateurs. Naviguez un peu dans les fonctions de la liste pour voir comment ils sont utilisés. Le paramètre suivant, ligne 12, indique dans quel menu la fonction doit apparaître, et sous quel nom. Le premier élément de la chaîne permet à Gimp de déterminer dans quel contexte la commande est accessible. "<Toolbox>" désigne la boîte à outils initiale, qui apparaît au lancement : la commande peut donc être lancée à n'importe quel moment, généralement elle créera une nouvelle image. "<Image>" indique que la commande s'applique à une image existante, elle apparaîtra donc dans le menu associé à une image en cours d'édition. La suite de la chaîne est la simple succession des menus et sous-menus, le dernier élément étant le nom sous lequel la commande apparaîtra dans le menu. Ensuite (ligne 13), on précise à quels types d'images la commande peut s'appliquer, à choisir parmi RGB (images en mode RGB), GRAY (images en tons de gris) ou INDEXED (les couleurs sont définies par une table). Si on ajoute un A après chacun de ces noms, on désigne un type disposant d'un canal de transparence (alpha channel). L'astérisque est un raccourci pour signaler avec ou sans canal de transparence. Par exemple, la chaîne "RGB*, INDEXED" indique les types RGB avec ou sans canal alpha, ainsi que les images à couleurs indexées sans canal alpha. Une commande avec ce qualificatif ne s'appliquera donc pas à des images en tons de gris, ni à des images indexées avec canal alpha. Les deux paramètres suivants sont la liste des paramètres acceptés par la commande, et ses éventuelles valeurs de retours. Nous y reviendrons par la suite. Cette longue liste se termine par la référence à la fonction Python qui devra être invoquée. Voyons maintenant notre exemple.

Dessin dans une image existante

Nous voulons définir deux nouvelles commandes, l'une s'appliquant à une image existante, l'autre créant une nouvelle image. Les deux situations étant très proches, notre script va commencer par définir une fonction " interne " qui fait l'essentiel du travail. Voici le début du script :

001: #!/usr/bin/python
002:
003: import math
004: from gimpfu import *
005: from gimpenums import *

Le module gimpfu contient la base de ce dont nous allons avoir besoin par la suite : il nous permettra d'accéder à d'autres modules, lesquels contiennent objets et fonctions pour créer et manipuler l'image. Il fournit également les fonctions register() et main(). Le module gimpenums contient tout un ensemble de symboles divers utilisés pour paramétrer le comportement de telle ou telle fonction. Voici notre fonction " interne " :

007: def texte_et_cadre(image,
008:                   texte, font, taille_texte, couleur_texte, antialias,
009:                   epaisseur_cadre, couleur_cadre, marge) :
010:                  
011:   marge_totale = int(2*(epaisseur_cadre+marge))
012:   save_fg = gimp.get_foreground()
013:   save_bg = gimp.get_background()

Les paramètres correspondent aux choix offerts à l'utilisateur, tels que montrés dans la capture d'écran en début d'article. Le premier paramètre est une instance d'un type Image, défini dans le module gimp, lui-même défini dans le module gimpfu. Il s'agit d'un véritable objet, nanti de données membres et de méthodes. Vous l'aurez deviné, ce type représente une image. Les lignes 12 et 13 sauvegardent les couleurs d'avant-plan et d'arrière-plan actuellement définies dans Gimp, en utilisant deux fonctions du module gimp. Ceci afin de pouvoir les restaurer quand nous aurons terminé nos manipulations, au cours desquelles nous allons les modifier. Justement, les lignes qui suivent créent un calque contenant le texte demandé :

015:   gimp.set_foreground(couleur_texte)
016:   layer_texte = gimp.pdb.gimp_text_fontname(image, None,
017:     0, 0, texte, 0, antialias, taille_texte, POINTS, font)

La première ligne définit la couleur d'avant-plan, qui sera celle du texte. Les deux suivantes sont un seul appel à une fonction, qui crée le texte et le calque pour le contenir. Ou plus précisément, il s'agit de l'invocation d'une autre commande de Gimp. L'ensemble des commandes est accessible depuis le script par l'objet gimp.pdb, qui représente la Procedural DataBase (PDB), ou base de données des commandes. Si vous explorez celle-ci en passant par le menu Xtns|Db browser, vous trouverez la commande "gimp-text-fontname" que nous utilisons ici... à un petit détail : les caractères de soulignement sont remplacés par des tirets. La raison de cette différence est simple : les tirets seraient interprétés par Python comme des opérateurs de soustraction. Donc les commandes possèdent (en principe) un nom " spécial Python ", en remplaçant les tirets par des caractères de soulignement. Vous pouvez obtenir les noms utilisables en Python en utilisant Xtns|Python-Fu|PDB Browser, comme nous l'avons vu au début. Les commandes peuvent en réalité être invoquées de deux façons. Ici, la commande se présente comme une méthode de l'objet pdb, ce qui n'est possible que grâce au changement de caractères évoqués. Si une commande ne possède pas de nom " corrigé ", par exemple une-commande, il est malgré tout possible de l'invoquer via une indexation par chaîne de caractères, ainsi :

gimp.pdb["une-commande"](parametres)

Je ne m'étendrai pas sur les paramètres de la commande gimp_text_fontname(), consultez sa documentation dans le navigateur des commandes. Une ou deux remarques tout de même. La documentation précise que le deuxième paramètre doit être le calque sur lequel créer le texte, ou (je cite) " -1 pour un nouveau calque ". Si vous donnez effectivement la valeur numérique -1, le script échouera en signalant un type de paramètre invalide : la valeur correcte à donner, en Python, est None. Ceci se retrouve pour d'autres commandes. Par ailleurs, l'avant-dernier paramètre, utilisé pour préciser dans quelle unité est donnée la taille du texte, est documenté comme devant être GIMP_PIXELS ou GIMP_POINTS. Essayez ces valeurs, vous vous ferez insulter. Les véritables valeurs, extraites du modules gimpenums, sont PIXELS ou POINTS. D'une manière générale, lorsque la documentation suggère un identifiant commençant par GIMP_, ce préfixe ne doit pas être utilisé dans un script Python. Le mieux est encore de regarder le code du module gimpenums (qui est en Python, justement, et usuellement placé dans /usr/lib/gimp/2.0/python) pour vérifier les noms corrects. Mais poursuivons notre programme. Maintenant que nous avons le texte, créons un calque pour le cadre qui doit l'entourer :

019:   largeur_cadre = layer_texte.width  + marge_totale
020:   hauteur_cadre = layer_texte.height + marge_totale
021:   layer_cadre = gimp.Layer(image, "Cadre", largeur_cadre, hauteur_cadre,
022:     RGBA_IMAGE, 100, NORMAL_MODE)
023:   image.add_layer(layer_cadre, 0)

Pour déterminer les dimensions de ce cadre, nous utilisons la valeur retournée par gimp_text_fontname(), qui est un objet calque, une instance de la classe gimp.Layer. Cette classe propose en données membres (entre autres) la largeur (width) et la hauteur (height) du calque. Nous pouvons alors créer le calque du cadre, lignes 21-22. Les paramètres donnés au constructeur de gimp.Layer sont :

• l'image qui doit contenir le calque ;
• le nom de ce calque ; si l'image contient déjà un calque de ce nom, Gimp va automatiquement le modifier en ajoutant un compteur sous la forme "#1", "#2", etc. ;
• les dimensions du calque ;
• le type de calque, l'une des valeurs *_IMAGE (GRAY_IMAGE, INDEX_IMAGE, etc.) définies dans gimpenums ; ici nous demandons un calque de type RGB avec un canal de transparence ;
• l'opacité, un réel entre 0 et 100 ;
• le mode, qui a la même signification que la propriété du même nom dans la fenêtre de gestion des calques (l'une des valeurs *_MODE dans gimpenums).

Le calque créé, il faut l'ajouter à l'image : c'est le rôle de la méthode add_layer() de la classe gimp.Image (ligne 23). Le deuxième paramètre est la position du calque dans la pile, celui le plus en haut ayant l'indice 0. Avant de dessiner dans notre calque, il faut initialiser son contenu :

024:   layer_cadre.fill(TRANSPARENT_FILL)

Ceci a pour effet de remplir le calque avec des points transparents. Sans cette opération, vous risquez de récupérer un contenu aléatoire et probablement disgracieux. Nous pouvons maintenant dessiner notre cadre, ce que nous allons faire en manipulant une sélection :

025:   gimp.set_foreground(couleur_cadre)
026:   gimp.pdb.gimp_image_set_active_layer(image, layer_cadre)
027:   gimp.pdb.gimp_rect_select(image, 0, 0,
028:     largeur_cadre, hauteur_cadre, CHANNEL_OP_REPLACE, FALSE, 0)
029:   gimp.pdb.gimp_rect_select(image,
030:     epaisseur_cadre, epaisseur_cadre,
031:     largeur_cadre-2*epaisseur_cadre, hauteur_cadre-2*epaisseur_cadre,
032:     CHANNEL_OP_SUBTRACT, FALSE, 0)
033:   gimp.pdb.gimp_edit_fill(layer_cadre, FOREGROUND_FILL)

La ligne 26 a pour effet de rendre actif le calque devant contenir le cadre : ainsi les opérations suivantes s'effectueront sur ce calque, sans altérer les autres. Ensuite on sélectionne la partie de l'image qui nous intéresse, par la commande gimp_rect_select(). Elle correspond à l'outil de sélection rectangulaire. Après l'image sur laquelle définir la sélection, la commande attend les coordonnées du coin supérieur gauche du rectangle et ses dimensions. Le paramètre suivant précise le type de sélection : CHANNEL_OP_REPLACE indique que cette sélection remplace celle existante, s'il y en a une. Les deux derniers paramètres concernent l'arrondi des coins, ici inutilisé. Nous avons donc une sélection rectangulaire, qui couvre tout le calque du cadre - et accessoirement, le calque du texte. Les lignes 29 à 32 définissent une autre sélection, qui cette fois se soustrait à la précédente : c'est le paramètre CHANNEL_OP_SUBSTRACT. Après ces deux opérations, la zone sélection a justement la forme d'un cadre autour du texte. Il ne reste plus qu'à la remplir avec la couleur d'avant-plan fixée ligne 25 : c'est ce que fait la commande gimp_edit_fill(), ligne 33. Dès lors, notre cadre est dessiné. Il reste à positionner correctement le texte : en effet, le calque contenant le texte est encore à l'origine de l'image, depuis sa création ligne 16. La classe gimp.Layer offre une méthode translate(), que nous allons utiliser pour centrer le texte dans le cadre :

035:   layer_texte.translate(int(epaisseur_cadre+marge),
036:     int(epaisseur_cadre+marge))

La fin de la fonction se contente de désactiver la sélection encore active, et de rétablir les couleurs d'avant et d'arrière-plan :

038:   gimp.pdb.gimp_selection_none(image)
039:   gimp.set_foreground(save_fg)
040:   gimp.set_background(save_bg)
041:   return (layer_texte, layer_cadre)

Pour mémoire, il ne s'agit ici que d'une fonction " utilitaire " : ce n'est pas la commande qui sera lancée par Gimp, que nous allons découvrir maintenant.

Commande pour une image existante

Première commande que nous allons créer, celle qui ajoute le texte avec son cadre dans une image existante, préalablement ouverte dans Gimp. Voici le code de cette commande :

043: def texte_et_cadre_dans_image(image, drawable,
044:                texte, font, taille_texte, couleur_texte, antialias,
045:                epaisseur_cadre, couleur_cadre, marge) :
046:  
047:   image.undo_group_start()
048:   (layer_texte, layer_cadre) = texte_et_cadre(image,
049:     texte, font, taille_texte, couleur_texte, antialias,
050:     epaisseur_cadre, couleur_cadre, marge)
051:   x = (image.width  - layer_cadre.width)  / 2
052:   y = (image.height - layer_cadre.height) / 2
053:   layer_cadre.translate(x, y)
054:   layer_texte.translate(x, y)
055:   image.undo_group_end()

Passons pour l'instant sur les paramètres, nous les retrouverons bientôt. Remarquez simplement le premier, qui est l'objet image que nous allons manipuler. La première instruction, ligne 47, est liée à la dernière, ligne 55. Les manipulations qui interviennent entre ces deux instructions seront référencées dans un " groupe d'annulation " : elles pourront toutes être annulées en une fois, par exemple lorsque vous utilisez la combinaison de touches Ctrl+Z. Sans cela, pour annuler notre commande, il faudrait annuler chacune des actions que nous avons effectuées : création des calques, translations, sélections, remplissages... ce qui serait extrêmement fastidieux. Lorsque vous créez une commande pour modifier une image existante, il est généralement souhaitable d'utiliser cette paire d'instructions. Ligne 48, nous utilisons simplement notre fonction utilitaire, décrite précédemment. Les lignes 51 à 54 ont pour effet de centrer les deux calques nouvellement créés dans l'image de départ. Voyons maintenant le référencement de notre commande dans Gimp :

057: register(
058:   "texte_et_cadre_dans_image",
059:   "Ecrit un texte dans un cadre (dans une image)",
060:   "Pour le LinuxMagazine HS sur Gimp 2.0",
061:   "Yves Bailly",
062:   "Yves Bailly",
063:   "2004",
064:   "<Image>/Python-Fu/LinuxMag/Texte et cadre",
065:   "RGB*",
066:   [
067:     (PF_STRING, "texte", "Texte", "coucou"),
068:     (PF_FONT, "font", "Police", "Helvetica"),
069:     (PF_SPINNER, "taille_text", "Taille en points", 20, (0,100,5)),
070:     (PF_COLOR, "couleur_texte", "Couleur du texte", (64,128,255)),
071:     (PF_TOGGLE, "antialias", "Antialising ?", 1),
072:     (PF_INT, "epaisseur_cadre", "Epaisseur du cadre", 8),
073:     (PF_COLOR, "couleur_cadre", "Couleur du cadre", (255,128,64)),
074:     (PF_SLIDER, "marge", "Marge interieur", 4, (0,24,2))
075:   ],
076:   [],
077:   texte_et_cadre_dans_image)

Je ne reviens pas sur les six premiers paramètres. Le septième, qui indique dans quel menu la commande doit apparaître, influe sur les paramètres qui seront passés à la fonction Python. Ici, le premier élément est "<Image>", ce qui signifie que la commande sera appliquée à une image en cours d'édition. Conséquence, la fonction Python recevra deux paramètres, avant tous les autres : l'image active, et le calque actif. Ceci explique les deux premiers paramètres de notre fonction texte_et_cadre_dans_image() (ligne 43). Le huitième exige que l'image modifiée soit en mode RGB, avec ou sans canal de transparence. Le neuvième paramètre, la liste des paramètres destinés à la commande, est plus intéressant. Il s'agit d'une liste de tuples, chaque tuple contenant quatre ou cinq éléments : 1. le type de paramètre, donné en utilisant l'une des valeurs PF_* définies dans le module gimpfu (qui est également en Python, donc que vous pouvez examiner facilement) ; 2. le nom du paramètre correspondant à utiliser pour appeler la fonction Python ; 3. le texte devant apparaître dans la boîte de dialogue, lorsque la commande est utilisée de manière interactive (lancée depuis un menu) ; 4. une valeur initiale, par défaut ; 5. pour certains types, des informations supplémentaires. Il serait trop long d'énumérer tous les types de paramètre ici, je vous renvoie à la documentation de la librairie Gimp ([2]). Les plus courants, utilisés ici, sont décrits dans le tableau ci-dessous.

Type	Description
PF_STRING	Une chaîne de caractères, qui se traduit dans l'affichage par un simple champ de saisie.
PF_INT	Une police de caractère, représentée par une chaîne. En mode interactif, un bouton est affiché pour choisir la police dans une liste.
PF_COLOR	Une couleur, représentée par un triplet de valeurs rouge-vert-bleu entre 0 et 255. En mode interactif, se présente sous la forme d'un bouton de la couleur sélectionnée, qui ouvre une boîte de sélection de couleur quand on clique dessus.
PF_TOGGLE	Valeur booléenne, de type oui/non, ou vrai/faux.
PF_SPINNER	Un entier, à choisir entre deux bornes. Se présente sous la forme d'un champ de saisie, avec deux boutons pour incrémenter ou décrémenter la valeur. Le tuple supplémentaire (ligne 69) donne les bornes minimum et maximum, ainsi que la valeur de l'incrément.
PF_SLIDER	Un nombre réel, à choisir entre deux bornes. Se présente sous la forme d'un curseur à déplacer dans une glissière. Le tuple supplémentaire (ligne 74) donne les bornes minimum et maximum, ainsi que la valeur de l'incrément si on clique en-dehors du curseur.

Cette liste de tuples sera utilisée par Gimp pour construire l'interface graphique associée à la commande. Si cette liste est vide, naturellement, il n'y aura pas d'interface. Voilà, nous avons défini notre première " vraie " commande ! Placez tout ce code dans un fichier, par exemple gimp-plugin-demo.py, lequel fichier doit se trouver dans le sous-répertoire plug-ins du répertoire .gimp-2.0 de votre répertoire personnel, comme cela a été expliqué au début de cet article. Ajoutez un appel à main() en dernière ligne. N'oubliez pas de donner l'attribut exécutable au fichier ! Pour que la nouvelle commande soit prise en compte, il est nécessaire de relancer Gimp. Cette manipulation n'est par contre pas nécessaire si vous modifiez simplement le code. Nous allons justement modifier le fichier, pour créer une deuxième commande qui va créer elle-même l'image contenant le texte et son cadre. Gimp devra être relancé pour que la nouvelle commande soit référencée.

Commande créant une nouvelle image

Nous allons cette fois créer une nouvelle image. Un calque de fond sera ajouté " sous " les deux autres calques (du texte et du cadre), un paramètre de couleur supplémentaire permettant de définir, justement, sa couleur. Voici le code :

079: def texte_et_cadre_nouveau( \
080:                texte, font, taille_texte, couleur_texte, antialias,
081:                epaisseur_cadre, couleur_cadre, marge,
082:                couleur_fond) :
083:   image = gimp.Image(1024, 1024, RGB)
084:   image.disable_undo()
085:   (layer_texte, layer_cadre) = texte_et_cadre(image,
086:     texte, font, taille_texte, couleur_texte, antialias,
087:     epaisseur_cadre, couleur_cadre, marge)
088:   image.resize(layer_cadre.width, layer_cadre.height, 0, 0)
089:   gimp.set_background(couleur_fond)
090:   fond = gimp.Layer(image, "Arriere-plan", image.width, image.height,
091:     RGB_IMAGE, 100, NORMAL_MODE)
092:   image.add_layer(fond, 2)
093:   gimp.pdb.gimp_edit_fill(fond, BACKGROUND_FILL)
094:   image.enable_undo()
095:   gimp.Display(image)

Première action, création d'une image, ligne 83. Nous ne savons pas a priori quelle taille est nécessaire, aussi donnons-nous des valeurs quelconques - ce sera ajusté par la suite. Sachez toutefois que ces dimensions sont une limite aux sélections, donc prévoyez suffisamment large. Par exemple, si j'avais créé une image en 10x10, le cadre ne serait que très partiellement dessiné. L'instruction ligne 84, qui va avec celle ligne 94, désactive l'enregistrement des manipulations que nous allons effectuer : elles ne pourront pas être annulées, ce qui est généralement souhaitable lorsqu'on crée une image de toute pièce. Puis nous créons nos calques de texte et de cadre, ligne 85. La ligne 88 ajuste la taille de l'image sur la taille du calque du cadre, les deux derniers paramètres étant la position à laquelle doit être déplacé l'ancien contenu de l'image (on retrouve ces paramètres dans la boîte de dialogue correspondant à cette méthode). Il s'agit bien d'un changement de dimensions de l'image, et non d'une mise à l'échelle (scale) : cette opération peut être effectuée avec la méthode scale() de gimp.Layer. Les lignes 89 à 93 ajoutent un calque pour le fond de l'image, de la couleur choisie. Remarquez le dernier paramètre donné à add_layer() (ligne 92) : comme nous voulons que ce calque soit sous les deux précédents, et que le calque le plus haut a l'indice 1, on insère notre nouveau calque à l'indice 2 (troisième position en partant du haut). La dernière instruction demande à Gimp d'afficher l'image. Sans cela, vous ne la verriez pas ! Mais elle apparaîtrait tout de même dans la liste des images.

Il ne reste plus qu'à référencer notre commande :
097: register(
098:   "texte_et_cadre_nouveau",
099:   "Ecrit un texte dans un cadre (nouvelle image)",
100:   "Pour le LinuxMagazine HS sur Gimp 2.0",
101:   "Yves Bailly",
102:   "Yves Bailly",
103:   "2004",
104:   "<Toolbox>/Xtns/Python-Fu/LinuxMag/Texte et cadre",
105:   "RGB*",
106:   [
107:     (PF_STRING, "texte", "Texte", "coucou"),
108:     (PF_FONT, "font", "Police", "Helvetica"),
109:     (PF_SPINNER, "taille_text", "Taille en points", 20, (0,100,5)),
110:     (PF_COLOR, "couleur_texte", "Couleur du texte", (64,128,255)),
111:     (PF_TOGGLE, "antialias", "Antialising ?", 1),
112:     (PF_INT, "epaisseur_cadre", "Epaisseur du cadre", 8),
113:     (PF_COLOR, "couleur_cadre", "Couleur du cadre", (255,128,64)),
114:     (PF_SLIDER, "marge", "Marge interieur", 4, (0,24,2)),
115:     (PF_COLOR, "couleur_fond", "Couleur de fond", (255,255,255))
116:   ],
117:   [],
118:   texte_et_cadre_nouveau)
119:  
120: main()

Voyez ligne 104, le premier élément de la chaîne étant "<Toolbox>", la commande sera disponible dans le menu principal de Gimp. Celui-ci détermine alors que cette commande crée une nouvelle image, aussi la fonction Python ne recevra-t-elle pas les deux paramètres qui étaient passés à celle que nous avons définie dans la section précédente.

Conclusion

Voilà pour cette rapide introduction aux possibilités offertes aux scripts Gimp-Python. Si vous voulez vous lancer dans l'écriture de scripts, n'hésitez surtout pas à vous inspirer de ceux fournis avec Gimp, vous devriez y trouver beaucoup de réponses. Pour terminer, voici un résultat produit par cette commande : À vos claviers ! Références [1] Gimp Python, http://www.jamesh.id.au/software/pygimp/ [2] Référence de l'API Gimp, http://developer.gimp.org/api/2.0/index.html