# Programmation Tcl/Version imprimable

* Si vous imprimez cette page, choisissez « Aperçu avant impression » dans votre navigateur, ou cliquez sur le lien Version imprimable dans la boîte à outils, vous verrez cette page sans ce message, ni éléments de navigation sur la gauche ou en haut.
* Cliquez sur Rafraîchir cette page pour obtenir la dernière version du wikilivre.
* Pour plus d'informations sur les version imprimables, y compris la manière d'obtenir une version PDF, vous pouvez lire l'article Versions imprimables.
Une version à jour et éditable de ce livre est disponible sur Wikilivres, une bibliothèque de livres pédagogiques, à l'URL : https://fr.wikibooks.org/wiki/Programmation_Tcl

# Introduction

Il était une fois un programmeur qui avait passé des milliers d'heures à programmer en C, particulièrement des applications de calculs scientifiques (traitement vidéo). Avec les années, il avait acquis une grande facilité dans l'écriture des programmes C, et en même temps une certaine impatience.
Autant le C le satisfaisait pour le calcul scientifique, autant dès qu'il fallait traiter des fichiers ou des chaînes de caractères, il trouvait que c'était fastidieux et surtout générateur d'erreurs de manière inacceptable.
Comme tout le monde, il avait entendu parler des langages de script genre Perl, Tcl/tk, et autres (python). À l'occasion de l'installation de son PC sous Linux, il prit le temps de commencer à programmer en Tcl.
Et ce fut un choc. Plus de pointeurs, plus de gestion-mémoire, de l'idée au programme en un minimum de lignes. Tout cela trivial à apprendre et gratuit, qui peuvent être redistribué, fonctionnant sous Unix (tous les Unix) et sous Windows. Capable de faire des interfaces graphiques de manière très facile, de la programmation CGI en plaisantant. Facile à expliquer. Génial.
Ce programmeur, c'est moi. Et j'ai très envie de vous faire partager cette passion pour mon langage préféré. Tcl (Tool Command Language) est un langage de programmation initialement conçu en 1989 pour le système d'exploitation UNIX par le Dr John Ousterhout et son équipe à l'Université de Berkeley.
Tcl est un langage facile à apprendre, surtout pour un habitué du Langage C. Il permet de développer très rapidement des logiciels de petite taille.
La promotion de Tcl est maintenant assurée par la société ActiveState. Cependant, Tcl est un logiciel libre.
Tcl est surtout connu pour son extension graphique TK. Tcl/Tk permet de concevoir des applications fenêtrées indépendamment de la plateforme (Xwindows / Mac / Windows) à la manière du Langage Java.
Tcl étant un langage interprété, le développement d'un programme est rapide et peut s'effectuer par couche successive. Cette méthode de travail correspond à un cycle de développement en cascade.
Tcl facilite l'accès aux fonctions de son interpréteur, ce qui contribue à la puissance du langage et le place à mi-chemin entre un langage fonctionnel (LISP) et un langage interprété ordinaire (BASIC).

# Vos premiers pas en Tcl

Comment j'ai divisé par 10 le nombre de lignes de code de mes programmes !
Auteur de la version initiale : Arnaud LAPREVOTE

## Introduction
### Pourquoi un cours sur le tcl/tk ?

Je me présente, je m'appelle Henri. Euh non, Arnaud LAPREVOTE.
Il était une fois un programmeur qui avait passé des milliers d'heures à programmer en C, particulièrement des applications de calculs scientifiques (traitement vidéo). Avec les années, il avait acquis une grande facilité dans l'écriture des programmes C, et en même temps une certaine impatience.
Autant le C le satisfaisait pour le calcul scientifique, autant dès qu'il fallait traiter des fichiers ou des chaînes de caractères, il trouvait que c'était fastidieux et surtout générateur d'erreurs de manière inacceptable.
Comme tout le monde, il avait entendu parler des langages de script genre Perl, tcl/tk, et autres (python). À l'occasion de l'installation de son PC sous Linux, il prit le temps de commencer à programmer en tcl.
Et ce fut un choc. Plus de pointeurs, plus de gestion-mémoire, de l'idée au programme en un minimum de lignes. Tout cela trivial à apprendre, gratuit, qui peut être redistribué, fonctionnant sous Unix (tous les Unix) et sous Windows. Capable de faire des interfaces graphiques de manière très facile, de la programmation CGI en plaisantant. Facile à expliquer. Génial.
Ce programmeur, c'est moi. Et j'ai très envie de vous faire partager cette passion pour mon langage préféré.

### Et la concurrence ?

Il y a de très nombreux concurrents au Tcl/Tk :
* Perl,
* Python,
* Scheme (LISP),
* dans une certaine mesure PHP,
* Visual Basic,
* Java.
Tous ces langages ont des avantages et des inconvénients. Mes critères de choix principaux sont :
* open source (source disponible, gratuite et qui peut être redistribuée),
* lisibilité (facilité à maintenir et déboguer),
* multiplateforme (Unix, Linux, Windows),
* grand nombre d'extensions.
Un dernier avantage est que le Tcl n'a pas une ambition infinie. Le Tcl ne veut pas TOUT faire. C'est juste un langage de "colle" pour faire tenir un ensemble d'application ensemble. Si vous voulez faire des choses très grosses ou très complexes ou très rapides, vous êtes priés de vous tourner vers le C, le C++ ou le java. À cette lumière, il ne reste que le python et le tcl, à la limite le Perl. La syntaxe du Perl me rend fou, donc je l'exclus. Je m'intéresse au Python.

### Autres avantages

Les points suivants méritent d'être soulignés :
* fonctions réseau (socket) intégrées très élégamment au langage. Un serveur Web se fait en claquant des doigts,
* facilité d'intégration du tcl dans une application existante,
* très grande robustesse du langage,
* facilité d'intégration de fonctions C dans le Tcl,
* la compatibilité ascendante n'est pas une théorie, mais une réalité,
* très forte cohérence due à une origine universitaire.

### Inconvénients

Tout n'est pas parfait en tcl.
* le langage n'est pas en GPL => moins grande dynamique du langage que le python ou le Perl,
* il n'est pas possible de définir de vraies structures en tcl (au sens C du terme). Cela peut nuire à la lisibilité des programmes et limite la taille de ce que l'on peut programmer. On peut se tourner vers les extensions objet du tcl pour avoir ces fonctions,
* il manque un IDE libre avec un débogueur intégré pour faciliter la prise en main par les débutants.

## Historique

Tcl fut créé en 1990 par John OUSTERHOUT à l'Université de Berkeley. C'est un langage de "collage" pour attacher ensemble plusieurs applications. C'est un langage interprété, mais compilé à la volée depuis la version 8.0. La version actuelle (en janvier 2016) est Tcl 8.6.4.
Après Berkeley, John Ousterhout est passé chez Sun, puis il a créé sa propre société Scriptix qui est devenue ensuite Ajuba Solutions et a été rachetée récemment. Des centaines de programmes et de société utilisent le tcl, mais souvent de manière souterraine. Tcl est donc un langage discret.

## Ressources utiles
### Sites Web

* Le père de tous les sites : http://www.tcl.tk/ .
* Une foultitude d'informations se trouvent sur : http://wiki.tcl.tk/ .
* Le site Web de francophone La Rochelle Innovation consacré au tcl/tk : http://www.larochelle-innovation.com/tcltk/ .
* Pour charger tcl/tk : http://www.activestate.com/Products/Download/Register.plex?id=ActiveTcl : ne pas remplir le formulaire et cliquer sur "Download".
* Toute la documentation et plus sur : http://www.linbox.com/ucome.rvt?file=/any/doc_distrib/tcltk-8.3.2/index.html .

### Les livres

* "Practical Programming in Tcl/Tk" ISBN: 0-13-038560-3 par Brent Welch <welch@acm.org>, Ken Jones, et Jeff Hobbs ; en partie en ligne sur "http://www.beedub.com/book/" : la bible incontournable.
* "Graphical Appications with Tcl&Tk" ISBN : 1-55851-471-6 par Eric F.Johnson : un très bon livre pour commencer.
* "TCL/TK Apprentissage et référence" ISBN : 2-7117-8679-X par Bernard Desgraupes. Je l'ai seulement feuilleté, je suis très vexé de ne pas l'avoir écrit.

## Vos premiers pas en Tcl
### Le premier pas

Pour démarrer un interpréteur tcl, tapez :
Alternativement, sous Windows, allez dans le menu "démarrer", déroulez-le sous menu tcl puis cliquez sur tclsh ou wish (plutôt wish).
Vous obtenez alors un invite de commande en %. Taper les lignes suivantes :
Les points clés de cet exemple sont :
COMMANDES

### Le deuxième pas

COMMANDES
SYNTAXE

## La syntaxe du tcl

Un des problèmes du tcl est sa simplicité. Concernant sa syntaxe, il n'y a que 2 choses à savoir.
Le premier mot de la commande est TOUJOURS la commande.
Donc en tcl, pour initialiser une variable on écrit :
ET PAS
Les arguments de la commande sont séparés les uns des autres par des espaces. D'où obligatoirement :
Et non pas

### La clé du tcl : la substitution

Il y a une finesse en tcl. Les substitutions. L'interprétation d'une ligne se fait en 2 temps :
* substitution de tout ce qui est substituable (variable, code entre crochets),
* exécution de la commande.
Donc :
L'exécution d'un code entre et la substitution dans l'expression appelante du contenu de par son résultat. C'est ce que l'on appelle de la programmation fonctionnelle. Le LISP est l'archétype de ces langages. Le tcl permet de mélanger élégamment programmation fonctionnelle et procédurale. Dans certains cas (les traitements sur des chaînes de caractères) la programmation fonctionnelle est TRÈS (très, vraiment très, j'insiste encore ? non) pratique.
Pour empêcher la substitution, on utilise les accolades { } :
Pour affiner ces notions, on peut ajouter que le caractère\ (barre oblique inverse), force l'interprétation du caractère suivant comme étant un simple caractère et rien d'autre :
Et que l'on peut utiliser les accolades autour d'un nom de variable pour lever l'ambiguïté :
Si vous avez complètement compris ce qui précédait, alors une friandise (sinon c'est le moment de piquer un roupillon, de papoter avec les voisins, de se taper un carton, de relever ses textos, et de noter qu'il faut relire le paragraphe qui suit dans 15 jours).
L'instruction eval permet de forcer une évaluation supplémentaire, et de temps en temps c'est fantastique (le préprocesseur de tcl est tcl contrairement au C):

## Types de données
### Les chaînes de caractères et les scalaires

Tout est chaîne en tcl : c'est la clé de la facilité d'interaction : toute fonction peut envoyer des résultats à n'importe quelle autre.
COMMANDES
SYNTAXE

### Les listes

On utilise beaucoup les listes en tcl.
| COMMANDES | Description |
| list first_elt second_elt ... | Création d'une liste. Renvoi une liste. |
| llength $a_list | Renvoi le nombre d'éléments de la liste |
| lindex $a_list elt_nber | Renvoi l'élément n° elt_nber de la liste. elt_nber peut être end (dernier élément). |
| lrange $a_list start_nber end_nber | Renvoi une liste composée des éléments commençants ) start_nber et finissant à end_nber |
| lsort $a_liste | Ordonnancement de la liste. De nombreuses options permettent de classer en ordre croissant/ décroissant, en utilisant un élément d'une sous-liste comme clé, en ordre numérique, ... Renvoi une liste |
| linsert $a_list nber elt_to_insert | Insère un élément dans une liste à l'endroit indiqué. Renvoi une liste. |
| lappend a_list elt_to_append_at_the_end | Ajoute les éléments suivant à la fin de la liste. ATTENTION LAPPEND NE RENVOIE PAS DE LISTE. IL MET AU BOUT DE LA LISTE NOMMÉE a_list LES ÉLÉMENTS. |
| split "chaîne de caractère" [caractère] | Transforme une chaîne de caractères en une liste. Le séparateur est le caractère fourni en second paramètre. |

### Chaînes et expressions régulières

Les expressions régulières sont une fonction clé des langages de scripts (ksh, Perl, awk, tcl, python, ...). Elles ne sont pas du tout naturelles, mais une fois comprises, elles sont un outil très puissant. Vous devez les essayer !
Une seule méthode pour survivre en United States of Regular Expressions : essayez d'abord, puis programmez. Même une ceinture noire 4ème dan de tcl fait comme cela.
COMMANDES
* . n'importe quel caractère,
* * le caractère précédent 0 ou plusieurs fois,
* + preceding character at least once or more,
* [a-zA-Z] character list or range,
* [^a-z] not these characters,
* \$ exactly the character $ forget rules,
* ^ first character of the string,
* $ last character of the string,
* ? matches preceding character once or nothing,
* pattern1|pattern2 matches pattern1 or pattern2.

### Les tableaux associatifs

| COMMANDES | EXPLICATION |
| set toto(tata) "string" | Initialisation à string de l'entrée tata dans le tableau toto |
| array exists name | Renvoi 1 si le tableau name existe |
| array names name | Renvoi la liste des entrées du tableau |
| array get name | Liste de paires clé valeur du tableau name |
| array set name list | Initialise le tableau name en utilisant une liste à la syntaxe identique au résultat de array get name |
| parray name | Affichage du tableau name |
| upvar $name name_to_use | Passage d'un tableau par pointeur à une fonction |

## Commandes de contrôle
### Conditions, boucles, contrôle de l'exécution

Les options -exact -glob et -regexp permettent de choisir le type de règle de comparaison utilisé. Pour distinguer les options de switch de l'argument final de switch on utilise -- :
Si l'on est en mode -exact de switch, on cherche la section de switch dont la valeur est strictement identique à l'argument de switch.
Si l'on est en mode -glob, alors * remplace n'importe quel caractère zéro ou plusieurs fois. Donc :
Enfin en mode regexp, on utilise un mode de comparaison de type expression régulière.
Un exemple plus complet :
Exemple
Enfin, il ne faut pas oublier l'instruction foreach. Cette instruction permet de boucler sur les éléments d'une liste.

### Fonctions et procédures

La commande permettant de définir une procédure est proc. C'est une commande comme une autre qui prend 3 arguments :
Exemple :

## Entrées/sorties et gestion des erreurs
### Entrées/sorties

Les commandes sont les suivantes : |open gets seek flush close read tell puts file
La commande open retourne un identifiant qui sera utilisé lors des appels aux autres commandes. Ex:
Ou encore :
Les autres commandes utiles sont :

### Gestion des erreurs

La commande catch permet d'attraper les erreurs :
Tout cela est bien sûr très utilisé lors de l'ouverture d'un fichier en lecture ou en écriture et plus généralement dès que l'on communique avec l'extérieur.
La commande error permet elle de générer une erreur dans un code et d'y associer un message d'erreur.

## Récapitulatif des commandes du Tcl

COMMANDES TRES UTILISEES
MOINS USITEES
Comme vous pouvez le remarquer, cela représente vraiment peu de commandes, ce qui explique la facilité d'apprentissage du tcl.

## Pas toujours les mêmes
### Lecture de fichiers

L'objectif est d'écrire un programme tcl qui parcourra un fichier HTML et donnera la liste des noms entre les tags HTML h1 et /h1 et les variantes de ces tags h2 /h2 et h3 /h3. La liste sera imprimée sur la sortie standard. Il faut tester sur la page suivante : http://www.w3.org/TR/REC-html32.html Sauvegardez cette page dans /tmp sous le nom test.html, puis lancez votre programme dessus.

### Lecture des arguments d'un programme

Vous souhaitez écrire un programme qui a des options d'appel en ligne de commande. En particulier :
* -h[elp] : affichage d'une aide ;
* -f[ile] nom_de_fichier : fichier d'entrée ;
* -l[evel] [0-9]+ : niveau de recherche de 1 à ce que vous voulez.
Les arguments peuvent être passés sur la ligne de commande dans n'importe quel ordre. À la fin de l'initialisation de la fonction vous avez 3 drapeaux à 1 ou 0 indiquant si les options -help, -file ou -level ont été appelées. Le nom du fichier d'entrée et le niveau sont stockés dans les variables filename et level.
Lors de l'appel d'un programme, les variables suivantes sont disponibles :
* argc : nombre d'arguments sur la ligne de commande (stockée dans argv),
* argv : liste des arguments sur la ligne de commande, sans la commande,
* argv0 : nom de la commande,
* env : tableau contenant les variables d'environnement.
Nous appelons cette commande args.tcl et la rendons exécutable puis testons :
Vous allez créer une machine à état. Le passage d'un état à un autre se fait lorsque l'on passe à l'argument suivant. L'état de base de cette machine est :
* check_args : attente d'un argument type -f, -l ou -h.
De cet état, vous allez sauter à l'état suivant lors du test de l'argument suivant, en fonction de la valeur de arg. Si arg est à -f*, alors vous sautez dans l'état is_file, et vous initialisez filename avec $arg. Au passage, vous initialisez le drapeau correspondant à la présence du nom de fichier sur la ligne de commande à 1. Il faut ensuite revenir à l'état check_arg.
Il vous reste juste à prévoir les états correspondants pour help et pour level et à les gérer de même.
Bon courage. Merci de ne pas oublier le guide à la fin de la visite. À votre bon cœur monsieur dame.

# Vos premiers pas en Tk

Tk - la bibliothèque graphique de Tcl
Auteur de la version initiale : Arnaud LAPREVOTE

## Tk

Tk est le compagnon graphique de tcl. Il contient en particulier les widgets suivants :
* bouton
* label
* entrée de texte
* menu
* photo
* fenêtre de sélection de fichiers, de couleurs, ...
Ce qui n'est pas directement dans Tk peut être trouvé directement dans des extensions supplémentaires, telles que Blt (widget de tracé de courbes), les Bwidgets, HTML. On commence aussi à trouver des méga-widgets directement écrits en tk (combobox, notepad, arbre).

## Premier pas en Tk

Pour créer une interface, on :
* définit chaque widget et ses attributs,
* dispose les widgets dans la fenêtre (pack ou grid),
* définit les commandes associées aux actions.
Tk gère intégralement la boucle de suivi des événements. On ne s'en préoccupe pas.
Ou encore plus simplement :

## Création d'un widget

Le nom d'un widget est toujours : .xxxx.yyyy.zzzz Dans ce cas on crée le widget zzzz qui se trouve dans le widget yyyy qui se trouve dans le widget xxxx. xxxx pourrait parfaitement être une nouvelle fenêtre ou un widget.
Lors de la création d'un widget, des paramètres sont initialisés. Par exemple, dans :
Lors de la création du label .exemple_label, on vient initialiser son paramètre -text à la valeur "Je dis juste bonjour !".
Il est constamment possible de changer un paramètre d'un widget avec la commande configure.
Les valeurs initialisables pour un widget varient d'un widget à l'autre. Cependant il y a un certain nombre de paramètres qui sont systématiquement initialisables pour les widgets. La liste de ces options par défaut est disponible :

## Modification des paramètres d'un widget existant

Reprenons notre petit exemple : 2 solutions existent ici. Si vous tapez directement dans wish, alors tapez :
Si vous souhaitez plutôt utiliser un programme dans un fichier, alors tapez :
Comme vous pouvez le constater configure a permis de changer la valeur d'un paramètre d'un widget. Si vous souhaitez connaître la liste de tous les paramètres d'un widget, il vous suffit de taper : .nom_du_widget configure
Si vous souhaitez connaître la valeur d'un paramètre donné, vous pouvez utiliser la commande cget :
Remarque Dis tonton Arnaud, tu nous as bassiné avec le fait qu'une ligne tcl consistait toujours en :
Or je constate ici que l'on a :
Il y a tromperie sur la marchandise, remboursez !!!!!
Réponse de tonton Arnaud Que nenni !!! Lorsque l'on crée un widget, une commande portant le nom du widget est créée et configure est un argument de cette commande comme un autre.

## Mort d'un widget

Tout à une fin. On peut détruire un widget avec la commande :

## Les options standard

| Option | Signification |
| -background | couleur de fond du widget. Ou un mot (red, ...) ou une chaîne définissant rgb avec des valeurs hexa (noir : "#00000", blanc : "#ffffff", rouge : "#ff0000") |
| -activebackground | couleur de fond lorsque le curseur est sur le widget |
| -foreground | la couleur du texte quand le curseur n'est pas sur le widget |
| -activeforeground | la couleur du texte quand le curseur est sur le widget |
| -text | le texte du bouton |
| -textvariable | une variable dont le contenu s'affichera dans le widget |
| -image | une image précédemment chargée |
| -bitmap | un bitmap qui s'affichera dans le widget |
| -padx | espace de garde à droite et à gauche du widget |
| -pady | espace de garde au-dessus et en dessous du widget |
| -anchor | l'élément interne au widget (texte ou graphique) sera collé à la partie haute (nord => n) basse (sud => s) droite (est => e) ou gauche (ouest => w) ou au centre (center). |
| -width | largeur en caractères du widget |
| -height | hauteur en caractères du widget |
| -justify | right, left, center. Si le widget contient un texte sur plusieurs lignes, la justification choisie sera appliquée. |

## À vous Cognaq-Jay

Créez une application contenant un label, un bouton "Quitter", un bouton "Changer". Au départ, sur le label on lit :
Quand on clique sur le bouton "Changer", le label devient "Vous venez de cliquer sur le bouton Changer", si on re-clique, on revient à "Je dis juste bonjour" et ainsi de suite. Si on clique sur le bouton "Quitter", l'application se termine.
Le bouton "Quitter" a un fond rouge, quand le curseur passe dessus se fond devient rose (#ff8080).
Dans une seconde version, vous garderez cette même application, ajouterez les boutons flat, groove, sunken, ridge. Lors de l'appui sur ces boutons, la propriété -relief du label changera et prendra la valeur flat, groove, sunken, ridge.
Je paye personnellement un coca-cola (virtuel) à celui qui réussira à faire ce dernier exercice avec une boucle sur la liste [list flat groove sunken ridge].

## Placement des widgets

3 modes de placement existent :
* pack
* grid
* place

### Le packer :

Les widgets sont placés en colonnes ou lignes. Les colonnes ou les lignes sont créées les unes après les autres. Pour obtenir des placements par groupe de widget on utilise des frames qui vont contenir des widgets en horizontal ou en vertical.

### Le grider :

Les widgets sont placés sur une grille (comme dans un tableau HTML pour ceux qui connaissent). La taille des colonnes est calculée automatiquement.
Le placer permet de placer les widgets en donnant directement leurs coordonnées. Je ne l'ai jamais utilisé.

## Le packer dans le détail - les options de pack

On peut utiliser la commande pack avec les options :
On choisit l'orientation (horizontal ou vertical) ainsi que l'endroit (de gauche à droite, de droite à gauche, de haut en bas, de bas en haut) dans lequel les widget sont placés.
Défini si les widgets packés doivent remplir complètement l'espace disponible ou non en horizontal (x) ou en vertical (y). Par défaut l'option est none.
Lors du redimensionnement de la fenêtre, les widgets packés avec cette commande suivront l'expansion de la taille de la fenêtre.
Le nombre de pixels à droite et à gauche du widget courant sera ajouté en horizontal (padx) ou en vertical (pady) autour du widget.
Le nombre de pixels nécessaire est ajouté à l'intérieur du widget à droite et à gauche (-ipady) ou au dessus et en dessous (-ipadx).
On peut faire "oublier" un widget au packer en utilisant l'option forget. Enfin, pour pouvoir bouger un widget dans tous les sens, il faut qu'il soit défini avant un autre.

## Exercice

Votre mission si vous l'acceptez consiste à obtenir successivement les looks suivant avec le packer et 2 labels :
img/tk_ex1.gif
img/tk_ex2.gif
img/tk_ex3.gif
img/tk_ex4.gif
img/tk_ex5.gif
img/tk_ex6.gif
Pour ce faire, vous allez lancer wish et vous allez créer les 2 widgets suivants en ligne de commande :
Afin que votre cerveau ne s’autodétruise pas au bout de 15 minutes, voici quelques conseils :
* les 5 premiers écrans s'obtiennent uniquement en faisant bouger l'un ou l'autre des widgets avec la commande pack,
* le dernier écran s'obtient en configurant l'option -anchor du label 2.
Bien sûr, si votre mission échoue, nous nierons tout lien avec vous et peut-être même vous livrerons au côté obscure de la force dans la salle d'à côté.

## Les frames

Les frames sont comme le sel en cuisine, il en faut des pincées, cela reste invisible, mais sans cela le plat est infect.
Imaginons que nous souhaitions avoir l'interface suivante :
Le code correspondant est le suivant :
Comme vous le voyez, les frames permettent de regrouper des ensembles de widget par ligne horizontale et verticale. Grâce à .frame1.frame2 on a groupé les widgets .frame1.frame2.lab1 et .frame1.frame2.ent1 horizontalement, puis dans .frame1 on a ajouté .ent2 et on les a empilés verticalement. Enfin on a placé .but1 et .frame2 cote à cote.
En jouant judicieusement sur les options -expand et -fill, on arrive à obtenir un comportement sophistiqué de l'application lors des redimensionnements.

## Le gridder

Dans certains cas, le packer est vraiment assez inadapté et oblige à utiliser un nombre incroyable de frame. Des extensions à tcl sont alors apparus qui intégraient des algorithmes de placement basés sur une grille de cases.
Une grille est définie et l'on choisi le ou les cases sur lesquels un widget (ou un ensemble de widget dans une frame) vont être placés. Le gridder est plus verbeux que le packer à l'écriture parce qu'il faut une ligne pour chaque widget. Par contre, il est trivial de générer le code automatiquement.
Les options de grid (au placement ou lors d'un configure) sont les suivantes :
Identification de la case où le widget sera placé
Le widget est placé sur une ou plusieurs colonnes, sur une ou plusieurs lignes.
Strictement identique à ces valeurs dans le packer.
La manière dont le widget est "collé" aux bords. Si l'on souhaite qu'en cas de redimensionnement le widget voit sa taille augmenté, on utilise -sticky ew ou ns ou ewns.
Il est possible de fixer les attributs d'une colonne ou d'une ligne grâce à
Assez étrangement, les numéros de lignes et de colonnes commencent à 1 et non pas à 0.

## Événements disponibles

On peut associer à chaque événement d'un widget des actions. Cela se fait avec la commande bind.
La syntaxe de bind est :
La syntaxe des événements est un peu particulière. En première approximation, c'est : <type_d_evenement-evenement>
type_d_evenement peut être :
Type d'événement :
| ButtonPress <=> Button | Expose | Map |
| ButtonRelease | FocusIn | Motion |
| Circulate | FocusOut | Property |
| Colormap | Gravity | Reparent |
| Configure | KeyPress <=> Key | Unmap |
| Destroy | KeyRelease | Visibility |
| Enter | Leave | Activate |
| Deactivate | | |
Button et Key sont d'utilisation très courantes. Il m'est arrivé d'utiliser aussi Enter et Leave.
evenement peut être :
* 1 : le bouton 1 de la souris,
* 2 : le bouton 2 de la souris,
* 3 : le bouton 3 de la souris,
* le nom d'une touche : abcdefghij...left, right, up, down, Control_L, Control_R, Insert, Delete, ....
En ce qui concerne les touches, attention, il peut y avoir des différences de dénomination entre OS. Utilisez l'exemple plus haut pour connaître le code.
Enfin devant tout cela (type_d_evenement-evenement), il peut y avoir un modificateur. Par exemple, on peut demander à ce que la touche Ctrl soit appuyé, Alt ou Shift, ou vouloir un double clique, ou que le bouton 1 de la souris soit activé. Les autres événements me paraissent moins utiles. La liste est la suivante :
Modificateur :
| Control | Mod2 <=> M2 |
| Shift | Mod3 <=> M3 |
| Lock | Mod4 <=> M4 |
| Button1 <=> B1 | Mod5 <=> M5 |
| Button2 <=> B2 | Meta <=> M |
| Button3 <=> B3 | Alt |
| Button4 <=> B4 | Double |
| Button5 <=> B5 | Triple |
| Mod1 <=> M1 | |
Enfin, dans le script associé au binding, on peut récupérer diverses informations sur l'événement grâce à des chaines du type %x :
* %b : numéro du bouton pour les événements ButtonPress et ButtonRelease,
* %k : le code de touche pour l'événement KeyPress ou KeyRelease,
* %K : le code de touche sous forme de chaîne pour les 2 événements décrits plus haut,
* %X : coordonnée horizontal de l'événement dans le widget courant (pour ButtonPress, ButtonRelease, KeyPress, KeyRelease),
* %Y : coordonnée vertical de l'événement dans le widget courant (pour ButtonPress, ButtonRelease, KeyPress, KeyRelease).
La page de man de bind donne toutes les indications.

## Liste des widgets disponibles

* button, canvas, checkbutton
* entry, frame, label
* listbox, menu, menubutton
* message, radiobutton, scale
* scrollbar, text, toplevel
* tk_getOpenFile, tk_getSaveFile, tk_chooseColor
* tk_dialog, tk_optionMenu, ...

## Les boutons

Pour avoir toutes les options, n'hésitez pas à vous reporter à la page de man. Les options me semblant crucialement utiles sont :
Liste des options pour le widget button :
| Option | Signification |
| -background | couleur de fond du bouton |
| -activebackground | couleur de fond lorsque le curseur est sur le bouton |
| -text | le texte du bouton |
| -image | une image précédemment chargée s'affiche dans le bouton |
| -command | commande(s) exécutées lors de l'appui sur le bouton |

## Les labels

Les labels sont les widgets contenant un texte non modifiable interactivement. Évidemment le texte est modifiable via programmation.
Liste des options pour le widget :
| Option | Signification |
| -text | le texte du bouton |
| -textvariable | une variable dont le contenu s'affichera dans le widget |
Le widget "message" est un label multiligne.

## Les entrées de texte

Liste des options pour le widget :
| Option | Signification |
| -textvariable | une variable dont le contenu s'affichera dans le widget |
| -width | le nombre de caractères par défaut du widget en largeur |

## Les cases à cocher

Une case à cocher permet de savoir si une option est ou non sélectionnée. Cela s'utilise de la manière suivante :
Les options -onvalue -offvalue permettent de forcer une valeur pour la variable selon que la case est ou non cochée.

## Les boutons radio

Les boutons radio sont des cases à cocher dont une seule peut-être active à la fois.

## Les menus

Pour créer un menu avec des listes déroulantes, on utilise simplement une frame (-relief raised), avec à l'intérieur des widget "menubutton". À chaque menubutton on associe un widget fils menu. Ce menu est composé d'entrée de type command (avec option -label, -command), de type radiobutton (option -label, -command, -variable et -value) de type checkbutton (-label -command -variable -onvalue -offvalue) ou de type cascade (option -label -cascade) enchaînant vers un autre menu.
L'option -accelerator permet d'associer une touche d'accélération pour activer l'entrée de menu correspondante.
Il existe aussi des menus d'options : tk_optionMenu
Ainsi que des menus pop-up.

## Les images

Comme nous l'avons vu précédemment, il est possible d'associer un bitmap (noir et blanc) ou une photo à un widget (bouton, label).
La procédure est simple :
* on crée l'image de type photo (couleur) ou bitmap (pixel noir ou blanc),
* on associe la photo créée au widget.
Prenons le cas de la photo :
Il ne reste plus qu'à associer la photo à un label
Il est évidemment possible de changer de photo par exemple :
Vous pouvez vous reporter au man de la commande image pour voir les commandes disponibles.

## Interface graphique contre grosse fatigue

Nous allons refaire un joyeux exercice, mais cette fois-ci vous allez pouvoir utiliser un builder graphique d'application. Il en existe 3 pour tk.
Le plus ancien est SpecTcl (http://wuarchive.wustl.edu/languages/tcl/SpecTcl/). À sa création par les laboratoires de Sun, s'était un produit commercial. Ils l'ont rapidement mis dans le domaine public et abandonné le développement. Le résultat est un excellent produit stable et facile à utiliser mais qui n'évolue plus (et c'est bien dommage). C'est ce que j'ai utilisé au départ.
L'inconvénient de specTcl est qu'il faut très régulièrement retoucher le code généré. À partir du moment où on touche le code généré par un builder, on ne peut plus du tout continuer à utiliser l'interface graphique et cela perd de son intérêt.
Nouveau : le développement de specTcl a repris. Il se trouve maintenant sur sourceforge.net.
tkBuilder que l'on peut trouver sur http://scp.on.ca/sawpit, est un outil moins graphique que specTcl, mais très pratique pour le programmeur. C'est un excellent support graphique à la programmation. Grâce à la possibilité de rajouter du code manuel un peu partout, il est très facile de ne pas avoir à modifier le code.
Enfin, Visual Tcl est un logiciel constamment prometteur, certainement le plus ambitieux des 3 (le plus proche de VB ?). On le trouve sur :
Malheureusement, à chaque fois que je l'utilise, il me claque entre les mains. Je vous propose malgré tout de voir si la dernière version (1.6alpha) tient ou non la route.
Je vous propose de charger l'un des 3 et de faire les exercices suivants avec une interface de construction. À charge pour vous de lire le manuel.

## Vous n'allez pas rigoler

Votre but est de créer l'application suivante :
On donne en haut le nom d'un fichier gif ou jpeg et quand on appuie sur le bouton Ouvrir cette image est affichée dans le label central. Bien sûr, on peut répéter l'opération d'ouverture à chaque fois.
On peut choisir le nom de fichier ou en le tapant dans l'entrée de texte du haut ou en cliquant sur le bouton à côté de l'entrée de texte qui permet d'appeler le widget tk_getOpenFile. On utilise cette fonction de la manière suivante :
tk_getOpenFile est un widget standard de tcl ayant un manuel.
J'ai utilisé tkBuilder pour créer cette application : img/tkbuilder.gif mais n'hésitez pas à utiliser un autre builder.

## Bibliographie

"Graphical Applications with Tcl&Tk" de Eric F. Johnson, M&T Books, ISBN 1-55851-471-6 : le livre avec lequel j'ai appris le tcl/tk. Pas complet, mais très pédagogique et agréable à lire.

# Notation particulière de Tcl

Tcl utilise une notation particulière pour indiquer les appels de fonctions.
En mathématique, ainsi que dans la plupart des langages de programmation, on utilise la notation y = f(a,b).
Tcl a magnifiquement simplifié cette notation en mettant les parenthèses AVANT la fonction :
set y [f a b]
Autrement dit, en mathématique, on écrirait y = (f a b) c'est lumineux, car on comprend où commence la fonction (par le crochet "[") et où elle finit (par "]"). Les virgules ont également disparu ... S'il y a des appels de fonctions imbriquées, les parenthèses doivent être imbriqués, par exemple set z [g x [f a b]] ... en math z=g(x,f(a,b)) Cette notation se rapproche évidemment de la notation utilisée dans les langages de scripts sh, csh, etc. mais là on écrit y = `f a b` avec des ` (accent grave) qui ne sont pas des parenthèses (ouvrantes et fermantes).
Dans tout langage de programmation, il faut toujours faire la distinction entre la référence à la variable et le contenu de la variable. Lorsque l'on utilise une variable, disons X, le fait que l'on parle de sa référence (ou son adresse) ou de son contenu dépend généralement de sa place dans l'instruction du langage de programmation. Ainsi en C on écrit X=Y ce qui signifie qu'on affecte à la variable X (on ne s'occupe pas de sa valeur) le contenu de la variable Y. X situé à gauche du signe "=" est traité différemment de Y qui est à droite du signe "=" (on ne s'intéresse qu'à sa valeur). En Tcl, (mis à part les raccourcis d'écriture décrits ci-dessous) c'est beaucoup plus logique ... Il existe la fonction set :
[set X] est la fonction qui rend le contenu de la variable X
set X 25 permet d'affecter à X la valeur 25
[set X 25] , par extension fait les deux, elle affecte 25 à X et rend la valeur de X, c'est-à-dire 25
ainsi x=y s'écrit set X [set Y]
c'est logique ... mais un peu lourd. En Tcl on utilise le raccourci d'écriture $Y à la place de [set Y], set X [set Y] s'écrit alors set X $Y
On utilise presque toujours $Y au lieu de [set Y] sauf quand il y a ambiguïté. On utilise aussi la notation ${VARIAB} à la place de $VARIAB (ou canoniquement [set VARIAB]) si ambiguïté.
Pourquoi tout cela ? ... Pour pouvoir concaténer des chaînes de caractères de la manière la plus naturelle possible, en les juxtaposant. Par exemple :
Dans cet exemple les mots sont bien séparés par des espaces
Prenons un exemple sans espaces
ne marche pas parce il semble qu'il y ait une variable de nom RepToto alors que ce qu'on voulait c'est (canoniquement)
ou (en raccourci sans ambiguïté),
pour bien faire la distinction entre la variable $Rep et le texte Toto.txt
Pour finir ces histoires de notation ... un appel à une fonction se fait par
si l'on veut transmettre à f le contenu de a et b
ou
si l'on veut transmettre à h la valeur de a et la référence (ou adresse) de la variable b (pour que h la modifie, par exemple)
on aurait dû écrire, canoniquement