Assez de théorie : jetons un coup d'œil au petit script Gimp-Perl ci-dessous pour voir comment cela fonctionne.

#! /usr/bin/perl
# Script simple destiné à montrer les bases de gimp-perl
use Gimp;
use Gimp::Fu;
register "colored_canvas",
         "Crée un canvas coloré",
         "Ce script crée un motif de canvas au dessus d'un gradient coloré",
         "Wolfgang Mauerer",
         "wolfgang\@mynetix.de", # @ s'écrit \@ dans une string perl
         "0.0",
         "<Toolbox>/Xtns/Script-Fu/Patterns/Color Canvas",
         "",
         [],
         sub {
	     my $image = new Image(640, 480, RGB);
	     # Mise en place de nouvelles sélections pour les couleurs
	     # d'arrière et d'avant-plan
	     Palette
	     Palette
	     my $layer = $image->layer_new(640, 480, 
                                           RGB_IMAGE, 
					   "Color Canvas", 
                                           100, NORMAL_MODE);
	     
	     # Crée un gradient coloré avec les couleurs choisies.
	     Gimp->gimp_blend($layer, 0, 0, 0, 100, 0, 0, 0, 0, 0, 0, 0,
                              639, 379);
	     # ... et applique le filtre canvas
	     Gimp->plug_in_apply_canvas(1, $image, $layer, 0, 10);
	     $image->add_layer($layer, 0);

	     return $image;
	 };
exit main;

La première ligne du script, #!/usr/bin/perl, n'a rien à voir avec GIMP ou Perl, c'est juste une commande shell qui utilise Perl comme interpréteur des commandes présentes dans le fichier. Vous l'avez sûrement déjà vue dans des scripts shell.

Les premières lignes qui nous intéressent sont celles qui contiennent use Gimp; et use Gimp::Fu; : elles servent à l'initialisation des fonctions GIMP et en autorisent l'utilisation. Si vous utilisez ces lignes dans vos scripts Perl, vous serez en mesure d'utiliser presque toutes les fonctions de GIMP.

Un point important dans la création d'un nouveau script, c'est son enregistrement sous GIMP. Sous GIMP-Perl, cette tâche est prise en charge par la fonction register qui prend de nombreux arguments en paramètres. Le script est décrit par ceux-ci afin que d'autres utilisateurs puissent se faire une idée de la fonction du script par le biais d'une description textuelle et, inversement, le script est fourni aux structures internes de GIMP afin qu'il puisse être exécuté correctement. Les arguments ont la signification suivante :

Tapez ou téléchargez ce script, sauvez-le (dans notre exemple, il prend le nom de simple.pl) et donnez lui les droits d'exécution (chmod a+x simple.pl sous le shell. Lancez alors GIMP et le serveur Perl (Menu Xtns → Perl Server) puis exécutez le script en tapant ./simple.pl. Si tout a marché, une nouvelle fenêtre avec un canvas rouge-bleu devrait apparaître sur votre bureau X.

Si vous obtenez un message d'erreur du style Command not found (cela peut varier en fonction du shell que vous utilisez), vérifiez l'endroit où se trouve votre interpréteur Perl en tapant whereis perl et ajustez en fonction la ligne #! pour qu'elle pointe vers le bon endroit. Si vous recevez des messages d'erreur de Perl, vérifiez le code du script et essayez de corriger les fautes de frappe.

Ça marche pas mal, non ? Mais quelque chose reste quand même bizarre : quand on effectue l'appel à register, nous donnons un emplacement dans la hiérarchie des menus de Gimp et, si l'on en croit la ligne :

on se serait attendu à trouver le script quelque part dans le menu Xtns. La raison pour laquelle le script n'est pas encore installé de manière permanente est simple : on a pour le moment fait appel à un mode de test, fonctionnalité plutôt maligne de Perl qui permet de tester rapidement de nouveaux scripts. Normalement, un script doit être installé pour pouvoir être utilisé de manière permanente sous Gimp. En lançant le serveur Perl, nous pouvons tester notre script sur la ligne de commande en ayant le même résultat que pour un module installé normal. Un autre avantage important du serveur Perl est que vous pouvez modifier votre script aussi souvent que vous le voulez et ensuite le relancer. Quand vous installez un script de manière permanente, vous devez le réinstaller à chaque modification. Pire, chaque fois qu'un script est installé, il vous faut redémarrer GIMP. Déboguer ou améliorer un script prendrait beaucoup de temps avec une telle méthode mais, à l'aide du serveur Perl, tout fonctionne bien et le temps de développement est réduit d'autant.

Quand vous êtes sûrs que votre script se comporte comme vous le voulez, vous pouvez l'intégrer à GIMP en utilisant l'utilitaire gimptool. Notre petit script, par exemple, se verrait installé au moyen de la commande :

gimptool -install-bin simple_fu.pl

Le script n'est utilisable que pour votre configuration GIMP personnelle : d'autres utilisateurs n'auront pas accès à votre script de cette manière. Si vous souhaitez que tous les utilisateurs puissent profiter de votre travail, il vous faut taper :

gimptool -install-admin-bin simple_fu.pm

Ceci installe le script de manière globale sur votre machine. Vous devez avoir les droits de root pour ce faire.

Après l'installation du script, vous verrez une nouvelle entrée dans le menu Xtns → Script-Fu → Patterns avec pour nom Color Canvas. Sélectionnez cette entrée pour exécuter le script et vous obtiendrez la même fenêtre que celle que vous aviez obtenue en appelant le script directement sur la ligne de commande: notre canvas rouge-bleu.

Avec un script plutôt simple, nous avons créé une image qui nécessiterait plusieurs centaines de lignes de code sans GIMP. Dans la mesure où il nous a été possible d'utiliser des fonctions prédéfinies (comme GIMP-blend) et des plug-ins déjà existants (apply_canvas), tout ce travail ne nous a demandé que peu de codage.

Comme vous vous en doutez certainement, GIMP est construit sur la base d'un très grand nombre de fonctions et de procédures et un grand nombre d'entre elles peut être utilisé à l'intérieur de scripts, que vous écriviez ceux-ci en C, en scripts fu ou avec GIMP-Perl. Comment tirer parti de cette intéressante fonctionnalité sans lire le code source de GIMP et étudier tous les scripts et les plug-ins ? Comme nous l'avons vu lors de l'enregistrement de notre premier script dans Gimp, tout composant nouveau qui peut être utilisé par d'autres utilisateurs ou programmeurs de GIMP doit se voir accompagné de textes descriptifs. Toutes les fonctions de base, à l'instar de tous les scripts et plug-ins fournis par défaut avec GIMP, ont de telles descriptions. Le point d'accès central à toutes ces fonctions, avec leurs paramètres et leurs descriptions, est l'explorateur de base de données (DB Browser), un catalogue interactif qui vous assiste dans le développement de scripts.

L'explorateur de base de données peut être lancé en sélectionnant l'entrée DB Browser dans le menu Xtns. Une boîte de dialogue comme celle de la figure 1 apparaît sur votre écran.

La meilleure chose à faire si vous voulez travailler avec GIMP-Perl, c'est d'utiliser les versions développeur de GIMP (1.1.x). Vous pouvez les trouver sur les sites miroirs de GIMP (voir sur http://www.gimp.org/). L'installation du paquetage pour GIMP 1.0.x demande un peu plus de travail. Il vous faut d'abord récupérer GIMP-Perl et Gtk-Perl (au moins la version 5.0120) sur n'importe quel miroir CPAN (http://www.cpan.org/). Il vous faut décompacter les fichiers tar avec les commandes :

tar xzfv Gtk-Perl-0.5120.tar.gz
tar xzfv Gimp-1.098.tar.gz

Placez vous dans les répertoires qui viennent d'être créés et, dans chacun d'eux, tapez :

perl Makefile.PL
make
make test
make install

Si Gtk-Perl ne fonctionne pas et que GNOME n'est pas installé, il vous faut taper :

perl Makefile.PL --without-gnome

Dans la partie de gauche de la figure ci-dessus se trouve une liste contenant de nombreux noms de fonctions : les fonctionnalités de GIMP sont vraiment énormes. Quand vous choisissez une fonction dans la liste, un certain nombre d'informations en rapport s'affichent dans la partie droite de la fenêtre : le nom de la fonction, un blurb (nous en avons déjà parlé précédemment, c'est le nom que donne GIMP à un court texte descriptif), un texte d'aide et, plus important, les paramètres requis pour la bonne exécution de la fonction. Quand vous voyez une ou plusieurs lignes commençant par Out:, la fonction retourne des valeurs calculées en plus des paramètres fournis lors de l'appel. Par exemple, la fonction gimp-layer-new prend une longue liste de paramètres et retourne un nouveau calque (layer). Nous avons utilisé cette fonction dans notre script exemple en lui donnant les bons paramètres et en assignant à la variable $layer le calque retourné.

Bien sûr, les boutons Search by name (rechercher selon le nom) et Search by blurb (rechercher selon le blurb) vous permet de chercher une fonction soit par son nom soit par une courte description. Cherchez par exemple la chaîne canvas dans les noms de fonctions et vous obtiendrez les fonctions GIMP qui comportent canvas dans leur nom. Choisissez plug-in-apply-canvas et regardez quels paramètres ont été utilisés pour cette fonction dans notre script.

Si vous regardez attentivement les noms de fonctions, vous remarquerez une détail important : alors que toutes les fonctions listées dans la base de données possèdent des tirets normaux (-), leurs équivalents dans le script Perl utilisent des underscores (_) à la place. Alors que Scheme (et Lisp) utilisent généralement le - comme symbole de séparation, Perl utilise le _ par convention. L'effet en est que vos scripts seront en accord avec le code Perl généralement disponible et seront dès lors plus faciles à lire et à comprendre pour les programmeurs autres que vous. Ainsi, quand vous cherchez des fonctions dans l'explorateur de base de données (abrégé DBB en anglais), n'oubliez pas de remplacer les tirets par des underscores dans votre programme Perl.

Dans certaines fonctions, des constantes peuvent être utilisées comme paramètres car des noms signifiants sont plus faciles à se rappeler que des nombres. Faites attention quand vous utilisez de telles constantes car GIMP-Perl remplace ici aussi les tirets par des underscores.

L'explorateur de base de données est un outil puissant pour vous aider au développement de script mais ce n'est pas le seul qui soit à votre disposition sous GIMP. PDB, l'explorateur de base de données procédural (Procedural Data Base Browser), est un outil analogue à DBB. Ils ont les mêmes fonctions mais les présentent de manière différente. Vous pouvez le lancer en choisissant l'entrée appropriée dans le menu Xtns. Comme vous pouvez le voir, il y a le logo GIMP-Perl dans le coin en haut à droite. Ce n'est donc pas un outil script-fu, il a été spécifiquement écrit pour GIMP-Perl. Dans la barre de titre de la fenêtre, vous pouvez voir que cet explorateur est toujours une version alpha : attendez vous donc à ce que des choses changent. Néanmoins, PDB est déjà un très bon utilitaire pour la création de scripts GIMP-Perl.

En gros, tout se passe comme suit : dans la boîte de dialogue Command, vous tapez un nom de fonction et toutes les fonctions contenant la chaîne apparaissent dans la boîte du bas. Vous pouvez soit continuer à taper jusqu'à ce qu'il ne reste plus qu'une seule solution (insérez là en tapant F2) soit choisir le nom de la fonction dans la liste. Prenez par exemple plug_in_apply_canvas. Quand vous appuyez sur espace après le nom de la fonction, le PDB va vous demander le premier paramètre de la fonction en vous proposant dans le même temps une liste de possibilités. Une fois encore, vous avez le choix entre en prendre une dans la liste ou taper le paramètre avec le clavier (la complétion avec F2 est par ailleurs disponible). Le même processus recommence jusqu'à ce que tous les paramètres nécessaires à l'appel aient été choisis. La barre d'état au bas de la fenêtre qui indique le pourcentage de paramètres renseignés est une fonctionnalité appréciable pour les fonctions en comportant 10000.

Utilisés ensemble, le PDB et le DBB sont deux outils très utiles pour vous aider dans le développement de scripts.

Si l'on en croit Larry Wall et Randal Schwarz dans Programmation Perl, un programmeur a trois vertus majeures : la paresse, l'impatience et l'orgueil. Mais quel rapport cela a-t-il avec notre sujet, GIMP ? Pensez aux appels de fonctions : ne sont-ils pas trop longs pour un programmeur paresseux et impatient ? Écrire toujours GIMP->gimp_... avant tout appel peut devenir ennuyeux. GIMP-Perl introduit des raccourcis pour régler ce genre de problèmes. Quand vous regardez les fonctions de GIMP, vous constatez qu'elles correspondent toutes à une certaine catégorie qui peut être déduite de leur entête : toutes les fonctions commençant par gimp-palette traitent d'opérations sur les palettes, les fonctions opérant sur les calques comportent la chaîne gimp-layer au début de leur nom et ainsi de suite. Dans la mesure où GIMP-Perl utilise la notation orientée objet de Perl, on peut s'épargner beaucoup de frappe en utilisant les formes plus courtes de ces opérations avec comme effet secondaire que vos scripts seront bien plus faciles à lire et à comprendre. Si, par exemple, vous disposez d'un objet image ($image dans notre exemple), vous pouvez utiliser les fonctions gimp-image- en les concaténant au nom de l'objet. Gimp->image_add_layer($image, $layer, 0) devient $image->add_layer($layer, 0) par ce biais. $image n'est alors plus un paramètre nécessaire dans la mesure où l'image à laquelle le calque va être ajouté devient évidente.

Une autre possibilité pour raccourcir vos scripts est d'utiliser le genre d'abbréviations que l'on peut utiliser avec les opérations de palette. Au lieu d'écrire Gimp->palette_set_foreground(...), il vous suffit d'utiliser Palette->set_foreground(...).

Pour savoir quels types d'abbréviations sont utilisables, lisez la page de man de Gimp/Fu en tapant man Gimp::Fu (si cela ne fonctionne pas, essayez perldoc Gimp::Fu).

Les programmeurs sont juste des humains, ils sont donc sujets à faire des erreurs dans les programmes. Il en est de même avec GIMP-Perl mais avec une extension spéciale : vous pouvez d'une part écrire du code Perl bogué et, d'autre part, appeler les fonctions de GIMP d'une manière erronée.

L'interpréteur Perl nous aide à régler les problèmes qui relèvent de la première catégorie en affichant les messages d'erreur correspondant mais qu'en est-il des erreurs provenant de GIMP ? Imaginez que nous appelions les fonctions internes de GIMP avec un mauvais ensemble d'arguments. Bien que le nombre de paramètres soit correct, un ou plusieurs d'entre eux peuvent dépasser leur intervalle de définition. Le seul message obtenu sera quelque chose du genre « procedural database execution failed at file name line line_number » (faute d'exécution dans la base de données procédurale dans le fichier nom à la ligne numéro de ligne). Voilà qui nous est de peu d'utilité.

Le traçage est une manière d'obtenir des messages plus précis sur l'exécution de votre script. Il vous suffit d'insérer Gimp::set_trace(TRACE_NAME) dans l'en-tête de votre routine et vous obtiendrez la liste de toutes les fonctions appelées avec leurs arguments. Pour notre script simple, la sortie sur STDERR ressemblera au listing 2 (les lignes ont été divisées en plusieurs parties dans la mesure où elles sont très longues dans la sortie originelle). Il est possible d'affiner les informations fournies lors du traçage en utilisant le paramètre de l'appel de set_trace. Dans notre exemple, nous avons utilisé TRACE_NAME mais il existe d'autres possibilités :

gimp_image_new(width=640, height=480, type=0) = (image=7)
gimp_palette_set_foreground(foreground=[255,0,0]) = ()
gimp_palette_set_background(background=[0,0,255]) = ()
gimp_layer_new(image=7, width=640, height=480, type=0, name="Color Canvas",
opacity=100.000000, mode=0) = (layer=16)
gimp_blend(drawable=16, blend_mode=0, paint_mode=0, gradient_type=0,
opacity=100.000000, offset=0.000000, repeat=0,
supersample=0, max_depth=0, threshold=0.000000, x1=0.000000,
y1=0.000000, x2=639.000000, y2=379.000000) = ()
plug_in_apply_canvas(run_mode=1, image=7, drawable=16,
direction=0, depth=10) = ()
gimp_image_add_layer(image=7, layer=16, position=0) = ()

Montrons maintenant les fonctionnalités de GIMP-Perl que l'on a employées jusqu'à présent dans un contexte plus complexe qu'auparavant. Avez-vous déjà créé une page personnelle qui utilise des boutons graphiques ? Si oui, vous savez certainement que pour chaque bouton les mêmes opérations doivent être appliquées à chaque fois : c'est un champ d'application parfait pour un script GIMP-Perl.

Ce sur quoi nous travaillons, ce sont des boutons avec un élément texte centré (des fontes et des tailles variables devraient pouvoir être employées) et entouré par un cadre qui ressemble à ceux que vous trouvez sur votre bureau. Si vous avez déjà utilisé un programme utilisant le nouveau look metal de Java, vous savez de qui je parle. Gtk offre lui aussi le rendu de tels boutons.

Avant de commencer à écrire notre script, nous devons considérer les étapes qui doivent être faites en premier. Trois calques sont nécessaires : un pour le fond, un pour la bordure et un pour le texte. Les calques de la bordure et du texte doivent être transparents : nous avons donc besoin d'un canal alpha.

Aussi bien le nom et la taille de la fonte que le texte du bouton doivent être configurables par l'utilisateur, ils sont donc passés en paramètre au script. Quand vous utilisez les scripts scripts-fu existants, des boîtes de dialogue pour chacun des paramètres à régler apparaissent avant l'exécution du script proprement dite. Il est possible de faire la même chose avec GIMP-Perl : lors de l'enregistrement d'une fonction, il nous suffit de préciser quels arguments du script doivent être configurables par l'utilisateur et les boîtes de dialogue dans lesquelles les paramètres sont entrés sont générées et affichées automatiquement à l'exécution du script. Toutes ces définitions de paramètres doivent être mises entre les crochets qui apparaissaient déjà dans le registre du premier exemple. La ligne décrivant un paramètre doit également être mise entre crochets. Pour notre nouveau script, cela sera du genre :

[
 [PF_STRING, 'text', 'Le texte du bouton.',""],
 [PF_FONT, 'font', 'La fonte utilisée pour le bouton.'],
 [PF_BOOL, 'flat', 'Mettre l'image à plat et la convertir en indexée]
]

Des utilisateurs de Perl expérimentés savent qu'une référence sur un tableau contenant des références de tableaux est passée de cette manière mais ceci n'est qu'un détail technique. Le bloc [] qui décrit l'argument est toujours structuré de la manière suivante :

PF_TYPE donne le type de l'argument. Ceci est important dans la mesure où le type de saisie diffère selon le type de données : une sélection de fonte est effectuée via une boîte de sélection de fonte tandis que les chaînes sont entrées à l'aide d'une boîte de texte. Les valeurs booléennes (vrai/faux) seront renseignées via une case à cocher. Les valeurs possibles de PF_TYPE sont documentées dans ma page de man Gimp/Fu. Compte tenu du fait que le nombre de types d'entrée est plutôt grand, nous n'allons pas tous les traiter ici : allez voir du côté de la page de man. (En fait, il serait plutôt difficile d'écrire un script qui fasse appel à des paramètres de tous les types possibles.)

name précède l'élément de saisie, c'est un texte descriptif; la description apparaîtra comme une bulle d'aide (de la même manière que quand vous laissez votre souris sur un widget de sélection sans bouger pendant un moment).

La valeur par défaut d'un paramètre doit être une valeur de base sûre pour le script ou alors on choisit de lui donner la valeur optimale qui donnera un bel aspect au résultat afin de donner une idée.

Les autres valeurs ont des significations différentes selon le type du paramètre mais nous n'allons pas en tirer parti ici.

#! /usr/bin/perl
# Script Gimp-perl pour créer des boutons en relief

use Gimp;
use Gimp::Fu;

register "etched_button",
         "Crée des boutons en relief",
         "Crée un bouton avec une bordure en relief. " .
         "La taille du bouton s'adapte automatiquement à la taille du texte.",
         "Wolfgang Mauerer",
         "wolfgang\@mynetix.de",
         "21-Jul-1999",
         "<Toolbox>/Xtns/Script-Fu/Buttons/Etched",
         "",
         [
          [PF_STRING, 'text', 'Texte du bouton', ''],
          [PF_FONT, 'font', 'Fonte du texte', 
           '-adobe-helvetica-medium-r-normal-*-*-120-*-*-p-*-iso8859-1'],
          [PF_BOOL, 'flat', 'Égalise l'image et la convertie en indexée']
	 ],
         \&create_etched_button;

exit main;

sub create_etched_button {
    # Récupère les paramètres réglables
    my $text = shift;
    my $font = shift;
    my $flatten = shift;

    # Décommentez cette ligne pour voir les messages de déboguage
    # Gimp::set_trace(TRACE_NAME);

    # Sauvegarde les couleurs
    my $old_fg = Palette->get_foreground;
    my $old_bg = Palette->get_background;

    my $image = new Image(640, 480, RGB);
    Palette->set_foreground('black');
    my $text_layer = Gimp->gimp_text_fontname($image, -1, 0, 0, $text, 1, 1, 
                                              xlfd_size($font), $font); 
    $image->resize($text_layer->width + 10, $text_layer->height + 10, 5, 5);
    my $background = $image->layer_new($image->width, $image->height, 
                                       RGB_IMAGE, "Background", 100, 
                                       NORMAL_MODE);
    Palette->set_background([192, 192, 192]);
    $background->fill(BG_IMAGE_FILL);
    $image->add_layer($background, 0);
    $image->raise_layer_to_top($text_layer);

    Brushes->set_brush("Circle (01)");

    my $frame_layer = $image->layer_new($image->width, $image->height, 
                                        RGB_IMAGE, "Frame Layer", 100, 
                                        NORMAL_MODE);
    $frame_layer->add_alpha();
    $frame_layer->drawable_fill(3);
    $image->add_layer($frame_layer, -1);

    # Zeichnen des Rahmens
    Palette->set_foreground('black');
    &create_frame($frame_layer, 0, 0, $image->width - 2, $image->height - 2);

    Palette->set_foreground('white');
    &create_frame($frame_layer, 1, 1, $image->width - 1, $image->height - 1);

    if ($flatten == 1) {
        # Égalise l'image et la convertit en indexée
        $image->merge_visible_layers(EXPAND_AS_NECESSARY);
        $image->convert_indexed(1, 0, 256, 1, 1, "");
    }

    # Restaure les réglages antérieurs de la palette
    Palette->set_foreground($old_fg);
    Palette->set_background($old_bg);
    
    # Retourne l'image générée
    return $image;
}

sub create_frame {
    # Crée un cadre dessiné au crayon sur le calque spécifié par le paramètre 1,
    # les dimensions se trouvant dans (x1, y1, x2, y2).
    my $frame_layer = shift;
    my ($x1, $y1, $x2, $y2) = @_;

    Gimp->gimp_pencil($frame_layer, 4, [$x1, $y1, $x2, $y1]);
    Gimp->gimp_pencil($frame_layer, 4, [$x1, $y1, $x1, $y2]);
    Gimp->gimp_pencil($frame_layer, 4, [$x2, $y1, $x2, $y2]);
    Gimp->gimp_pencil($frame_layer, 4, [$x1, $y2, $x2, $y2]);
}

De quoi d'autre aurons-nous besoin pour créer un bouton ? Une routine pour créer le cadre serait plutôt pratique : nous allons l'implanter sous forme d'une routine Perl qui appelle les fonctions GIMP correspondantes qui vont dessiner les quatre lignes à l'aide de l'outil crayon. Le script figure dans le listing 3. Comme vous pouvez le constater, la routine utilisée pour le contrôle de la création du bouton n'est plus anonyme comme dans l'exemple simple, c'est une vraie routine Perl. Il nous faut donc utiliser &create_etched_button pour passer une référence de la routine à la fonction register.

Notre troisième argument a pour nom flat. Quand il est sélectionné, tous les calques de l'image seront assemblés et le calque résultant sera converti dans le format de couleur indexé. L'image sera sauvée au format gif.

Le schéma de fonctionnement général du script doit maintenant être clair étant donné que la structure n'a été que très peu modifiée par rapport à l'exemple simple, si ce n'est qu'il y a maintenant des paramètres et que la routine est une vraie routine Perl. Il nous reste à expliquer comment le calque de texte est créé.

La fonte et sa taille ont été choisies par l'utilisateur et peuvent se trouver dans la chaîne $font. Son format est qualifié de X logical font description (description logique de fonte sous X) et prend la forme de :

Plutôt compliqué. Mais cela n'est pas un problème : nous pouvons utiliser directement cette chaîne en argument de gimp-text-fontname, une fonction qui crée un nouveau calque contenant une chaîne donnée. La fonction a à la fois besoin du nom de la fonte et de sa taille. Celle-ci est contenue dans la chaîne décrivant la fonte et peut en être extraite en utilisant la fonction xlfd_size fournie par GIMP-Perl.

Dessiner deux cadres qui se recouvrent pour créer l'effet de relief se fait par le biais de la procédure Perl draw_frame qui n'est pas exportée dans la base de données de GIMP et qui ne peut par conséquent être utilisée que dans notre script. Elle dessine quatre lignes à partir des coordonnées des coins en haut à gauche et en bas à droite. Les sélections de couleur et de brosse ne sont pas changées : les valeurs qui sont actives au moment de l'appel sont utilisées.

Si le drapeau flat est positionné ($flatten est alors à 1), d'autres opérations sont également effectuées : les calques sont rassemblés en un seul et l'image est convertie en couleurs indexées ce qui permet la sauvegarde au format gif.

Les couleurs de fond et d'avant-plan sont restaurées à leurs valeurs originelles avant l'exécution du script. L'image résultante est alors renvoyée à GIMP, ce qui fait apparaître une nouvelle fenêtre contenant un bouton graphique. Vous ne verrez pas trop l'effet de relief mais mettez-le dans une page web et il devrait ressembler à la figure 4.

Si vous avez aimé le script, vous pouvez l'installer avec la commande gimptool comme nous l'avons vue dans l'exemple simple. Une nouvelle entrée appelée Etched apparaîtra dans Xtns → Script-Fu → Buttons.