Par Wolfgang Mauerer
Aucun doute n'est possible : GIMP n'est pas seulement l'une des applications qui sert à attirer vers Linux les utilisateurs de desktops mais compte également parmi les applications graphiques les plus puissantes du moment. Il n'y a que peu de choses que vous ne puissiez faire avec GIMP. Une de ses principales caractéristiques est la modularité : les programmeurs peuvent l'étendre à l'aide de programmes écrits en C appelés plug-ins. Ouvrez un menu contextuel à l'aide du bouton droit de la souris, allez sur Filters et consultez-en les différents sous-menus : vous verrez tout de suite la puissance des possibilités de plug-ins sous GIMP. Tous les filtres que vous voyez ont été implantés sous forme de plug-ins.
Qu'en est-il de l'entrée suivante du menu contextuel : Script-Fu ? On peut y trouver des tonnes d'effets différents. La différence entre les Script-Fu et les vrais filtres tient dans le fait que les effets Script-Fu ont été générés par le biais de Scripts Scheme : de petits programmes écrits dans un langage étrange appelé Scheme. Celui-ci est fortement lié à Lisp dont certains d'entre vous ont déjà dû entendre parler dans le cadre d'applications d'intelligence artificielle. Gnu Emacs utilise Lisp comme langage d'extension et d'implantation. Quant à Guile (GNU Projects Ubiquitous Language for Extension ou Langage d'Extension Présent Partout dans les Projets GNU) qui peut être intégré dans toutes sortes d'applications, est un dialecte Scheme. Pourquoi alors une application aussi orientée utilisateur que peut l'être Gimp utilise-t-elle un langage aussi compliqué ? Cette question peut être l'objet d'un immense débat philosophique et religieux sur les langages de programmation, débat sur lequel certaines personnes peuvent passer des années. La quintessence de la question religieuse s'étend en gros entre les deux problèmes suivants : quel éditeur de texte utiliser, et la fin du monde. Cependant, cet épineux problème peut se résumer en une simple phrase : Lisp et Scheme sont certes des langages flexibles, puissants et élégants mais ils ne sont pas, en tout cas, des langages faciles à apprendre pour le néopite, en comparaison de langages plus conventionnels. Pour autant, Script-Fu reste un moyen extraordinaire d'étendre les fonctionnalités de Gimp en proposant des raccourcis pour des opérations effectuées souvent ainsi que pour le traitement automatique et la génération d'images : ceci n'est pas utile uniquement à l'utilisateur de base mais ça l'est également aux designers de page web et aux éditeurs. Considérez par exemple votre page personnelle qui utilise des tonnes de boutons graphiques qui ont le même aspect : il vous faudrait faire les mêmes opérations encore et encore pour chaque bouton. À terme, cela devient vite ennuyeux et fatiguant. Le fait de faire un script automatise la chaîne de traitement de telle manière que la seule chose qu'il vous reste à faire soit d'entrer le texte du bouton (en plus, peut-être, de la couleur et d'autres paramètres) : Gimp génère les boutons automatiquement pour vous à l'aide d'un script Script-Fu.
Comme vous le voyez, la possibilité de faire des scripts est une fonctionnalité très puissante qui peut être utile dans de nombreuses situations. Pour faciliter l'écriture de scripts, Marc Lehmann s'est mis en tête d'écrire un logiciel d'extension à Gimp d'ores-et-déjà fourni avec les versions développeurs 1.1.x et qui peut être utilisé pour le version stables 1.0.x de Gimp : il a écrit une interface qui permet d'écrire des scripts Gimp en utilisant le langage Perl. Je ne vais pas me lancer dans une de ces discussions traitant des qualités et des faiblesses de Perl ; ceci dit ce langage est bien plus facile à apprendre que le Script-Fu si vous n'avez pas d'expérience en programmation. Par ailleurs, c'est même son principal avantage à mon avis vu que la plupart des scripts CGI et des programmes interfacés Web sont écrits en Perl ce qui fait qu'un grand nombre de personnes connaît ce langage.
Des interprètes Perl sont disponibles sous toutes les distributions Linux que je connais car Perl est petit à petit devenu un des composants importants d'un système UNIX : il n'est donc généralement pas nécessaire de l'installer séparément. Si vous utilisez la version stable de GIMP (1.0.x), le paquetage Gimp-Perl doit d'abord être installé : voir ci-dessous pour savoir comment faire. Si vous souhaitez utiliser des scripts interactifs, un langage d'interfaçage entre Perl et le toolkit de Gimp, GTK, doit également être installé afin de pouvoir en utiliser les fonctions. Les instructions pour ce faire sont également présentes ci-dessous.
Assez de théorie : jetons un coup d'oeil au petit script Gimp-Perl ci-dessous pour voir comment cela fonctionne.
#! /usr/bin/perl
# Script simple, modifié, 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é<\n>",
"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->set_background('red');
Palette->set_foreground('white');
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, $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 lance Perl pour pouvoir interpréter les 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, d'un autre côté, le script est présenté 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 :
<Toolbox>/Xtns/Script-Fu/Simple/Color Canvas
on se serait attendu à trouver le script quelque part dans le menu Xtns (Extensions). 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 le relancer immédiatement. 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ûr 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.pl
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 -- Explorer la base de procédures...), 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
Figure 1 : explorateur de base de données
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 à son sujet 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: c'est que 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 un 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 significatifs 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 scripts 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 montrent 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.
Figure 2 : explorateur de base de données procédural
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 au clavier (la complétion avec F2 est également 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ète 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 originale). 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 (en gras le nom de l'option, puis l'information donnée en sortie) :
Pas de traçage du tout.
Affiche toutes les fonctions exécutées avec leurs paramètres.
Affiche la description de la fonction à partir de la base de données interne de GIMP : tous les noms de paramètres, leur description et les valeurs qu'ils peuvent prendre.
Affiche toutes les informations disponibles.
gimp_image_new(width=640, height=480, type=0) = (image=7)<newline> gimp_palette_set_foreground(foreground=[255,0,0]) = ()<newline> gimp_palette_set_background(background=[0,0,255]) = ()<newline> gimp_layer_new(image=7, width=640, height=480, type=0, name="Color Canvas",<newline> opacity=100.000000, mode=0) = (layer=16)<newline> gimp_blend(drawable=16, blend_mode=0, paint_mode=0, gradient_type=0,<newline> opacity=100.000000, offset=0.000000, repeat=0,<newline> supersample=0, max_depth=0, threshold=0.000000, x1=0.000000,<newline> y1=0.000000, x2=639.000000, y2=379.000000) = ()<newline> plug_in_apply_canvas(run_mode=1, image=7, drawable=16,<newline> direction=0, depth=10) = ()<newline> gimp_image_add_layer(image=7, layer=16, position=0) = ()<newline>
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 donnera l'impression qu'ils sont incrustés dans votre bureau. Si vous avez déjà utilisé un programme utilisant le nouveau look métal de Java, vous savez de quoi je parle. Gtk offre lui aussi un tel rendu pour les 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 :
[<newline> [PF_STRING, 'text', 'Le texte du bouton.',""],<newline> [PF_FONT, 'font', 'La fonte utilisée pour le bouton.'],<newline> [PF_BOOL, 'flat', 'Mettre l'image à plat et la convertir en indexée']<newline> ]
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,nom,description,valeur par défaut(optionnelle),autres valeurs(optionnelles)]
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 la 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 manuel. (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]);
}
Figure 3 : la boîte de dialogue du script
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 suivant. 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 se trouvent 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 :
-Adobe-Courier-Medium-R-Normal-14-140-75-75-M-90-ISO8859-1
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 besoin à la fois 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 peut, par conséquent, n'ê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.
Pour un confort accru de l'utilisateur, 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.
Figure 4 : boutons générés avec GIMP-Perl
Si vous avez aimé le script, vous pouvez l'installer avec la commande gimptool comme nous l'avons vu dans l'exemple simple. Une nouvelle entrée appelée Etched apparaîtra alors dans Xtns -> Script-Fu -> Buttons.
Copyright © 2000, Wolfgang Mauerer. Paru dans le numéro 51 de la Linux Gazette de Mars 2000.
Traduction française de Pierre Tane
