IDL et ses widgets

IDL et ses widgets
IDL et ses widgets 1
(aide à l’apprentissage - Jean Aboudarham)

IDL et ses widgets 2
Table des matières
I. RAPPELS IDL ..................................................................................................................................................... 3
1) PASSAGES DE VALEURS ENTRE PROGRAMMES .................................................................................................... 3
2) LES STRUCTURES............................................................................................................................................... 3
3) QUELQUES RAPPELS DE REGLES D’ECRITURE...................................................................................................... 4
II. PRINCIPE GENERAL DES WIDGETS........................................................................................................... 4
1) GENERALITES.................................................................................................................................................... 4
a) Qu’est-ce qu’un « widget » ?........................................................................................................................ 4
b) Qu’est-ce qu’un « compound widget » ?....................................................................................................... 4
2) HIERARCHIE...................................................................................................................................................... 4
3) LES DIFFERENTS WIDGETS ................................................................................................................................. 5
4) LES CONTROLES ................................................................................................................................................ 6
III. PRATIQUE SIMPLE ....................................................................................................................................... 7
1) LES WIDGETS, LEURS ARGUMENTS DE BASE ET LES STRUCTURES ASSOCIEES....................................................... 8
a) widget_base ................................................................................................................................................. 8
b) widget_button .............................................................................................................................................. 8
c) widget_draw................................................................................................................................................. 9
d) widget_droplist ............................................................................................................................................ 9
e) widget_label................................................................................................................................................. 9
f) widget_list .................................................................................................................................................. 10
g) widget_slider ............................................................................................................................................. 10
h) widget_table............................................................................................................................................... 11
i) widget_text ................................................................................................................................................. 11
2) ROUTINE DE TRAITEMENT DES EVENEMENTS.................................................................................................... 12
a) Widget_control .......................................................................................................................................... 12
b) La gestion des événements ......................................................................................................................... 13
3) TRANSFERT D’ARGUMENTS ............................................................................................................................. 14
4) UN EXEMPLE SIMPLE ....................................................................................................................................... 15
IV. UN PEU DE COMPLEXITE.......................................................................................................................... 18
1) ARGUMENTS COMPLEXES DES WIDGETS ........................................................................................................... 18
a) Mots clés communs à la plupart des widgets .............................................................................................. 18
b) Widget_base............................................................................................................................................... 19
c) Widget_button............................................................................................................................................ 20
d) Widget_draw.............................................................................................................................................. 20
e) widget_label............................................................................................................................................... 20
f) widget_table ............................................................................................................................................... 21
g) widget_text................................................................................................................................................. 21
2) LES COMPOUND WIDGETS ................................................................................................................................ 22
a) cw_bgroup ................................................................................................................................................. 22
b) cw_defroi................................................................................................................................................... 23
c) cw_field...................................................................................................................................................... 23
d) cw_form..................................................................................................................................................... 24
e) cw_fslider................................................................................................................................................... 24
f) cw_pdmenu................................................................................................................................................. 24
g) cw_zoom .................................................................................................................................................... 25
3) REPRISE DE L'EXEMPLE DU DEBUT AVEC UN COMPOUND WIDGET...................................................................... 26
4) WIDGET_INFO.................................................................................................................................................. 27
5) UN EXEMPLE PLUS COMPLET DE WIDGET.......................................................................................................... 28
INDEX ................................................................................................................................................................... 32

I. Rappels IDL
1) Passages de valeurs entre programmes
Il existe trois façons de passer des arguments entre procédures (ou fonctions) :
• Les arguments, qui sont des noms de variables, déterminés par leur nombre et leur position.
Par exemple :
plot,tab Un seul argument : tab. C’est le tableau de points à tracer
plot,val_x,tab Deux arguments : val_x et tab. Le 1 er comporte le tableau de valeurs de
l’axe des abcisses, et le second le tableau des points à tracer.
• Les mots-clés, sont caractérisés par leur nom auquel est associée une valeur grâce au signe ‘=‘.
Leur position n’a aucune importance.
Par exemple :
tit=‘Tracé de la fonction tab’
plot,tab,title=tit title est un mot-clé
Rappelons que la syntaxe /keyword est équivalente à keyword = 1.
• Les commons s’écrivent sous la forme common suivi d’un espace puis du nom du common
séparé de noms de variables par des virgules. Par exemple :
common mon_com,var1,var2,var3
• Les commons passent de façon instantanée les valeurs des variables entre les programmes, y
compris avec l’instance principale de IDL (celle où on peut entrer les commandes en ligne), alors
que les arguments ne se passent qu’au début puis à la fin du programme appelé. Par contre, une
fois qu’il a été déclaré (dans un programme ou en mode interactif), il est impossible de modifier
le contenu d’un common (attention, il s’agit des variables qui le composent : leur nom, leur ordre,
... ; pas du contenu des variables). Il faut alors quitter la session IDL puis la relancer pour pouvoir
le corriger.
2) Les structures
Les structures sont un format spécial de variable qui permet de mélanger les types et les
dimensions au sein d’un même nom. L’avantage est de pouvoir ainsi regrouper des éléments
ayant des points communs ensemble, et de pouvoir les transférer entre des modules sous un nom
unique de variable. Une structure se définit soit avec un nom, soit de façon « anonyme » :
a={nom_structure, champ1:val1,champ2,val2,...} ou
a={champ1:val1,champ2,val2,...}
Pour connaître le contenu du champ i de la structure a, il suffit de taper :
print,a.champi
Une structure peut être un tableau. Pour créer un tableau b de 100 éléments de même structure
que la structure a, il faut faire :
b=replicate(a,100) ou, directement :
b=replicate({champ1:val1,champ2:val2,...},100)
Les valeurs des champs vont être soit des variables mises à 0 ou vides (dans le cas des chaînes de
caractères) - ou directement leur contenu définitif - soit des déclarations de tableau. Par exemple :
a={champ1:0,champ2:0.,champ3:’’,champ4:0L,champ5:strarr(12)}
IDL et ses widgets 3

Ici, champ1 est un entier, champ2 un réel, champ3 une chaîne de caractères, champ4 un
entier long, champ5 un tableau de chaînes de caractères à 12 éléments.
Si b = replicate(a,100), on peut accéder à la 5 ème structure par :
print,b[4]
On peut également accéder au champ2 de la 6 ème structure par :
print,b[5].champ2
Et on peut accéder à la 3 ème chaîne du champ5 de la 7 ème structure par :
print,b[6].champ5[2]
Pour obtenir le descriptif de la structure, il faut faire :
help,b,/structure
3) Quelques rappels de règles d’écriture
Pour un mot-clé, faire précéder son nom de / équivaut à mettre sa valeur à 1
Les fonctions s’écrivent sous la forme : res = nom_fonction(param)
Les tableaux s’écrivent avec des crochets : tab[i,j]
II. Principe général des widgets
1) Généralités
a) Qu’est-ce qu’un « widget » ?
Un widget est une fonction qui permet de tracer un « objet » graphique et de lui associer certaines
actions. Ces objets graphiques peuvent être du texte, des fenêtres graphiques, des boutons, des
menus, ... Quant aux actions associées, il peut s’agir de n’importe quelle commande IDL.
Les widgets permettent donc de construire des interfaces graphiques de programmes IDL, dont
les widgets sont les briques élémentaires.
Leur fonctionnement est cependant légèrement différent de celui des procédures et fonctions
standard IDL. IDL ne gère pas directement les widgets. Ce travail est effectué par l’intermédiaire
d’une procédure (XMANAGER), qui va gérer les interruptions et les événements générés par les
widgets pour les envoyer à une routine de traitement.
Le résultat d’un widget (car il s’agit d’une fonction) est un numéro d’identificateur.
b) Qu’est-ce qu’un « compound widget » ?
Un compound widget regroupe les actions de plusieurs widgets de telle façon que sa gestion
apparaisse aussi simple à l’utilisateur que celle d’un widget de base. Par exemple, l’une de ceux
fourni par IDL permet de construire un groupe de boutons aussi simplement que si on en créait un
seul.
2) Hiérarchie
La hiérarchie d’un widget est définie par sa décomposition en éléments horizontaux et verticaux.
Un widget est formé d’une base qui correspond au cadre extérieur de ce que l’on veut tracer.
IDL et ses widgets 4

Ensuite, on définit des sous-bases, en fonction des découpages horizontaux ou verticaux
complets dont on a besoin. La figure ci-dessous représente un widget dont la base est le cadre.
Il est structuré verticalement : un premier groupe formé de diverses fenêtres et de boutons, une
deuxième avec le texte ‘Info’ et une fenêtre de texte, et un troisième avec le bouton ‘Quitter’.
Le premier groupe est structuré horizontalement : un premier sous groupe est formé du label et du
bouton ainsi que du label et de la fenêtre ; le deuxième sous-groupe est constitué de boutons, et le
troisième sous-groupe d’une fenêtre graphique.
Le premier groupe est lui-même structuré verticalement, ainsi que le second.
Et on décompose ce que l’on veut obtenir ainsi de suite, jusqu’à ne plus avoir besoin de changer
de sens entre horizontal et vertical.
3) Les différents widgets
Le nombre de widgets qui existent est très limité. Il y en a 8 qui permettent de dessiner divers
objets. Un qui permet de définir les bases et sous-bases, un qui permet de modifier ou créer des
widgets définis par ailleurs, et deux qui jouent un rôle spécial.
Un certain nombre de « dialogues » ressemblent à des widgets, mais leur utilisation est différente.
Les principaux sont
res=dialog_pickfile() et
res=dialog_message(‘message à afficher’)
La distribution standard d’IDL contient enfin 13 compound widgets d’intérêt divers, ainsi qu’un
modèle (« template ») de compound widget destiné à faciliter la création d’une telle fonction.
Nous les verrons plus loin.
Les principaux widgets sont :
widget_base permet de créer une base principale et des sous bases
widget_button permet de créer un bouton
widget_draw permet de créer une fenêtre graphique
IDL et ses widgets 5

widget_droplist affiche l’élément par défaut d’une liste. Quand on clique
dessus, la liste complète apparaît, permettant une autre sélection qui
remplace la précédente
widget_label affiche un texte statique (un label)
widget_list affiche une fenêtre contenant une liste d’éléments que l’on peut
sélectionner individuellement. Si besoin est, un ascenseur l’accompagne
widget_slider affiche un curseur permettant de sélectionner une valeur entière entre deux
bornes
widget_table affiche des éléments sous forme d’un tableau
widget_text affiche une fenêtre contenant du texte, soit statique, soit modifiable
4) Les contrôles
La façon dont sont gérés les widgets, comme nous l’avons mentionné plus haut, ne ressemble pas
à ce à quoi on est habitué avec IDL.
Chaque widget retourne des « événements » (‘events’) qu’il va falloir gérer comme on va le voir.
Tout d’abord, une procédure contenant des widgets n’est pas composée de la même façon que les
procédures classiques, elle contient deux parties : l’une qui sert à composer, à l’aide de widgets,
l’interface graphique que l’on désire, et l’autre qui sert à interpréter en termes de commandes
IDL l’effet des événements renvoyés par les widgets.
Si le nom de la routine principale est ‘toto’, la routine de traitement des événements devra
s’appeler ‘toto_event’. On peut s’affranchir de cette contrainte, mais cela complique les choses.
L’interface graphique que l’on crée se construit à l’aide d’un widget spécial nommé
widget_control. Puis l’activation de cette interface se fait à l’aide de la procédure
xmanager qui va envoyer la main à un autre widget, widget_event, qui va permettre de
récupérer et de pré-traiter les événements générés par les widgets, avant de les renvoyer dans la
routine de traitement des événements. Cette avant-dernière routine, widget_event, est
totalement transparente à l’utilisateur (qui peut l’appeler directement s’il le désire, mais IDL ne le
recommande pas), car son nom n’apparaît nulle part de façon visible.
La procédure xmanager, appelée dans la procédure de création de l’interface, permet de gérer
plusieurs interfaces en même temps. Il s’agit en quelque sorte d’une routine de gestion des
interruptions (clic ou déplacement de souris, frappe de clavier).
Quand, à la suite d’un plantage, on veut reprendre la main pour tuer un widget qui reste dans un
état commateux, il faut taper :
xmanager
sans aucun argument.
La forme générale d’une procédure de création d’une interface par widget est la suivante :
pro nom_procédure_event,ev C’est la procédure de traitement des événements. ev
est un élément spécial (une structure caractéristique,
comme on le verra plus loin)
routine de traitement des événements
end
pro nom_procédure, arguments procédure de création de l’interface
IDL et ses widgets 6

construction de l’interface
widget_control,nom_de_base,/realize on construit l’interface
graphique
xmanager,’nom_procédure’,nom_de_base on active l’interface pour gérer les
interruptions
end
On remarquera que la routine de gestion des événements est placée dans le même fichier que la
routine de création des widgets, en première position. De plus, le nom du fichier doit être le nom
de la routine de création, suivi de l’extension .pro. Dans notre exemple, ce serait
nom_procédure.pro.
Tous les événements renvoyés par les widgets à la routine de traitement d’événements sont des
structures. Et toutes ces structures ont leurs trois premiers champs identiques.
La définition de la structure renvoyée par les widgets commence par :
ev = {id:0L,top:0L,handler:0L, ...}
Le premier élément de cette structure, ev.id, contient l’identificateur du widget, c’est-à-dire un
élément permettant de l’identifier. Le second, ev.top, contient l’identificateur du widget de
base de plus haut niveau contrôlant cette interface. Le troisième, ev.handler, contient
l’identificateur d’une éventuelle routine d’événements, comme nous le verrons plus loin. Pour
l’instant, seuls les deux premiers champs nous intéressent parmi ces trois champs communs à
tous les widgets.
En ce qui concerne xmanager, on peut lui adjoindre le mot-clé NO_BLOCK que l’on met à 1 afin
de permettre l’accès à d’autres routines, ou à la ligne de commande d’IDL :
xmanager,’nom_procédure_event’,/no_block
Du point de vue du programmeur, la gestion d’une routine contenant des widgets va se faire de la
façon suivante. Les widgets sont créés et activés dans la routine principale (via widget_control et
xmanager), et, à chaque fois que l’utilisateur intervient (en cliquant sur un widget, en entrant du
texte, ...), un événement est généré. Cet événement est intercepté par la routine de gestion des
événements. Nous verrons un peu plus loin la façon dont cette routine récupère les informations
et les gère.
III. Pratique simple
Chaque widget dispose d’un certain nombre d’arguments qui vont permettre de les caractériser au
mieux, et génère une structure (l’événement) qui lui est propre, contenant tous les renseignements
utiles à son traitement, en plus des 3 champs mentionnés plus haut. Rappelons que chaque widget
est une fonction qui renvoie le numéro d’identification du widget.
Les arguments et mots-clés indiqués ci-dessous suffisent à l’utilisation courante de la plupart des
widgets.
IDL et ses widgets 7

1) Les widgets, leurs arguments de base et les structures associées
a) widget_base
Sous sa forme : id = widget_base(), ce widget indique qu’il s’agit de la base de plus haut
niveau, c’est-à-dire le cadre général de l’interface. Si on a :
base=widget_base()
une sous-base de ‘base’ va s’écrire :
ss_base=widget_base(base)
Les mots-clés pouvant accompagner ce widget sont :
/column indique que les éléments dépendant de cette base s’agenceront en
colonne, les uns en dessous des autres
/exclusive indique que la base ne contient que des boutons, et qu’un seul d’entre eux
pourra être sélectionné
group_leader=id id contient l’identificateur d’un widget déjà créé qui, s’il est détruit,
entraînera la destruction de tous les widgets dont il est le ‘group_leader’
/nonexclusive indique que la base ne contient que des boutons, et que plusieurs d’entre
eux peuvent être sélectionnés simultanément
/row indique que les widgets dépendant de cette base s’agenceront en ligne,
c’est-à-dire les uns à côté des autres
/scroll indique que si la base dépasse la taille disponible, des ascenseurs au bord
permettront d’en faire défiler les différentes parties
title=chaÎne indique le titre de la base (valable seulement pour la base de plus haut
niveau)
uvalue=val permet de transférer une valeur que l’on pourra simplement récupérer
dans la routine de traitement des événements
Pour l’instant, seuls les 3 premiers champs de la structure d’événement généré sont utiles :
{widget_base, id:0L, top:0L, handler:0L}
b) widget_button
Ce widget contient comme argument obligatoire le nom de la base dans laquelle il se trouve.
Ses principaux mots-clés sont :
group_leader=id cf. widget_base
uvalue=‘texte’ le texte indiqué comme valeur d’utilisateur (user value), dont on verra
plus loin la grande utilité, peut être récupéré dans la routine de traitement
des événements, permettant ainsi de reconnaître facilement un widget
grâce à sa ‘uvalue’
value=‘texte’ le texte indiqué est celui qui s’affiche dans le bouton
units=val la valeur indiquée dans val indique le système d’unités utilisé : 0 =
pixels (valeur par défaut), 1 = inches, 2 = centimètres
xsize=val indique la dimension horizontale du bouton, dans l’unité précisée par
units
ysize=val indique la dimension verticale du bouton, dans l’unité précisée par units
IDL et ses widgets 8

Structure générée par ce widget :
{widget_button, id:0L, top:0L, handler:0L, select:0}
ev.select vaut 1 si le bouton est appuyé.
c) widget_draw
Ce widget contient comme argument obligatoire le nom de la base dans laquelle il se trouve.
Ses principaux mots-clés sont :
group_leader=id cf widget_base
/scroll permet d’ajouter des ascenseurs si le contenu de la fenêtre est plus grand
qu’elle
units=val cf widget_button
uvalue=‘texte’ cf widget_button
value=var var est une variable qui contiendra le numéro de la fenêtre graphique
ainsi ouverte. Cela permet, si plusieurs fenêtres graphiques sont ouvertes,
de choisir celle que l’on veut avec wset,var
xsize=val cf widget_button
ysize=val cf widget_button
Structure générée par ce widget :
{widget_draw, id:0L, top:0L, handler:0L,type:0, x:0, y:0,
press:0B, release:0B, clicks:0}
Les différents champs se rapportent à des mots-clés que nous n’avons pas encore vus. ils seront
explicités plus loin.
d) widget_droplist
Ce widget contient comme argument obligatoire le nom de la base dans laquelle il se trouve.
Ses principaux mots-clés sont :
group_leader=id cf widget_base
title=‘texte’ permet d’ajouter un titre à la liste déroulante
units=val cf widget_button
uvalue=val cf widget_button
value=str str contient une ‘string’ ou ‘strarr’ contenant les éléments de la liste
xsize=val cf widget_button
Structure générée par ce widget :
{widget_droplist, id:0L, top:0L, handler:0L, index:0L}
index contient l’indice de l’élément de la liste qui a été sélectionné.
e) widget_label
Ce widget contient comme argument obligatoire le nom de la base dans laquelle il se trouve.
Ses principaux mots-clés sont :
group_leader=id cf widget_base
units=val cf widget_button
IDL et ses widgets 9

value=‘texte’ contient le texte du label à afficher
xsize=val cf widget_button
ysize=val cf widget_button
Aucune structure n’est générée par ce widget.
f) widget_list
Ce widget contient comme argument obligatoire le nom de la base dans laquelle il se trouve.
Ses principaux mots-clés sont :
group_leader=id cf widget_base
/multiple permet de sélectionner plusieurs éléments de la liste
units=val cf widget_button
uvalue=‘texte’ cf widget_button
value=tab contient le tableau de strings formant la liste
xsize=val cf widget_button
ysize=val cf widget_button
Structure générée par ce widget :
{widget_list, id:0L, top:0L, handler:0L,index:0L, clicks:0L}
index contient le numéro de l’élément qui a été sélectionné.
clicks vaut 1 si on a cliqué une fois sur l’élément, 2 s’il s’est agi d’un double clic.
g) widget_slider
Ce widget contient comme argument obligatoire le nom de la base dans laquelle il se trouve.
Ses principaux mots-clés sont :
/drag génère continuement des événements quand on déplace le curseur
group_leader=id cf widget_base
maximum=val valeur maximum du curseur en entiers (défaut = 100)
minimum=val valeur minimum du curseur en entiers (défaut = 0)
title=‘texte’ titre à afficher
units=val cf widget_button
uvalue=‘texte’ cf widget_button
value=val valeur initiale à laquelle se trouve le curseur
/vertical crée un curseur vertical
xsize=val cf widget_button
ysize=val cf widget_button
Structure générée par ce widget :
{widget_slider, id:0L, top:0L, handler:0L, value:0L, drag:0}
value contient la nouvelle valeur du curseur
On peut mettre le champ drag à 0, quand on a utilisé /drag afin que les événements ne soient
générés que quand on relâche le curseur.
IDL et ses widgets 10

h) widget_table
Ce widget contient comme argument obligatoire le nom de la base dans laquelle il se trouve.
Ses principaux mots-clés sont :
column_labels=‘texte’ permet d’entrer des titres de colonnes (string ou strarr)
column_widths=val définit la largeur des colonnes (scalaire ou tableau)
group_leader=id cf widget_base
/no_headers ne met pas d’en-têtes aux lignes et colonnes
row_heights=val définit la hauteur des lignes (scalaire ou tableau)
row_labels=‘string’ permet d’entrer des titres de lignes (string ou strarr)
/scroll permet d’afficher un ascenseur pour faire défiler la partie de la table qui
est hors de la vue
units=val cf widget_button
uvalue=‘texte’ cf widget_button
value=tab tableau de valeurs destiné à emplir la table
xsize=val cf widget_button
ysize=val cf widget_button
/all_events et /editable cf tableau ci-dessous pour les combinaisons de ces
deux mots-clés
Mot-clé Effet
all_events editable Une entrée change-telle
le contenu du
IDL et ses widgets 11
widget ?
Type d’action
générant des
événements
0 0 Non Aucun
0 1 Oui Insertion d’une fin de
ligne (carriage return)
1 0 Non Tous les événements
1 1 Oui Tous les événements
Structure générée par ce widget :
{widget_table, id:0L, top:0L, handler:0L, type= 0, ...}
Le champ type indique le type de structure renvoyé à l’utilisateur. Cela n’étant pas utile pour
l’instant, nous en parlerons plus loin.
i) widget_text
Ce widget contient comme argument obligatoire le nom de la base dans laquelle il se trouve.
Ses principaux mots-clés sont :
group_leader=id cf widget_base
/scroll cf widget_draw
units=val cf widget_button
uvalue=‘texte’ cf widget_button
value=string texte contenu dans le widget
/wrap coupe automatiquement les lignes trop longues

xsize=val cf widget_button
ysize=val cf widget_button
/all_events et /editable cf tableau ci-dessous pour les combinaisons de ces
deux mots-clés
Mot-clé Effet
all_events editable Une entrée change-t- Type d’action
elle le contenu du générant des
widget ?
événements
0 0 Non Aucun
0 1 Oui Insertion d’une fin de
ligne (carriage return)
1 0 Non Tous les événements
1 1 Oui Tous les événements
Structure générée par ce widget :
{widget_list, id:0L, top:0L, handler:0L, type:0, ...}
Le champ type indique le type de structure renvoyé. Nous verrons plus loin les autres champs.
2) Routine de traitement des événements
a) Widget_control
widget_control est un widget spécial comparé aux autres. Tout d’abord, il s’agit d’une
procédure, et non pas d’une fonction. Son rôle est de réaliser, gérer et détruire les widgets. Il
s’applique à un identificateur de widget :
widget_control,id
suit alors un mot-clé qui va définir les actions de modification du widget dont l’id est indiqué.
Ces mots clés vont permettre de changer la valeur des mots-clés utilisés lors de la création du
widget.
Les formes de base de widget_control sont :
widget_control,id,/realize construit toute la hiérarchie de widget dont id est
l’élément le plus haut
widget_control,id,/destroy détruit toute la hiérarchie de widget dont id est
l’élément le plus haut
Les principaux mots-clés pouvant accompagner widget_control sont :
all_table_events, ainsi que all_text_events, conjointement avec editable
modifient le type de génération d’événements de widget_table et widget_text suivant
les tables indiquées plus haut dans la description de ces widgets.
/append utilisé avec set_value (voir plus loin), permet d’ajouter le texte
courant (défini par set_value) au texte que contient déjà un
widget_text
column_labels=‘texte’ permet de changer les titres de colonnes dans un
widget_table
IDL et ses widgets 12

column_width=val permet de changer les largeurs de colonnes dans un
widget_table
edit_cell=[x,y] rend éditable la colonne x, ligne y d’une table d’un
widget_table
get_uvalue=var met dans la variable var le contenu de la ‘user value’ uvalue du
widget impliqué
get_value=var met dans la variable var le contenu défini par le mot-clé value du
widget impliqué (voir pour chaque widget le contenu de value)
group_leader=id permet de rattacher le widget courant à une hiérarchie (ainsi, un
même widget peut être rattaché à plusieurs hiérarchies, mais on ne
peut pas le retirer d’une hiérarchie)
/hourglass affiche une petite montre indiquant que la machine travaille, jusqu’à
ce qu’un nouvel événement soit généré. Utile par exemple quand on
charge un gros fichier de données, pour que l’utilisateur ne croie
pas la machine ‘plantée’
/iconify transforme en icône le widget courant et toute sa hiérarchie
(iconify=0 le réagrandit)
map=0 fait disparaître le widget de l’écran, mais il existe toujours. Pour le
faire réapparaître, mettre /map
row_labels=‘texte’ permet de changer les titres de lignes d’un widget_table
row_heights=val permet de changer la hauteur des lignes d’un widget_table
sensitive=0 rend ‘insensible’ un widget et sa hiérarchie descendante. Pour le
rendre à nouveau sensible, faire /sensitive
set_button=val si val = 0, désélectionne le bouton, sinon, le sélectionne (peut
dépendre des mots-clés exclusive et non_exclusive de
widget_base)
set_text_top_line=val affiche le texte d’un widget_text en commençant par la
ligne val
set_uvalue=‘texte’ change la valeur de uvalue (user value)
set_value=val change le contenu de value du widget impliqué
tlb_set_title=‘texte’ change le titre de la base la plus haute de la hiérarchie
units=val change le type d’unités choisi pour le widget courant
xsize=val change la taille horizontale du widget
ysize=val change la taille verticale du widget
b) La gestion des événements
La gestion des événements va se faire, comme on l'a vu, dans la routine qui va se trouver en tête
de fichier, du type :
pro nom_de_procédure_event,ev
ev est l'événement engendré par le widget qui a réagi ; et c'est grâce à la procédure
widget_control que nous allons pouvoir savoir ce qui s'est passé.
IDL et ses widgets 13

Le champ ev.id de la structure ev nous donne l’identificateur du widget qui a réagi. Ainsi, on
peut en extraire des informations. L’une des plus utiles que l’on peut espérer récupérer est la
valeur utilisateur du widget, uvalue. Cela se fait de la façon suivante, où var est une variable
quelconque :
widget_control,ev.id,get_uvalue=var
Si on a pris soin de donner une valeur utilisateur explicite et différente pour chaque widget
utilisé, la lecture de celle-ci nous indique immédiatement quel widget a été sollicité.
Ainsi, en testant cette valeur (grâce à CASE, particulièrement), on peut diriger la gestion des
événements vers telle ou telle partie du programme qui effectuera la tâche assignée au widget.
3) Transfert d’arguments
Il est souvent utile de transférer des arguments (ie des variables) entre la procédure qui crée les
widgets, et celle qui gère les événements, ou entre des appels successifs à la routine de gestion
des événements. Ces arguments peuvent être classiquement un numéro de fenêtre associé à
widget_draw, l’identificateur d’un widget dont le contenu peut être modifié en cours de
programme (comme une fenêtre de texte de widget_text, par exemple), ou même des
variables (comme quand on a chargé une image et que l’on veut pouvoir en faire une coupe…).
Le problème est qu’après la création de l’interface, la main est passée à xmanager qui gère la
queue des événements, puis à widget_event qui « conditionne » les événements pour aboutir
enfin à la routine de gestion des événements, et que ce cycle est permanent entre ces trois
dernières routines. Le transfert d’arguments ou de variables n’est donc pas possible de façon
directe.
Deux solutions existent.
• La première, la plus simple à mettre en œuvre, mais moins « propre » et plus lourde, consiste à
utiliser un common qui va se trouver à la fois dans la routine de création et dans la routine de
gestion des événements. On y met toutes les variables utiles. Avantage, on a directement sous les
yeux ces variables. Inconvénient, un common qui a été compilé ne peut plus être modifié, ou
alors, il faut quitter IDL, le relancer, modifier le contenu du common, et re-compiler le
programme.
• L’autre solution consiste à utiliser une valeur utilisateur pour transmettre une structure
contenant toutes les variables utiles. Comme on l’a vu au début de cette section, les valeurs
utilisateur peuvent être utilisées pour identifier les widgets. En ce cas, rien n’empêche d’utiliser
la valeur utilisateur de la base principale. Ou, si celle-ci est déjà utilisée (quand plusieurs
interfaces simultanées sont affichées), créer une sous-base de la base principale à laquelle sera
rattachée toute la hiérarchie :
base=widget_base()
child=widget_base(base,uval=ma_structure)
...
Ainsi, grâce à widget_control, il est possible de récupérer la structure en question.
IDL et ses widgets 14

4) Un exemple simple
Pour commencer, nous allons étudier un exemple simple de création de widget. Le but est
d’entrer un texte court dans une petite fenêtre. S’il nous convient, on l’ajoute dans une plus
grande fenêtre au texte existant, sinon, on l’efface et rien ne se passe. On peut de plus, bien sûr,
quitter l’application. L’image ci-dessous montre l’aspect de ce que l’on souhaite obtenir :
La petite fenêtre du haut permet d’entrer le texte (avec un label au-dessus), puis les trois boutons,
permettant (de gauche à droite respectivement) de valider l’entrée, de l’annuler, et de quitter le
logiciel. Enfin, le label ‘Affichage’ surmonte la fenêtre où l’ensemble des textes entrés va
s’afficher.
On remarque que la structure principale de ce widget est en colonne (les éléments sont les uns au
dessus des autres), mais que les boutons ont une structure en ligne.
Voici le listing de cette interface (une procédure appelée exo1.pro), la routine de gestion des
événements précède la procédure de création de l’interface, comme expliqué plus haut :
pro w_exo1_event,ev Routine de traitement des événements
common ex1,txt,wintxt,txt2,txt1 On récupère les valeurs utiles grâce au common
widget_control,ev.id,get_uvalue=uval On récupère la valeur utilisateur du widget qui a réagi
case uval of On teste cette valeur
'u_txt1':
widget_control,ev.id,get_value=txt
IDL et ses widgets 15
S’il s’agit de la petite fenêtre de texte, le texte entré
s’accumule lettre après lettre (à cause du mot-clé
/all_events utilisé à la création) dans la variable txt
'u_bu_ok': begin S’il s’agit du bouton OK :
wintxt=wintxt+txt On rajoute au texte contenu dans la grande fenêtre le
contenu de txt
txt='' On remet txt à zéro pour la suite
widget_control,txt1,set_value=txt On efface le contenu de la petite fenêtre de texte
widget_control,txt2,set_value=wintxt On affiche le nouveau texte de la grande fenêtre
end
'u_bu_eff': begin S’il s’agit du bouton Effacer :
txt='' On vide la variable txt
widget_control,txt1,set_value=txt On efface la petite fenêtre de texte
end

'u_bu_quit':
widget_control,ev.top,/destroy
S’il s’agit du bouton Quitter, on détruit le widget
endcase Fin du test sur la valeur de uval
end Fin de la routine de traitement des événements
pro w_exo1 Début de la routine de création de l’interface
common ex1,txt,wintxt,txt2,txt1 Définition du common contenant toutes les valeurs
qu’il est utile de transférer dans la routine de
traitement des événements
txt='' On initialise à vide le texte de la petite fenêtre de texte
wintxt='' On initialise à vide le texte de la grande fenêtre de
texte
base=widget_base(/column) On crée la base générale, ses “enfants“ seront en une
colonne (les uns en dessous des autres)
lbl1=widget_label(base,value='Entrez un On affiche le label du haut
texte')
txt1=widget_text(base,value='',uvalue= $ On crée la petite fenêtre de texte, vide, en lui donnant
'u_txt1',xsize=40,ysize=1, $ une dimension fixe (en nombre de caractères), en lui
/editable,/all_events)
donnant une valeur utilisateur, éditable, et réagissant à
chaque entrée de caractère (afin d’éviter d’attendre
que la touche ‘Return’ ou ‘Entrée’ soit utilisée)
b1=widget_base(base,/row) On crée une sous-base en ligne pour les boutons
bu_ok=widget_button(b1,value='OK',uvalue Création du 1
='u_bu_ok')
er bouton avec son contenu et sa valeur
utilisateur associée
bu_eff=widget_button(b1,value='Effacer',
uvalue='u_bu_eff')
Création du 2ème bouton
bu_quit=widget_button(b1,value='Quitter'
,uvalue='u_bu_quit')
Création du 3ème bouton
lbl2=widget_label(base,value='Affichage'
)
txt2=widget_text(base,value='',xsize=20,
ysize=5,/wrap,/scroll)
IDL et ses widgets 16
Création du label de la grande fenêtre de texte
Création de la grande fenêtre de texte (20 caractères
sur 5 lignes), en demandant que les lignes soient
automatiquement coupées entre les mots, et qu’un
ascenseur apparaisse si le texte dépasse les 5 lignes
widget_control,base,/realize On construit le widget d’ensemble
xmanager,'w_exo1',base On passe la main pour la gestion des événements
end
On vient de voir une façon de concevoir ce programme en utilisant le common. Voici
maintenant, ci-dessous, rigoureusement le même programme, mais utilisant cette fois-ci le
transfert d’une structure en uvalue de la base principale :
pro w_exo1_1_event,ev Routine de gestion des événements
widget_control,ev.id,get_uvalue=uval On récupère la uvalue du widget qui a réagi
widget_control,ev.top,get_uvalue=struc On récupère la structure mise en uvalue de la base

IDL et ses widgets 17
principale
case uval of Test sur uval
'u_txt1': begin Petite fenêtre de texte :
widget_control,ev.id,get_value=txt On récupère son contenu
struc.txt=txt On le met dans la structure
widget_control,ev.top,set_uvalue= $ On met la structure corrigée dans uvalue de la base
struc
end
principale
'u_bu_ok': begin Bouton OK :
struc.wintxt=struc.wintxt+struc.txt On ajoute au champ de la structure contenant le texte
de la grande fenêtre le contenu du champ de la
structure contenant le texte de la petite fenêtre
struc.txt='' On met le champ contenant le texte de la petite
fenêtre à vide
widget_control,struc.txt1, $ On met dans le widget de la petite fenêtre (dont l’ID
set_value=struc.txt
est dans struc.txt1) la chaîne vide
widget_control,struc.txt2, $ On affiche la nouvelle chaîne de la grande fenêtre
set_value=struc.wintxt
(dont l’ID est dans struc.txt2)
widget_control,ev.top,set_uvalue= $ On sauvegarde la nouvelle valeur de la structure
struc
end
'u_bu_eff': begin Bouton Effacer :
struc.txt='' On met le champ txt à vide (contenu de la petite
fenêtre)
widget_control,struc.txt1, $ On remplace le texte de la petite fenêtre (dont l’ID est
set_value=struc.txt
dans struc.txt1) par le contenu vide de struc.txt
widget_control,ev.top,set_uvalue= $ On sauvegarde la nouvelle valeur de la structure
struc
end
'u_bu_quit': $
widget_control,ev.top,/destroy
endcase Fin du test du uval
end
Bouton Quitter : on détruit le widget
pro w_exo1_1 Routine de création de l’interface
struc={txt:'',wintxt:'',txt2:0L,txt1:0L} Définition de la structure contenant tous les éléments
utiles
base=widget_base(/column,uval=struc) On définit la base (par colonne) avec la structure
comme uvalue
lbl1=widget_label(base,value= $
Création du label du haut
'Entrez un texte')
txt1=widget_text(base,value='',uvalue= $ Création de la petite fenêtre de texte
'u_txt1',xsize=40,ysize=1, $
/editable,/all_events)
b1=widget_base(base,/row) Création de la sous-base (en ligne) pour les boutons
bu_ok=widget_button(b1,value='OK', $ Création du bouton ‘OK’

uvalue='u_bu_ok')
bu_eff=widget_button(b1,value= $
'Effacer', uvalue='u_bu_eff')
bu_quit=widget_button(b1,value= $
'Quitter',uvalue='u_bu_quit')
lbl2=widget_label(base,value= $
'Affichage')
txt2=widget_text(base,value='', $
xsize=20,ysize=5,/wrap,/scroll)
IDL et ses widgets 18
Création du bouton ‘Effacer’
Création du bouton ‘Quitter’
Création du second label
Création de la grande fenêtre de texte
widget_control,base,/realize Réalisation de l’interface (et donc assignation d’ID à
chaque widget)
struc.txt2=txt2 L’ID de la grande fenêtre de texte va dans
struc.txt2
struc.txt1=txt1 L’ID de la petite fenêtre de texte va dans
struc.txt1
widget_control,base,set_uvalue=struc La structure mise à jour est sauvée dans la uvalue
de la base principale
xmanager,'w_exo1_1',base On passe la main pour la gestion des événements
end
IV. Un peu de complexité
Nous allons maintenant voir quelques autres possibilités liées aux widgets et à leur création. Nous
ne les verrons pas toutes, bien sûr, car avant de pouvoir utiliser toutes les options possibles, il est
indispensable d’être déjà bien familiarisé avec l’utilisation standard des widgets.
1) Arguments complexes des widgets
Nous allons examiner quelques mots clés supplémentaires (et quelques alternatives à certains que
l’on a déjà vus).
a) Mots clés communs à la plupart des widgets
/no_copy Ce mot clé est l'équivalent de la fonction IDL
temporary. C'est-à-dire qu'il permet de ne pas
recopier les valeurs de value, mais de les transférer
directement, économisant ainsi de la mémoire
frame=val Donne l'épaisseur du cadre. Attention, la valeur que l'on
donne se réfère au choix d'unité précisé par unit
event_function='nom_fonction' Envoie directement l'événement généré dans la
fonction indiquée. Si cette fonction retourne une
structure dont les 3 premiers champs sont ID, TOP et
HANDLER, ce résultat est envoyé comme événement à
la routine de traitement des événements. Sinon, la main
revient à xmanager. Permet donc d'intervenir avant
d'effectuer le traitement (c'est la méthode utilisée,
comme on le verra plus loin, pour créer des compound
widgets)

event_pro='nom_procédure' Envoie directement l'événement généré dans la
procédure indiquée avant de rendre la main à
xmanager. Permet par exemple d'associer un bouton à
la création d'une nouvelle interface
func_get_value='nom_fonction' Quand on lance la commande
widget_control,id,get_value= ..., la
fonction indiquée s'exécute avant de renvoyer le résultat
comme valeur
pro_set_value='nom_procédure' Quand on lance la commande
widget_control,id,set_value=..., la
procédure indiquée s'exécute, ce qui permet de mettre
dans value un nouveau résultat
b) Widget_base
/align_bottom
/align_top
/align_center
/align_left
/align_right
/base_align_bottom
/base_align_top
/base_align_center
/base_align_left
/base_align_right
mbar=var
app_mbar=var
IDL et ses widgets 19
Ces cinq mots clés permettent de
définir l'alignement de la base en cours
par rapport à son parent. Les 3 premiers
s'appliquent quand le mot clé /row du
parent est mis, les 3 derniers quand le
mot clé /column a été mis
Identique à la série précédente, mais
s'appliquent aux 'enfants' de la base en
cours
Ne fonctionne que sur la base de plus
haut niveau. Permet de mettre un menu
sur cette base. app_mbar permet sur
Macintosh de remplacer la barre de
menu système. Voir dans la section
suivante, widget_button, son
fonctionnement. Incompatible avec
/modal
/floating Associé à group_leader=id : permet de créer une
base de plus haut niveau flottante, liée au
group_leader indiqué
map=0 ou 1 map=0 rend la base et ses enfants invisible ; map=1 la
rend visible. Incompatible avec /modal
/modal Permet de créer une base qui contiendra un dialogue
avec des boutons ; associée à un group_leader. Les
boutons pourront être l'acceptation ou l'annulation de ce
qui a été fait dans ce nouveau widget. Une base 'modale'
bloque tous les autres widgets tant qu'elle n'a pas été
détruite

tlb_frame_attr=val Définit les actions possibles sur la base :
1 : ne peut être redimensionnée
2 : supprime l'affichage du menu du système
4 : supprime la barre de titre (sauf sur Mac)
8 : ne peut être fermée
16 : ne peut être déplacée
On peut combiner ces actions en ajoutant les valeurs
indiquées les unes aux autres
c) Widget_button
/align_center
/align_left
/align_right
IDL et ses widgets 20
Définit le type de justification du texte qui se
trouve dans le bouton (défaut =
/align_center)
/separator Affiche un séparateur dans un menu déroulant
value=tab tab est un tableau à deux dimensions, qui est une
image bitmap. En ce cas, le texte du bouton est
remplacé par l'image formée par tab
/menu indique que le bouton en question est le titre d'un menu
déroulant. Lié aux mots clés mbar et app_mbar de
widget_base. Exemple :
base=widget_base(mbar=bar)
menu1=widget_button(bar,value='Menu1',/menu
)
but1=widget_button(menu1,value='Un')
but2=widget_button(menu1,value='Deux')
d) Widget_draw
/motion_events Envoie des événements quand la souris se déplace sur la
fenêtre graphique. Cela crée une structure de la forme :
{widget_draw, id:0L, top:0L,
handler:0L, type:0, x:0, y:0,
press:0B, release:0B, clicks:0}
type = 0 : bouton appuyé, 1 : bouton relâché, 2 :
mouvement, 3 : scrolling, 4 : changement de visibilité.
x et y donnent la position en coordonnées de la fenêtre.
clicks =1 si simple clic, =2 si double clic
/button_events Génère des événements quand le bouton de la souris est
cliqué sur la fenêtre graphique.
e) widget_label
/align_center
/align_left
/align_right
Définit le type de justification pour le label

f) widget_table
Suivant le type d'action qui a lieu avec ce widget (dont les possibilités sont définies par
/all_events et /editable), la structure renvoyée est différente. On a vu que le champ
ev.type détermine la structure. Nous allons voir quelques-unes de ces structures, les autres
sont à regarder dans la partie widget_table de IDL Reference Guide (tome 2) :
• Type = 0 : Insertion d'un caractère
{widget_table_ch, id:0L, top:0L, handler:0L, type:0, offset:0L,
ch:0B, x:0L, y:0L}
offset = position (de 0 à n) du caractère inséré ; ch est sa valeur ASCII, x et y sont les
numéros de colonne et de ligne de la cellule où l'insertion a lieu.
• Type = 1 : Collé de plusieurs caractères
{widget_table_str, id:0L, top:0L, handler:0L, type:1, offset:0L,
str='', x:0L, y:0L}
offset, x et y : même signification que ci-dessus. str = chaîne inserrée.
• Type = 2 : Effacement de texte
{widget_table_del, id:0L, top:0L, handler:0L, type:2, offset:0L,
length:0L,x:0L, y:0L}
offset, x, y : idem. Length = nombre de caractères impliqués dans l'effacement.
• Type = 3 : Sélection de texte
{widget_table_ch, id:0L, top:0L, handler:0L, type:3,
offset:0L,length:0L,x:0L, y:0L}
Mêmes significations que ci-dessus
• Type = 4 : Sélection de cellule
{widget_table_ch, id:0L, top:0L, handler:0L, type:4, sel_left:0L,
sel_top:0L, sel_right:0L, sel_bottom:0L}
sel_left, ... donnent les numéros de cellules (de 0 à n) extrêmes sélectionnées.
• Type = 6 : Changement de hauteur de ligne.
• Type = 7 : Changement de largeur de colonne.
• Type = 8 : erreur dans le format de données entré par l'utilisateur.
g) widget_text
/no_newline Empêche l'insertion automatique d'un retour chariot à la
fin de chaque ligne quand le texte est sur plusieurs
lignes
Suivant le type d'action qui a lieu avec ce widget (dont les possibilités sont définies par
/all_events et /editable), la structure renvoyée est différente. On a vu que le champ
ev.type détermine la structure :
• Type = 0 : Insertion d'un caractère
{widget_text_ch, id:0L, top:0L, handler:0L, type:0, offset:0L,
ch:0B}
offset est la position d'insertion (de 0 à n) du caractère, dont le code ASCII est dans ch.
• Type = 1 : Insertion de plusieurs caractères
IDL et ses widgets 21

{widget_text_ch, id:0L, top:0L, handler:0L, type:1, offset:0L,
str=''}
offset = position d'insertion. str= chaîne à insérer
• Type = 2 : Effacement de texte
{widget_text_ch, id:0L, top:0L, handler:0L, type:2, offset:0L,
length:0L}
offset = position (de 0 à n) du 1 er caractère à effacer. Length = nombre de caractères effacés.
• Type = 3 : Sélection de texte
{widget_text_ch, id:0L, top:0L, handler:0L, type:3, offset:0L,
length:0L}
offset = position du 1 er caractère à sélectionner. Length = nombre de caractères sélectionnés.
2) Les compound widgets
Les compound widgets (appelés ci-après CW) sont des programmes ayant l'apparence d'un
widget, mais regroupant en réalité plusieurs widgets.
Leur utilisation est semblable à celle des widgets standards, et ils envoient des événements dont
la structure est semblable à celle des widgets (c'est-à-dire que les trois premiers champs sont id,
top et handler).
Les CW sont basés sur l'utilisation de fonction d'interception des événements générés pour les
traiter et les décomposer avant de renvoyer l'information utile à l'utilisateur.
Leur nom commence toujours par cw_ et on trouvera toute l'information les concernant dans IDL
Reference Guide (tome 1), à la rubrique de leur nom.
Un utilisateur confirmé des widgets pourra se mettre à créer lui-même des CW au gré de ses
besoins. L'idée présidant à leur conception est qu'ils forment des regroupements utiles de widgets
que l'on peut utiliser dans des routines différentes comme s'il s'agissait de simple widgets.
Voici un bref descriptif des principaux CW.
a) cw_bgroup
Ce CW permet de créer un groupe de boutons d'une seule commande. Sa forme d'appel est :
id = cw_bgroup(parent, noms)
où parent est l'ID du parent de ce CW, et noms est un tableau chaîne de caractères contenant
le nom de chaque bouton. Nous verrons dans la section 3) ci-dessous un exemple d'utilisation de
ce CW.
L'événement ev retourné par ce CW renvoie entre autres le champ value qui donne, suivant le
mot-clé associé lors de la création, l'indice du bouton, son ID, son nom, ou la valeur utilisateur
correspondante.
Les principaux mots-clés qui lui sont associés sont :
button_uvalue=string_array Tableau contenant les uvalue de chaque bouton. Ce
mot-clé l'emporte toujours sur les mots-clés de la forme
/return_xxx
/column met les boutons en colonne
/exclusive identique à widget_base
label_left=txt met un label à gauche du bouton
label_top=txt met un label au dessus du bouton
/nonexclusive identique à widget_base
IDL et ses widgets 22

eturn_id renvoie dans le champ value l'ID du bouton
sélectionné
/return_index renvoie dans le champ value l'indice du bouton
sélectionné
/return_name renvoie dans le champ value le nom du bouton
sélectionné
/row met les boutons en ligne
/scroll permet d'afficher un ascenseur pour faire apparaître les
boutons hors cadre
b) cw_defroi
Ce CW permet de définir une région d'intérêt (id de la délimiter) sur une image. Il est modal, ce
qui signifie qu'il bloque les autres widgets. Son utilisation se fait sous la forme :
res=cw_defroi(draw)
où draw est l'id du widget_draw où l'on délimite la région. res est un tableau d'indices
définissant la région. On peut ainsi créer un nouveau tableau formé uniquement de la région
choisie par :
new_tab = old_tab(res)
Le widget_draw utilisé doit être accompagné des mots-clés /motion_events et
/button_events.
c) cw_field
Permet de créer un ensemble formé d'un label plus un champ d'entrée de valeur (texte par défaut)
:
id=cw_field(parent)
Notez que chaque interrogation widget_control, id, get_value=x renvoie le contenu
du champ.
Les principaux mots-clés pouvant lui être associés sont :
/all_events génère un événement à chaque changement du contenu
/return_events génère un événement à chaque retour chariot
/column centre le label au-dessus du champ
/floating convertit automatiquement l'entrée en réel
/integer convertit automatiquement l'entrée en entier
/long convertit automatiquement l'entrée en entier long
/string convertit automatiquement l'entrée en chaîne
/noedit rend le champ non éditable
/row met le label à gauche du champ (= défaut)
title=str label (défaut = "Input Field")
uvalue=str valeur utilisateur
value=val contenu initial du champ (automatiquement converti
suivant le type choisi)
L'événement engendré par cw_field a la forme :
ev={id:0L, top:0L, handler:0L, value:'', type:0, update:0}
IDL et ses widgets 23

value contient le contenu du champ. Type indique le type d'entrée (0 = string, 1 = float, 2 =
interger, 3 = long integer) ; et update vaut 0 si rien n'a été modifié, 1 sinon.
d) cw_form
Ce CW permet de créer des formulaires (mélange de texte, champs numériques, boutons, listes et
listes déroulantes). Son utilisation est relativement complexe suivant ce que l'on désire faire. Se
reporter à IDL Reference Guide tome 1 pour plus d'informations.
e) cw_fslider
Crée un curseur permettant de choisir des valeurs réelles :
id=cw_fslider(parent)
Son utilisation est semblable à celle de widget_slider. Ses principaux mots-clés sont :
/drag cf widget_slider
/edit rend éditable le label du curseur
Maximum = val cf widget_slider
Minimum = val cf widget_slider
Title=str Label du curseur
uvalue=str valeur utilisateur
/vertical cf widget_slider
value=val position initiale du curseur
Le champ ev.value du l'événement engendré renvoie la valeur réelle choisie à l'aide du
curseur.
f) cw_pdmenu
Permet de créer un menu déroulant. ev.value renvoie l'indice du bouton sélectionné, son ID,
son nom ou son nom complet, suivant le mot-clé associé à ce CW.
id = cw_pdmenu(parent,desc)
desc est un tableau chaîne de caractère qui va décrire le menu déroulant. Chacun de ses
éléments s'écrit sous la forme :
'flag\item_name' (attention, il s'agit d'un backslash)
item_name est l'intitulé du bouton.
flag = 0 Le bouton n'est ni le début ni la fin d'un niveau déroulant
flag = 1 Le bouton est la racine d'un sous menu déroulant (le sous-menu commence avec le
bouton suivant)
flag = 2 Le bouton est le dernier du sous-menu déroulant actuel
flag = 3 Le bouton est le dernier du sous-menu déroulant actuel, mais c'est aussi la racine
d'un sous-menu déroulant.
Exemple :
IDL et ses widgets 24

Desc=['1\Titre','0\zéro', $
'1\un>','0\aa', $
'0\bb','3\cc','0\0',
$
'2\1','2\deux']
Les principaux mots-clés associés sont :
/mbar Crée le menu déroulant sur la barre de menu. Le parent
doit être la barre de menu de la base la plus haute
/return_id renvoie dans ev.value l'ID du bouton sélectionné
/return_index renvoie dans ev.value l'indice du bouton sélectionné
/return_name renvoie dans ev.value le nom du bouton sélectionné
(cc> par exemple)
/return_full_name renvoie dans ev.value le nom complet du bouton
sélectionné (par exemple, pour le bouton '1',
ev.value='Titre.un>.cc.1'). Chaque niveau
de menu est séparé du précédent par un point.
D'autres formes d'utilisation de cd CW existent. Consulter IDL Reference Guide, tome 1 pour
plus d'informations.
g) cw_zoom
Affiche deux images : l'originale, et une portion zoomée de celle-ci dans une autre fenêtre.
id = cw_zoom(parent)
L'image se charge par :
Widget_control,id,set_value=data
Les principaux mots-clés l'accompagnant sont :
max=val Valeur maximum de zoom (déf = 20), ≥ 1
min=val Valeur minimum de zoom (déf = 1) ≥ 1
sample=val Type d'échantillonnage. Défaut = 0 (bilinéaire) ; ≠ 0
pour une interpolation avec le voisin le plus proche
scale=val valeur entière de facteur d'échelle initial pour le zoom
(défaut = 4) ≥ 1
xsize=val et ysize=val Taille en pixels de la fenêtre initiale (défaut = 500x500)
x_zsize=val et y_zsize=val Taille en pixels de la fenêtre de zoom (défaut =
250x250)
Pour récupérer l'image zoomée, il faut faire :
widget_control,id,get_value=tab
L'événement engendré par cw_zoom a l'aspect suivant :
ev={zoom_event,id:0L, top:0L, handler:0L, xsize:0L, ysize:0L,
x0:0L, y0:0L, x1:0L, y1:0L}
xsize et ysize sont les dimensions de l'image zoomée ; x0 et y0 sont les coordonnées du
coin inférieur gauche où commence le zoom ; et x1, y1 du coin supérieur droit.
IDL et ses widgets 25

3) Reprise de l'exemple du début avec un compound widget
Voici ci-dessous l'exemple de widget présenté dans le III 4). La série de boutons est ici créée par
le compound widget cw_bgroup.
pro w_exo1_2_event,ev
widget_control,ev.id,get_uvalue=uval
widget_control,ev.top,get_uvalue=struc
case uval of
'u_txt1': begin
widget_control,ev.id,get_value=txt
struc.txt=txt
widget_control,ev.top,set_uvalue=struc
end
'u_butt': begin
val=ev.value
case val of
'u_bu_ok': begin
struc.wintxt=struc.wintxt+struc.txt
struc.txt=''
widget_control,struc.txt1,set_value=struc.txt
widget_control,struc.txt2,set_value=struc.wintxt
widget_control,ev.top,set_uvalue=struc
end
'u_bu_eff': begin
struc.txt=''
widget_control,struc.txt1,set_value=struc.txt
widget_control,ev.top,set_uvalue=struc
end
'u_bu_quit': widget_control,ev.top,/destroy
endcase
end
endcase
end
pro w_exo1_2
struc={txt:'', wintxt:'',txt2:0L, txt1:0L, butt:0L}
base=widget_base(/column,uval=struc)
lbl1=widget_label(base,value='Entrez un texte')
txt1=widget_text(base,value='',uvalue='u_txt1',xsize=40,ysize=1,/editable,/all
_events)
b_val=['OK','Effacer','Quitter']
b_uval=['u_bu_ok','u_bu_eff','u_bu_quit']
butt=cw_bgroup(base,b_val,/row,button_uvalue=b_uval,uvalue='u_butt')
IDL et ses widgets 26

lbl2=widget_label(base,value='Affichage')
txt2=widget_text(base,value='',xsize=20,ysize=5,/wrap,/scroll)
widget_control,base,/realize
struc.txt2=txt2
struc.txt1=txt1
struc.butt=butt
widget_control,base,set_uvalue=struc
xmanager,'w_exo1_2',base
end
4) widget_info
Ce widget est spécial : son seul but est de fournir des informations sur un widget dont l’ID lui sert
d’argument :
res=widget_info(id)
Voici quelques uns des 46 mots-clés qui peuvent l’accompagner :
Mot-clé Widget concerné Description
/child Tous Renvoie l’ID du 1 er ‘enfant’ (0 si aucun)
/droplist_number Widget_droplist Renvoie le nombre d’éléments dans la liste
/droplist_select Widget_droplist Renvoie le numéro de l’item sélectionné dans la liste
/event_func Tous Renvoie le nom de la fonction d’interception de la
gestion des événements
/event_pro Tous Renvoie le nom de la procédure d’interception de la
gestion des événements
/geometry Tous Renvoie les dimensions diverses du widget sous
forme d’une structure (cd IDL Reference Guide)
/list_number Widget_list Renvoie le nombre d’éléments de la liste
/list_num_visible Widget_list Renvoie le nombre d’éléments visibles dans la
fenêtre
/list_select Widget_list Renvoie le nombre d’éléments sélectionnés dans la
liste (-1 si aucun)
/list_top Widget_list Renvoie le numéro de l’élément du haut visible dans
la fenêtre
/name Tous Renvoie le nom du widget (base, button, draw, ...)
/parent Tous Renvoie l’ID du parent (0 si aucun)
/slider_min_max Widget_slider Renvoie un tableau à 2 éléments dont le premier est
la valeur min du curseur, et le second la valeur max
/text_number Widget_text Renvoie le nombre de caractères contenu dans le
widget_text
/unit Tous Renvoie le type d’unités : 0 = pixels, 1 = inches, 2 =
centimètres
IDL et ses widgets 27

5) Un exemple plus complet de widget
Le but de cet exemple est de construire une interface permettant d'effectuer les opérations
suivantes :
Charger un fichier texte, d'extension .lst contenant une série de noms de fichiers précédée du
nombre de fichiers. Sélectionner l'un de ces fichiers, le charger et l'afficher. Pouvoir en tracer la
surface, la surface ombrée et l'isocontour, sauver le tracé au format jpeg. Puis recommencer avec
un autre fichier. On souhaite de plus qu'une ligne d'informations renseigne sur les opérations en
cours.
Voici l'aspect général que l'on veut donner à l'interface (on l’a déjà vue dans le II) :
On constate tout d'abord que la base générale est organisée en une colonne. Sa partie supérieure
est organisée en ligne dont la partie gauche est en colonne, qui se décompose pour la partie haute
en ligne ; et la partie centrale, avec les boutons est en colonne. C'est ainsi que l'on va définir les
bases nécessaires à la construction de cette interface.
Voici le listing :
pro w_exo2_event,ev ; Routine de traitement des événements
common ex2, lst, txt, w_num,indice,ld,filen,data,jp ; Transfert d'arguments
widget_control,ev.id,get_uvalue=uval ; On récupère la valeur utilisateur
case uval of ; et on la teste
'u_but1': begin ; Bouton de chargement fichier texte
fn=dialog_pickfile(filter='*.lst')
if strlen(fn) ne 0 then begin
nb_el=0
openr,lun,fn,/get_lun
IDL et ses widgets 28

eadf,lun,nb_el
filen=strarr(nb_el)
readf,lun,filen
free_lun,lun
widget_control,lst,set_value=filen ; On affiche dans le widget_list les
; noms de fichiers
endif
end
'u_lst': begin ; Un nom de fichier a été sélectionné
indice=fix(ev.index)
widget_control,txt,set_value='Fichier '+ filen[indice] + ' sélectionné'
; Texte dans la fenêtre d'informations
end
'u_bu_load': begin ; On charge le fichier sélectionné
if indice ne -1 then begin
widget_control,txt,set_value="Chargement en cours"
; Texte dans la fenêtre d'informations
openr,lun,filen[indice],/get_lun
data=intarr(382,286)
readf,lun,data
free_lun,lun
wset,w_num
tvscl,data
ld=1
widget_control,txt,set_value="Chargement terminé"
; Texte dans la fenêtre d'informations
endif
end
'u_bu_sav': begin ; Le bouton 'Save JPEG' est cliqué
if ld then begin
widget_control,txt,set_value="Sauvegarde en cours"
; Texte dans la fenêtre d'informations
wset,w_num
dat=tvrd()
fn='exo2_'+strcompress(string(jp),/remove_all)+'.jpeg'
write_jpeg,fn,dat
jp=jp+1
widget_control,txt,set_value="Fichier "+fn+' sauvé'
; Texte dans la fenêtre d'informations
endif
end
'u_bu_surf': begin ; Le bouton 'Surface' est cliqué
if ld then begin
wset,w_num
surface,data
endif
end
'u_bu_shad': begin ; Le bouton 'Shade_surf' est cliqué
if ld then begin
wset,w_num
shade_surf,data
endif
end
'u_bu_iso': begin ; Le bouton 'Isocontour' est cliqué
if ld then begin
IDL et ses widgets 29

wset,w_num
image_cont,data
endif
end
'u_bu_quit': widget_control,ev.top,/destroy ; Pour quitter, on détruit la base
; principale
endcase
end
pro w_exo2 ; Routine de création de l'interface
common ex2, lst, txt, w_num,indice,ld,filen,data,jp
; On met en common les données utiles : l'ID du widget_list, l'ID de la fenêtre texte
d'information, le
; numéro de fenêtre (qui n'est pas indispensable puisqu'il n'y en a qu'une), l'indice du fichier
; sélectionné dans la liste de noms de fichiers, un indicateur disant si un fichier est chargé ou non,
la
; liste des noms de fichiers, les données à manipuler quand elles ont été chargées, et un compteur
qui
; s'incrémente à mesure des sauvegardes en jpeg afin de ne pas écraser un ancien fichier.
; Initialisation des valeurs
filen=''
indice=-1
ld=0
jp=0
base=widget_base(/column) ; Base de plus haut niveau
b1=widget_base(base,/row) ; Sous-base pour la partie supérieure
b11=widget_base(b1,/column) ; Sous-sous-base pour le haut-gauche
b111=widget_base(b11,/row) ; sous-sous-sous-base pour la 1 ère ligne
lbl1=widget_label(b111,value='Fichier texte')
but1=widget_button(b111,value='Lire',uvalue='u_but1')
lbl2=widget_label(b11,value="Liste d'images")
lst=widget_list(b11,value=filen,uvalue='u_lst',xsize=35,ysize=6)
b12=widget_base(b1,/column) ; Sous-base pour les boutons
bu_load=widget_button(b12,value='Load', uvalue='u_bu_load')
bu_sav=widget_button(b12,value='Save JPEG', uvalue='u_bu_sav')
bu_surf=widget_button(b12,value='Surface',uvalue='u_bu_surf')
bu_shad=widget_button(b12,value='Shade_surf',uvalue='u_bu_shad')
bu_iso=widget_button(b12,value='Isocontour',uvalue='u_bu_iso')
w_gr=widget_draw(b1,uvalue='u_w_gr',xsize=382,ysize=286) ; Fenêtre graphique
b2=widget_base(base,/row) ; Sous-base pour la fenêtre d'informations
lbl3=widget_label(b2,value='Infos')
txt=widget_text(b2,value='',xsize=40,ysize=1)
bu_quit=widget_button(base,value='Quitter',uvalue='u_bu_quit')
IDL et ses widgets 30

widget_control,base,/realize ; Réalisation du widget
widget_control,w_gr,get_value=w_num ; Récupération du numéro de fenêtre graphique
xmanager,'w_exo2',base ; Passage du contrôle à xmanager
end
IDL et ses widgets 31

no_copy ........................... 18
arguments................................ 3
commons................................. 3
compound widget .................... 4
compound widgets................. 22
cw_bgroup ............................ 22
/column......................... 22
/exclusive .................. 22
/nonexclusive ........... 22
/return_id .................. 23
/return_index ........... 23
/return_name ............. 23
/row................................ 23
/scroll......................... 23
button_uvalue ........... 22
label_left .................. 22
label_top .................... 22
cw_defroi .............................. 23
cw_field ................................ 23
/all_events................ 23
/column......................... 23
/floating .................... 23
/integer....................... 23
/long.............................. 23
/noedit......................... 23
/return_events......... 23
/row................................ 23
/string......................... 23
title.............................. 23
Type................................ 24
update ........................... 24
uvalue ........................... 23
value......................... 23,24
cw_form................................ 24
cw_fslider.............................. 24
/drag.............................. 24
/edit.............................. 24
/vertical .................... 24
Maximum......................... 24
Minimum......................... 24
Title.............................. 24
uvalue ........................... 24
value.............................. 24
cw_pdmenu........................... 24
/mbar.............................. 25
/return_full_name.. 25
/return_id .................. 25
/return_index ........... 25
/return_name ............. 25
cw_zoom............................... 25
max .................................. 25
IDL et ses widgets 32
Index
min .................................. 25
sample ........................... 25
scale.............................. 25
x_zsize ......................... 25
x0..................................... 25
x1..................................... 25
xsize.............................. 25
y_zsize ......................... 25
y0..................................... 25
y1..................................... 25
ysize.............................. 25
ev.handler......................... 7
ev.id .................................... 7
ev.top.................................. 7
event_function.............. 18
event_pro ......................... 19
frame .................................. 18
func_get_value.............. 19
gestion des événements.......... 13
help....................................... 4
/structure............................. 4
mots-clés ................................. 3
pro_set_value................ 19
structures................................. 3
template................................... 5
temporary ......................... 18
transfert d’arguments............. 14
widget ..................................... 4
widget_base .............. 5,8,19
/align_bottom ........ Voir
/align_center ........... 19
/align_left................ 19
/align_right.............. 19
/align_top .................. 19
/base_align_bottom 19
/base_align_center 19
/base_align_left .... 19
/base_align_right.. 19
/base_align_top....... 19
/column............................... 8
/exclusive .................... 8
/floating .................... 19
/modal ........................... 19
/nonexclusive ............. 8
/row.................................. 8
/scroll ........................... 8
app_mbar....................... 19
group_leader................ 8
map .................................. 19
mbar................................ 19
title................................ 8
tlb_frame_attr......... 20
uvalue ............................. 8
widget_button.......... 5,8,20
/align_center ........... 20
/align_left................ 20
/align_right.............. 20
/menu.............................. 20
/separator .................. 20
ev.select....................... 9
group_leader................ 8
units................................ 8
uvalue ............................. 8
value........................... 8,20
xsize................................ 8
ysize................................ 8
widget_control........... 6,12
/append ......................... 12
/destroy....................... 12
/hourglass .................. 13
/iconify....................... 13
/realize....................... 12
all_table_events .... 12
all_text_events....... 12
column_labels ........... 12
column_width.............. 13
edit_cell..................... 13
editable....................... 12
get_uvalue .................. 13
get_value..................... 13
group_leader.............. 13
map .................................. 13
row_heights................ 13
row_labels .................. 13
sensitive..................... 13
set_button .................. 13
set_text_top_line .. 13
set_uvalue .................. 13
set_value..................... 13
tlb_set_title ........... 13
units.............................. 13
xsize.............................. 13
ysize.............................. 13
widget_draw............... 5,9,20
/button_events......... 20
/motion_events......... 20
/scroll ........................... 9
group_leader................ 9
units................................ 9
uvalue ............................. 9
value................................ 9
xsize................................ 9

ysize................................ 9
widget_droplist .......... 6,9
group_leader ............... 9
index................................ 9
title................................ 9
units................................ 9
uvalue ............................. 9
value................................ 9
xsize................................ 9
widget_event .................... 6
widget_info ........................... 27
/child ................................ 27
/droplist_numbe................ 27
/droplist_select.................. 27
/event_func....................... 27
/event_pro......................... 27
/geometry.......................... 27
/list_num_visible .............. 27
/list_number...................... 27
/list_select......................... 27
/list_top............................. 27
/name................................ 27
/parent .............................. 27
/slider_min_max ............... 27
/text_number..................... 27
/unit .................................. 27
widget_label ............ 6,9,20
/align_center ........... 20
/align_left................ 20
/align_right ............. 20
group_leader ............... 9
units................................ 9
value.............................. 10
xsize.............................. 10
IDL et ses widgets 33
ysize.............................. 10
widget_list ................. 6,10
/multiple .................... 10
clicks ........................... 10
group_leader.............. 10
index.............................. 10
units.............................. 10
uvalue ........................... 10
value.............................. 10
xsize.............................. 10
ysize.............................. 10
widget_slider............. 6,10
/drag.............................. 10
/vertical .................... 10
group_leader.............. 10
maximum ......................... 10
minimum ......................... 10
title.............................. 10
units.............................. 10
uvalue ........................... 10
value.............................. 10
xsize.............................. 10
ysize.............................. 10
widget_table .......... 6,11,21
/all_events................ 11
/editable .................... 11
/no_headers................ 11
/scroll ......................... 11
ch..................................... 21
column_labels ........... 11
column_widths ........... 11
group_leader.............. 11
Length ........................... 21
offset ........................... 21
row_heights................ 11
row_labels .................. 11
sel_bottom .................. 21
sel_left....................... 21
sel_right..................... 21
sel_top ......................... 21
str .................................. 21
Type ................................ 21
units.............................. 11
uvalue ........................... 11
value.............................. 11
x 21
xsize.............................. 11
y 21
ysize.............................. 11
widget_text............. 6,11,21
/all_events................ 12
/editable..................... 12
/no_newline................ 21
/scroll ......................... 11
/wrap.............................. 11
ch..................................... 21
group_leader.............. 11
Length ........................... 22
offset ........................... 21
str .................................. 22
Type ................................ 21
units.............................. 11
uvalue ........................... 11
value.............................. 11
xsize.............................. 12
ysize.............................. 12
xmanager ............................. 6