# Programmation GTK2 en Pascal/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_GTK2_en_Pascal

# Introduction

GTK+ (The Gimp Tool Kit) est un ensemble de bibliothèques (au sens informatique du terme, c'est-à-dire un ensemble de fonctions) développé originellement pour les besoins du logiciel de traitement d'images The Gimp (GNU Image Manipulation Program) et utilisé également pour le développement de l'environnement de bureau GNOME.
GTK+ peut-être utilisé pour créer des programmes avec interfaces graphiques facilement.
GTK+ est libre (licence GNU LGPL) et multiplateforme.
Le plan de ce « livre » est calqué sur le site wiki GtkFr - Cours Gtk+-2 qui concerne la programmation de GTK+ version 2 mais en langage C. Ce site et son ancêtre sont sous licence GFDL.
Ce « livre » se veut donc l'équivalent, un manuel de référence pour la programmation GTK+ version 2 en langage Pascal. Une bonne connaissance du Pascal est nécessaire ; vous pouvez pour l'acquérir vous référer au livre Programmation Pascal.

# Logiciels nécessaires

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie

## Compilateur Pascal

Un bon compilateur libre est le Free Pascal. La version stable disponible en février 2013, est la 2.6.2. Il est multi-plateforme et fonctionne pour les systèmes Linux, FreeBSD, NetBSD, MacOSX/Darwin, MacOS classic, DOS, Win32, OS/2, BeOS, SunOS (Solaris), QNX et Classic Amiga.
L'outil de développement de Borland, Kylix pour Linux, est disponible gratuitement pour écrire des programmes open source. On peut l'utiliser comme un simple compilateur pascal sans utiliser le système de gestion de fenêtres (basé d'ailleurs pour la version portable, CLX, sur Qt, un système concurrent à GTK).
La version windows, Delphi pour win32, n'est apparemment plus disponible en téléchargement gratuit.
Il existe un environnement de développement Pascal open source, très proche de Delphi/Kylix et compatibles avec ces derniers, Lazarus.

## En-Têtes GTK2 pour le langage Pascal

Ces en-têtes servent d'interface entre les programmes et les bibliothèques GTK. Le projet Gtk2 for Pascal en fournit sous licence LGPL. Elles sont utilisables par les compilateurs Free Pascal, Delphi et Kylix. La version stable disponible en mars 2005, est la 1.0.7.
Ces en-têtes sont intégrées dans la version 2.0 du compilateur Free Pascal (au mois de mars 2005, la version 2.0 RC 2, 1.9.8 est disponible).

## Bibliothèques GTK+

GTK+ s'appuie sur plusieurs bibliothèques :
* Gtk : contient les fonctions de gestion des contrôles visuels ;
* Glib : contient les fonctions de bas-niveau ;
* Pango : contient les fonctions de texte et notamment tout ce qui est internationalisation ;
* Atk : contient les fonctions gérant l'accessibilité.
En mars 2005, Gtk et Glib sont en version 2.6.2 (les versions windows sont toujours des 2.4) et Pango en version 1.8.0.

# Installation sous Linux

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie

## Compilateur Pascal
### Free Pascal
#### Mandrake

Avec un urpmi bien configuré :
et le tour est joué.
Ou pour avoir la dernière version (au mois de mars 2005, la 1.9.8), il faut télécharger sur le site http://www.freepascal.org le fichier fpc-1.9.8-0.i586.rpm qu'on installe classiquement :

### Kylix

<à compléter>

## En-têtes GTK2 pour le langage Pascal
### Free Pascal version 1.0 ou Kylix

L'archive gtk2forpascal-1.0.7.tgz est à télécharger sur le site Gtk2 for Pascal.
Il faut décompresser ensuite l'archive, par exemple dans le répertoire où vous placez vos sources :
Cela créé un sous-répertoire gtk2 avec tout ce qu'il faut dedans.

### Free Pascal version 2.0 (1.9.x)

Si vous avez installé la version 2.0 du compilateur Free Pascal (ou les versions RC, 1.9.x), vous avez déjà ces en-têtes. Mais elles sont précompilés pour fonctionner avec les bibliothèques Gtk+ 2.0, pas 2.2, 2.4 ou 2.6 qui apportent pas mal de nouveautés intéressantes.
En attendant que l'équipe de Free Pascal le fasse, pour recompiler ces unités en version 2.6, la dernière disponible en mars 2005, vous devez télécharger les sources du compilateur Free Pascal, exemple pour Mandrake, le fichier fpc-1.9.8-0.src.rpm.
Il faut mettre à jour le fichier gtk+/gtk/gtkincludes.inc car il y a 3 unités qui ne passent pas. Mettez en commentaires les lignes :
Puis on poursuit :
Nos unités sont disponibles.

## Bibliothèques GTK+

Sur un Linux où un Gnome récent est installé, les bibliothèques GTK+ version 2 seront installés.
Vous pouvez vérifier quelle version est installée sur votre système à l'aide de la ligne de commande suivante :
S'il vous répond, un truc du style :
Ce n'est pas bon signe...

### Autre solution

Taper en root « locate *.pc » pour trouver le répertoire pkgconfig.
Vérifier si le fichier "gtk+-2.0" est présent ! Si non : installer libgtk2.0-dev et libglade2-dev. Et il est conseillé d'ajouter : libgtk2.0-0, libgtk2.0-bin et libgtk2.0-common.

### Compilation

Par le biais des mises-à-jour automatiques il se peut que vous ayez une version de Gtk+ assez ancienne. Par exemple sur une Mandrake 10.0, pas si vieille, c'est la version 2.2.4 de Gtk+ qui est disponible. Pour posséder une version récente, au mois de mars 2005, la 2.6.2, on peut tout recompiler.
Il faut télécharger sur le site http://www.gtk.org/ les fichiers :
* glib+-2.6.2.tar.bz2
* atk-1.9.0.tar.bz2
* pango-1.8.0.tar.bz2
* gtk+-2.6.2.tar.bz2
Puis dans l'ordre, on compile la GLib :
Au tour de l'Atk :
De Pango :
Et enfin de Gtk+ :
Et c'est tout.

# Installation sous Windows

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie

## Compilateur Pascal
### Free Pascal

Sur le site de Free Pascal, téléchargez le fichier w321010.zip (au 23/02/2005, version stable 1.0.10), la version sans les sources est suffisante (25,1 Mo).
Décompactez l'archive dans un répertoire temporaire et lancez install.exe.

## En-têtes GTK2 pour le langage Pascal

L'archive gtk2forpascal-1.0.7.tgz est à télécharger sur le site Gtk2 for Pascal.
Il faut décompresser ensuite l'archive, par exemple dans le répertoire où vous placez vos sources. Avec un WinZip récent ça passe.
NB : Il faut éventuellement le faire en deux fois, et renommer le fichier intermédiaire en .tar pour qu'il soit accepté par WinZip.
Cela créé un sous-répertoire gtk2 avec tout ce qu'il faut dedans.

## Bibliothèques GTK+

Sur le site de Gimp, vous devez télécharger les principales bibliothèques nécessaires. Des explications en anglais sont données.
Au 23/02/2005, il faut télécharger :
* glib-2.4.7.zip
* GNU libiconv (libiconv-1.9.1.bin.woe32.zip)
* gettext-runtime-0.13.1.zip
* gtk+-2.4.14.zip
* pango-1.4.1.zip
* atk-1.8.0.zip
Décompactez ces archives dans un même répertoire.
Il faut ensuite mettre à jour la variable d'environnement PATH Sous un windows 2000 ou XP, cela se passe dans le panneau de configuration, choix Système, onglet Avancé, bouton Variables d'environnement. Sélectionnez « path » et le bouton « modifier », ajoutez à la fin un « ; » suivi du répertoire où vous venez de placer toutes les archives, suivi de « \bin ».
Par exemple, chez moi, j'ai tout décompacté dans D:\gtk2lib, j'ai donc ajouté ;D:\gtk2lib\bin.

# Installation sous Mac/OS

Cette page est considérée comme une ébauche à compléter . Si vous possédez quelques connaissances sur le sujet, vous pouvez les partager en éditant dès à présent cette page (en cliquant sur le lien « »).
Ressources suggérées : Aucune (vous pouvez indiquer les ressources que vous suggérez qui pourraient aider d'autres personnes à compléter cette page dans le paramètre « ressources » du modèle engendrant ce cadre)
* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
NB: Ne connaissant pas du tout le monde Mac, ce chapitre est simplement ébauché pour l'instant.

## Free Pascal et en-têtes Gtk+

En février 2005, Free Pascal est disponible en version 1.9.8 (2.0 RC 2). La page du site plus particulièrement dédiée au Mac est http://www.freepascal.org/fpcmac.html.

## Bibliothèques GTK+

Voir le projet GTK+OSX (http://gtk-osx.sourceforge.net/) de portage de Gtk+ sur Mac/OS X.

# Une application minimale

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie

## Avant-propos

Cette application GTK minimale va nous permettre de tester l'installation des différents logiciels nécessaires.

## L'application

Elle est simple et minimale. De plus elle ne fait rien. Voilà le fichier gtk000.pas :

## La compilation sous Linux
### Avec Free Pascal version 1.0.x

À la première compilation, il convient de générer le fichier des ressources pour GTK+ gtk2.link.res. Ce fichier est utilisé dans l'édition des liens de chaque programme GTK+.
Cela se passe dans le répertoire gtk2 où se trouvent les entêtes GTK+, il faut lancer le script :
On ne doit relancer ce script que si l'on modifie les en-têtes, lors d'une nouvelle version par exemple.
Pour la compilation, proprement dite, le mieux est d'écrire un script. Dans le cas de figure où on a les sources dans le répertoire où on a décompacté les en-têtes Gtk+, soit comp notre fichier de script :
Et donc pour lancer notre compilation :
Il y a en fait d'autres lignes avec pas mal d'avertissements, car les unités gtk2.pas, etc. sont compilées la première fois.
On peut ensuite lancer notre programme :
Il ne se passe rien, ce qui est normal puisque on ne lui a rien vraiment demandé. On va pouvoir maintenant dans la suite de ce livre passer à des choses plus sérieuses.

### Avec Free Pascal version 2.0.x (1.9.x)

C'est plus simple :
Et pour lancer le programme c'est pareil :

## La compilation sous Windows
### Avec Free Pascal

Comme pour Linux, on peut utiliser un script. Dans le cas de figure où on a les sources dans le répertoire où on a décompacté les en-têtes Gtk+ et le compilateur dans le répertoire pp du même disque, le fichier comp.bat donne ceci :
Pour compiler, il faut ouvrir une fenêtre « Invite de commandes » (Démarrer - Programmes - Accessoires) et se placer dans le répertoire des sources :
L'exécution se lance par :
Ou via l'explorateur de fichiers.

# La notion d'objet

Avant de commencer l'étude de la création d'interface graphique grâce à Gtk+, il faut savoir que les objets graphiques de Gtk+ qui sont appelés en anglais des widgets (de Window Gadget) et en français des contrôles (ou contrôle fenêtré). Un contrôle est en fait une structure définissant les propriétés d'un objet associé à une large panoplie de fonctions permettant de manipuler ces objets.
Ici, le terme « objet » est à prendre au sens littéral, mais aussi au sens Programmation orientée objet (POO). En effet, bien que GTK+ soit écrit en C et non en C++, il introduit la notion d'héritage et les contrôles de Gtk+ suivent une hiérarchie bien définie. Ainsi tous les objets graphiques héritent des propriétés et des fonctions (qu'on appelle également méthodes dans la terminologie objet) d'une classe de base qui s'appelle GtkWidget. Lui même héritant des propriétés et des méthodes de la classe ancêtre GtkObject.
Ainsi la classe permettant d'afficher une fenêtre (GtkWindow) a bien sûr ses propres fonctions, mais grâce à l'héritage elle bénéficie aussi des fonctions des autres contrôles dont elle dérive. Dans l'ordre de l'héritage jusqu'à l'ancêtre commun : GtkBin, GtkContainer, GtkWidget et GtkObject.

# La gestion des évènements

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
La programmation des applications avec interface graphique est également nommée programmation événementielle. Contrairement à un programme séquentiel qui traite un ensemble de tâches puis s'arrête, le programme événementiel attend les ordres de l'utilisateur, un clic de souris, la frappe d'une touche, etc. pour exécuter ce qui est demandé et se replace en attente.
Dans un premier temps, lorsque l'utilisateur interagit avec l'application par l'entremise d'un contrôle (un bouton sur lequel on clique, une fenêtre que l'on ferme, etc.), ce dernier émet un signal (par exemple destroy lorsque l'on ferme une fenêtre). Chaque contrôle est associé à un ou plusieurs signaux et permet donc ainsi de programmer toutes les actions possibles.
Ce signal va ensuite être intercepté par une boucle évènementielle qui va vérifier qu'une action spécifique à ce signal et ce contrôle a bien été définie. Si tel est le cas, la fonction associée sera exécutée. Ce type de fonction s'appelle fonction callback en anglais qu'on peut traduire par fonction ou procédure de rappel.
Il faut donc créer une fonction de rappel pour chacun des évènements susceptible d'avoir lieu pendant l'exécution du programme et associer (ou connecter) cette fonction à un signal.
La première étape consiste donc à créer une fonction de rappel. Dans la majorité des cas, une fonction de rappel sera de cette forme :
Le paramètre widget est le contrôle qui a émis le signal, et data est une donnée supplémentaire qui peut être utilisée.
Ensuite, pour connecter un signal à une fonction de rappel, Gtk+ utilise une fonction de la bibliothèque GLib qui est :
Le premier paramètre instance, correspond au contrôle qui émet le signal. Cependant, la variable demandée par g_signal_connect étant de type gpointer (correspond à pointer du Pascal) et le contrôle de type PGtkWidget, il faut convertir ce dernier pour ne pas provoquer d'erreur lors de la compilation. Pour cela Gtk+ (ou dans ce cas GLib) fournit une fonction de conversion (pGTKOBJECT) qui sera à utiliser à chaque utilisation de cette fonction.
Le second paramètre detailed_signal, est le signal qui doit être intercepté par la boucle évènementielle. Dans ce livre, certains signaux seront utilisés dans les exemples, mais la rubrique « En savoir plus » donnera une liste complète des signaux qui peuvent être émis par un contrôle.
Le troisième paramètre c_handler, définit la fonction de rappel à associer au signal. Cette fois encore, il faudra utiliser une fonction de conversion qui est GTK_SIGNAL_FUNC(@fonction).
Le dernier paramètre data, permet de spécifier une donnée quelconque à laquelle la fonction de rappel peut avoir accès pour effectuer son travail correctement.
Une fois que les signaux sont connectés, il faut lancer la boucle évènementielle en appelant cette fonction :
Cela aura pour effet de faire entrer Gtk+ dans une boucle infinie qui ne pourra être stoppée que par l'appel de la fonction de fin de boucle qui est :
Ces fonctions correspondent au minimum nécessaire afin de pouvoir créer une application Gtk+ correcte. D'autres fonctions permettent une utilisation avancée des signaux et de la boucle évènementielle et sont traitées dans le chapitre GSignal du livre.
Un exemple simple de mise en place d'un signal destroy émis par une fenêtre quand elle se ferme, est fourni dans le chapitre GtkWindow.

# Le placement des contrôles

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Le placement des contrôles visuels avec Gtk+ peut paraître de prime abord complexe. Mais quand on a bien compris la logique du système, cela ne pose pas de problèmes particuliers.

## La particularité de Gtk+

De nombreuses API de gestion d'interface graphique fonctionne en positionnant le contrôle visuel de manière très précise en indiquant les coordonnées en pixels. Gtk+ ne fonctionne pas ainsi. À la création d'un contrôle, on lui fournit un ensemble de paramètres généraux et c'est Gtk+ qui va précisément s'occuper du positionnement, de la largeur, etc.
Les avantages sont une application qui s'adapte très bien à la taille de la fenêtre et donc à son redimensionnement, à la taille de l'écran, aux thèmes Gtk+, etc.

## Les conteneurs

Afin de placer un contrôle visuel de base comme un bouton, ou un champ de saisie dans une fenêtre, on va utiliser des conteneurs. Des conteneurs spéciaux existent qui regroupent les contrôles de manière verticale ou bien horizontale, il s'agit des GtkVBox et des GtkHBox.
* Voici un exemple de conteneur GtkVBox dans lequel on a placé des boutons. Ceux-ci s'empilent verticalement dans le conteneur.
* Ci-dessous, voici un exemple de conteneur GtkHBox.

## L'empilement des conteneurs

On peut placer un ou plusieurs conteneurs dans un autre conteneur. C'est d'ailleurs ce qu'on fait quand on place un GtkVBox par exemple dans une fenêtre. La fenêtre est un conteneur.
Cette combinaison va nous permettre de définir des interfaces très complexes.
Voici ci-dessus un exemple relativement simple. On peut bien entendu imbriquer plusieurs GtkBox l'une dans l'autre.

# Les fenêtres

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
GTK+ permet de gérer plusieurs types de fenêtres :
* GtkWindow : La fenêtre classique
* GtkDialog : La boîte de dialogue, c'est une fenêtre avec par exemple 2 boutons qui vont être le plus souvent OK et Annuler.
* GtkMessageDialog : La boîte de message, qui est une petite fenêtre permettant d'afficher un message d'erreur par exemple.

# Les conteneurs

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
GTK+ permet de gérer plusieurs types de conteneurs.
* Des classes ancêtres non utilisées directement et dont les fonctions sont intéressantes :
** GtkContainer
** GtkBox
** GtkBin
* Des classes utilisables et très utiles (certaines nous sont d'ailleurs déjà connues) :
** GtkHBox
** GtkVBox
** GtkTable : un autre système pour placer les contrôles
** GtkNotebook : les boîtes à onglets

# Les visuels

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Gtk+ possède toute une série de contrôles visuels, c'est à dire qui ne permettent que l'affichage de données :
* GtkLabel
* GtkImage
* GtkStatusBar
* GtkProgressBar
* GtkDrawingArea

# Les boutons

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Les boutons sont un élément important d'une interface graphique vu qu'ils sont facilement manipulables à la souris. Gtk+ permet la gestion de plusieurs contrôles de ce type :
* GtkButton
* GtkToggleButton
* GtkCheckButton
* GtkRadioButton

# La saisie de données

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
La saisie de données est l'autre élément important d'une interface graphique permettant d'établir la communication avec l'utilisateur. Gtk+ permet la gestion de plusieurs contrôles de ce type :
* GtkEntry
* GtkHScale
* GtkVScale
* GtkSpinButton

# Les listes déroulantes

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Les listes déroulantes ou combobox en anglais ont été complètement revues dans la version 2 de Gtk+, l'objet GtkCombo ne doit plus être utilisé. Elles sont liées maintenant aux objets des listes et des arbres. Elle peuvent néanmoins être utilisées de manière simple en mode texte :
* GtkComboBox
* GtkComboBoxEntry

# Les menus

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Les menus sont des contrôles complexes et sont donc découpés en plusieurs classes de contrôles.
La barre de menu tout d'abord :
* GtkMenuBar
Le menu en lui-même :
* GtkMenu
La classe de base des menus :
* GtkMenuShell
Les éléments d'un menu :
* GtkMenuItem
* GtkImageMenuItem
* GtkRadioMenuItem
* GtkCheckMenuItem
* GtkSeparatorMenuItem
* GtkTearoffMenuItem

### Étapes pour créer un menu

* Création d'une barre de menu
* Création d'un item de menu (exemple : Fichier)
* Attachement de cet item dans la barre de menu
* Création d'un menu
* Attachement de ce menu à l'item de la barre de menu (créé en 2.)
* Création d'un item de menu (exemple : Nouveau, Ouvrir, Sauvegarder, etc.)
* Attachement de cet item au menu (créé en 4.)
* Création des autres items (on boucle sur 6. et 7.)
* Si on veut une autre entrée de menu dans la barre de menu (exemple Édition, Aide, etc.), on recommence à 2.

# Les décorations

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Les contrôles décoratifs ne sont pas indispensables mais permettent de réaliser des interfaces graphiques plus agréables, plus ergonomiques. On va y trouver les cadres qui permettent de regrouper visuellement des contrôles et des lignes qui permettent au contraire de séparer les contrôles :
* GtkFrame
* GtkHSeparator
* GtkVSeparator

# La barre d'outils

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
La barre d'outils est un élément moderne participant à l'ergonomie d'une interface graphique. Elle est constituée comme le menu de plusieurs éléments :
* GtkToolbar
* GtkToolItem
* GtkToolButton
* GtkMenuToolButton
* GtkToggleToolButton
* GtkRadioToolButton
* GtkSeparatorToolItem

# Les sélections

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Les sélections sont des fenêtres de dialogue souvent utilisées dans des applications pour sélectionner différentes choses : un fichier, une couleur, etc. Gtk+ en met à disposition un certain nombre, parmi ceux-ci nous verrons :
* La sélection d'un fichier : GtkFileSelection
* La sélection d'une couleur : GtkColorSelectionDialog
Il existe également la sélection d'une police de caractères.

# Bibliographie

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie

## Gtk+ et Pascal
### Bibliographie

* Aucun livre à ma connaissance.

### Document PDF

* Florian Klaempfl et Michael Van Canneyt, http://www.freepascal.org/packages/gtk/gtk-1.pdf suivi de 2 3 4 5 : en anglais, Gtk+ version 1.

### Sites internet

* http://www.freepascal.org/packages/gtk/tutorial/pgtk-contents.html. En anglais, Gtk+ version 1.

## Gtk+
### Bibliographie

* David Odin, Programmation Linux avec GTK+, Eyrolles, Paris, 2000, 656 pages. Langage C et Gtk+ version 1.

### Sites internet

* http://www.gtk.org : site officiel de Gtk+. En anglais. Tutoriel , Manuel de référence et FAQ : Exemples et prototypes des fonctions en C, Gtk+ version 2.
* http://www.gtk-fr.org/ : wiki français, langage C et Gtk+ version 2.

## Pascal

Voir le livre Programmation Pascal.