# Programming with gtkmm 3

Murray Cumming
Bernhard Rieder Chapitre « Fonctions à délai échu ».
Jonathon Jongsma Chapitre « Tracés avec Cairo ». Chapitre « Travail sur le code source de gtkmm » Chapitre « Documents récents ».
Ole Laursen Parties du chapitre « Internationalisation ».
Marko Anastasov Chapitre « Impression ». Parties du chapitre « Internationalisation ».
Daniel Elstner Section « Structure de construction » du chapitre « Habillage des bibliothèques C avec gmmproc ».
David King Section on Gtk::Grid.
Pedro Ferreira Chapter on Keyboard Events.
Kjell Ahlstedt Parts of the update from gtkmm 2 to gtkmm 3.

Cet ouvrage explicite les concepts-clés de l'API C++ gtkmm pour la création d'interfaces utilisateur. Il présente également les principaux éléments graphiques d'interfaçage utilisateur (« widgets » en anglais, « contrôles » ou « éléments graphiques » en français).

2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Murray Cumming
2010-2011 Géode (Géodebay@gmail.com)
2010-2011 Bruno Brouard (annoa.b@gmail.com)

Permission vous est donnée de copier, distribuer et/ou modifier ce document selon les termes de la licence de documentation libre GNU, Version 1.2 ou ultérieure publiée par la Free Software Foundation sans section inaltérable, sans texte de première page de couverture ni texte de dernière page de couverture. Vous pouvez obtenir un exemplaire de cette licence en visitant le site Web de cette organisation ou en écrivant à : Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

## Introduction

### Cet ouvrage

Cet ouvrage explicite les concepts-clés de l'API C++ gtkmm pour la création d'interfaces utilisateur. Il présente également les principaux éléments graphiques de l'interfaçage utilisateur (« widgets » en anglais, « contrôles » ou « éléments graphiques » en français). Même s'il est fait mention de classes, de constructeurs et de fonctions membres, ces concepts ne sont pas examinés en détail. Par conséquent, pour une information complète sur l'API, il conviendra de vous reporter à la documentation de référence.

Cet ouvrage suppose une bonne connaissance du C++, ainsi que des méthodes de création de programmes avec ce langage.

Nous souhaitons vivement que vous nous rapportiez tout problème rencontré dans l'apprentissage de gtkmm avec ce document ; cela nous permet d'y apporter des améliorations en conséquence. Veuillez vous reporter au chapitre Contribution pour plus d'informations.

### gtkmm

gtkmm est un habillage (« wrapper ») C++ pour GTK+, une bibliothèque servant elle-même à créer des interfaces utilisateur graphique. gtkmm est sous licence LGPL : vous pouvez donc développer des logiciels ouverts, des logiciels libres ou même des logiciels commerciaux non-libres sans acheter de licence.

À l'origine gtkmm s'appelait « gtk-- » étant donné que GTK+ avait déjà un signe « + » dans le nom. Mais, comme « -- » n'est pas facilement indexé par les moteurs de recherche, le paquet logiciel a couramment été désigné par gtkmm et c'est ainsi que nous le désignerons dans la suite.

#### Pourquoi utiliser gtkmm plutôt que GTK+ ?

gtkmm vous permet d'écrire du code en se servant des techniques habituelles du C++ telles que l'encapsulation, la dérivation et le polymorphisme. En tant que programmeur C++, vous avez probablement déjà perçu que ces possibilités conduisent à un code plus clair et mieux organisé.

gtkmm possède une sécurité améliorée pour la typologie des données ; le compilateur détecte donc des erreurs qui ne seraient apparues qu'au moment de l'exécution en C. L'utilisation de ces types spécifiques rend l'API plus claire puisque vous pouvez voir les types à utiliser à la simple lecture de la déclaration d'une fonction membre.

L'héritage s'utilise pour dériver de nouveaux éléments graphiques. Dans un code C de GTK+, ce processus de dérivation est si complexe et sujet à erreur que quasiment aucun programmeur C ne l'utilise. En tant que développeur C++, vous savez que la dérivation est une technique essentielle dans la programmation orientée objet.

L'utilisation des instances membres simplifie la gestion de la mémoire. Tous les éléments graphiques C de GTK+ sont traités en utilisant des pointeurs. Vous savez, comme tout programmeur C++, que les pointeurs doivent, si possible, être évités.

Comparé à GTK+, avec l'utilisation des noms de fonctions préfixés et de nombreuses macros de forçage de type, gtkmm nécessite moins de code.

#### gtkmm comparée à Qt

Qt de Trolltech est le plus proche concurrent de gtkmm ; cela mérite une explication.

Les développeurs inclinent à préférer gtkmm à Qt, car gtkmm fait les choses d'une façon plus proche du C++. Qt est né à une époque où le C++ et les bibliothèques standard n'étaient, ni normalisées, ni bien prises en charge par les compilateurs. Ainsi, nombre de choses, aujourd'hui dans la bibliothèque normalisée, sont en double, comme les conteneurs et des définitions de types. Plus significatif encore, Trolltech a modifié le langage C++ afin de fournir des signaux, de sorte que les classes Qt ne se marient pas facilement avec des classes non-Qt. gtkmm a été capable d'utiliser du C++ standard sans modification pour fournir des signaux sans modification du langage C++. Consultez la foire aux questions pour plus de précisions.

#### gtkmm est un habillage

gtkmm n'est pas une boîte à outils en C++ natif, mais un habillage C++ d'une boîte à outils en C. Cette séparation entre interface et implémentation a des avantages. Les développeurs gtkmm passent la majeure partie de leur temps à discuter de la manière dont gtkmm peut présenter l'API la plus claire, sans compromis délicat en raison d'obscurs détails techniques. Nous contribuons un peu aux fondements du code GTK+ sous-jacent, mais les codeurs en C, Perl et Python, etc. font de même. Ainsi GTK+ bénéficie d'une base d'utilisateurs plus large que n'aurait une boîte à outils spécifique à un langage — il y a plus d'implémentations, plus de développeurs, plus de testeurs et plus d'utilisateurs.

## Installation

### Dépendances

Before attempting to install gtkmm 3.0, you might first need to install these other packages.

- libsigc++ 2.0

- GTK+ 3.0

- cairomm

- pangomm

- atkmm

Ces dépendances ont elles-mêmes leurs propres dépendances, comprenant les applications et bibliothèques suivantes :

- pkg-config

- glib

- ATK

- Pango

- cairo

- gdk-pixbuf

### Unix et Linux

#### Paquets logiciels pré-compilés

Les versions récentes de gtkmm sont empaquetées par pratiquement toutes les grandes distributions Linux. Donc, si vous êtes un utilisateur de Linux, vous pourrez probablement débuter avec gtkmm en installant son paquet à partir du dépôt officiel de votre distribution. Parmi les distributions qui mettent à disposition gtkmm dans leurs dépôts, citons Debian, Ubuntu, Red Hat, Fedora, Mandriva, Suse, mais il y en a beaucoup d'autres.

Les noms des paquets gtkmm varient selon les distributions (par exemple, libgtkmm3.0-dev sur Debian et Ubuntu ou gtkmm30-devel sur Red Hat Fedora) ; vérifiez donc avec le programme de gestion de paquets de votre distribution la dénomination correcte, puis installez-le comme vous feriez pour tout autre paquet.

The package names will not change when new API/ABI-compatible versions of gtkmm are released. Otherwise they would not be API/ABI-compatible. So don't be surprised, for instance, to find gtkmm 3.2 supplied by Debian's libgtkmm3.0-dev package.

#### Installation à partir des sources

Si votre distribution ne met pas à disposition un paquet pré-compilé de gtkmm, ou bien si vous souhaitez installer une version différente de celle fournie, vous pouvez installer gtkmm à partir des sources. Le code source de gtkmm est téléchargeable à partir de .

Après installation de toutes les dépendances, téléchargez le code source de gtkmm, extrayez-le et déplacez vous dans le nouveau répertoire. gtkmm se construit et s'installe en saisissant cette suite de commandes :

    # ./configure
    # make
    # make install

N'oubliez pas qu'avec un système d'exploitation Unix ou Linux, vous aurez besoin d'être `root` (avoir les privilèges administrateur) pour installer le logiciel. La commande `su` vous confère temporairement le statut d'administrateur après la saisie du mot de passe `root`.

Le script `configure` effectue une vérification pour s'assurer que toutes les dépendances requises sont déjà installées. Si une quelconque manque, il s'arrête et affiche une erreur.

Par défaut, gtkmm est installé dans le répertoire `/usr/local`. Sur certains systèmes, il sera peut-être nécessaire de l'installer à un autre emplacement. Par exemple, sur les systèmes Linux Red Hat, vous utiliserez peut-être l'option `--prefix` avec configure, ainsi :

    # ./configure --prefix=/usr

Il faut être très précautionneux si vous faites une installation avec comme préfixe un des répertoires système standard, comme `/usr`. Les distributions Linux installent leurs paquets logiciels dans `/usr` ; donc, le fait d'installer un paquet source dans ce répertoire peut corrompre ou entrer en conflit avec un logiciel installé par le système de gestion des paquets de votre distribution. Dans un monde idéal, vous devriez utiliser un préfixe à part pour tous les logiciels installés à partir des sources.

Si vous souhaitez participer au développement de gtkmm ou expérimenter de nouvelles fonctionnalités, vous pouvez installer gtkmm à partir du dépôt « git ». La plupart des utilisateurs n'ont jamais besoin de faire ainsi, mais si vous êtes intéressé par une participation au développement de gtkmm, consultez l'annexe Travail sur le code source de gtkmm

### Windows Microsoft

GTK+ et gtkmm ont été conçus pour bien fonctionner avec Windows Microsoft ; les développeurs poussent à son utilisation sur les plates-formes win32. Mais, Windows ne dispose d'aucune norme d'installation pour les bibliothèques de développement. Consultez les pages spécifiques relatives aux instructions et notes spécifiques à l'Installation sous Windows.

## Fondamentaux

Ce chapitre présente quelques aspects parmi les plus importants du codage avec gtkmm. Nous les montrerons à partir d'exemples simples et fonctionnels de code. Ce n'est toutefois qu'un avant-goût et vous aurez besoin d'examiner les autres chapitres pour des informations plus conséquentes.

Vos connaissances en matière de C++ vous seront d'un bon secours pour gtkmm comme pour toute autre bibliothèque. À moins que nous n'indiquions le contraire, vous pouvez vous attendre à ce que les classes gtkmm aient un comportement identique à celui des autres classes C++ et donc à utiliser vos techniques C++ habituelles avec elles.

### Un exemple simple

Comme entrée en matière avec gtkmm, nous débuterons avec le programme le plus simple qui soit. Ce programme crée une fenêtre vide de 200 x 200 pixels.

Code source

File: `base.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <gtkmm.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      Gtk::Window window;

      Gtk::Main::run(window);

      return EXIT_SUCCESS;
    }

Détaillons maintenant chaque ligne de l'exemple

    #include <gtkmm.h>

Tous les programmes gtkmm doivent inclure certains fichiers d'en-tête gtkmm ; `gtkmm.h` inclut la totalité du jeu d'en-têtes gtkmm. En règle générale, ce n'est pas une bonne idée parce que cette façon de faire inclut à peu près un mégaoctet d'en-têtes, mais pour des programmes simples, c'est acceptable.

La ligne suivante :

    Gtk::Main kit(argc, argv);

crée un objet Gtk::Main, nécessaire pour toutes les applications gtkmm. Le constructeur de cet objet initialise gtkmm et vérifie les paramètres passés à l'application sur la ligne de commande. Il examine les options standard, comme `-display`, les enlève de la liste des paramètres en ne gardant que celles qu'il n'a pas reconnues pour un traitement éventuel par l'application. Cela garantit que toutes les applications gtkmm accepteront le même ensemble de paramètres normalisés.

Les deux lignes de code suivantes créent et affichent une fenêtre :

    Gtk::Window window;

La deuxième ligne affiche la fenêtre et entre dans la boucle principale de traitement, boucle dont on ne sort qu'à la fermeture de la fenêtre.

    Gtk::Main::run(window);

Après avoir incorporé ces lignes de code source dans `simple.cc`, vous pouvez compiler ce programme avec la commande :

    g++ simple.cc -o simple `pkg-config gtkmm-3.0 --cflags --libs`

Notez qu'il est impératif d'entourer l'appel à `pkg-config` d'apostrophes inverses. Elles demandent à l'interpréteur de commandes d'exécuter la commande entourée et d'intégrer au même emplacement la sortie correspondante dans la ligne de commande.

### Fichiers d'en-têtes et édition des liens

Même si nous avons indiqué la commande de compilation pour cet exemple simple, vous devriez vraiment utiliser les outils automake et autoconf tels que décrits dans « Autoconf, Automake, Libtool » par G.V. Vaughan et autres. Les exemples utilisés dans le présent ouvrage sont incorporés dans le paquet logiciel de gtkmm, avec les fichiers de construction appropriés ; nous ne mentionnerons donc pas ces commandes dans le futur. Il conviendra simplement de trouver le répertoire convenable, de s'y placer et de saisir `make`.

Pour simplifier la compilation, nous utilisons `pkg-config`, présent dans toutes les installations de gtkmm (correctement effectuées). Ce programme « sait » quels sont les commutateurs nécessaires à la compilation des programmes utilisant gtkmm. L'option `--cflags` demande à `pkg-config` de produire la liste des répertoires des en-têtes, répertoires que le compilateur devra parcourir ; l'option `--libs` demande la liste des bibliothèques nécessaires à l'édition des liens par le compilateur ainsi que les répertoires où elles se trouvent. Essayez de lancer directement cette commande à l'invite de votre terminal pour voir les résultats sur votre système.

Mais, il est plus simple d'utiliser la macro `PKG_CHECK_MODULES()` dans un fichier standard `configure.ac` avec autoconf et automake. Par exemple :

    PKG_CHECK_MODULES([MYAPP], [gtkmm-3.0 >= 3.0.0])

Cette commande vérifie la présence de gtkmm et définit les variables MYAPP_LIBS et MYAPP_CFLAGS à utiliser dans vos fichiers `Makefile.am`.

gtkmm-3.0 is the name of the current stable API. There was an older API called gtkmm-2-4 which installs in parallel when it is available. There were several versions of gtkmm-2.4, such as gtkmm 2.10 and there will be several versions of the gtkmm-3.0 API. Note that the API name does not change for every version because that would be an incompatible API and ABI break. Theoretically, there might be a future gtkmm-4.0 API which would install in parallel with gtkmm-3.0 without affecting existing applications.

Note that if you mention extra modules in addition to gtkmm-3.0, they should be separated by spaces, not commas.

Openismus fournit une Aide sur les fondamentaux avec automake et autoconf.

### Éléments graphiques

Les applications gtkmm sont constituées par des fenêtres comportant des éléments graphiques, comme des boutons ou des boîtes de texte. Dans certains autres systèmes, les éléments graphiques sont appelés « contrôles ». Pour chaque élément graphique dans les fenêtres d'une application, il existe un objet C++ dans le code de l'application. Il vous suffit donc d'appeler une fonction membre de la classe de l'élément graphique pour en modifier l'apparence.

Les éléments graphiques sont disposés dans des conteneurs tels que cadres et bloc-notes, avec une hiérarchie entre éléments graphiques. Certains de ces conteneurs d'éléments graphiques, comme les Gtk::Grid, ne sont pas visibles ‑ ils ne participent qu'à la disposition relative des éléments graphiques. Voici un exemple de code qui place deux contrôles Gtk::Button dans un conteneur d'éléments graphiques Gtk::VBox :

    m_box.pack_start(m_Button1);
    m_box.pack_start(m_Button2);

et voici comment ajouter le Gtk::VBox, contenant ces boutons, dans un Gtk::Frame, qui possède un cadre et un titre visibles :

    m_frame.add(m_box);

La plupart des chapitres de cet ouvrage traitent d'éléments graphiques spécifiques. Consultez la section Éléments graphiques conteneurs pour de plus amples précisions sur la manière de placer des éléments graphiques dans des conteneurs.

Même s'il est possible de préciser la disposition et l'apparence des fenêtres ainsi que des éléments graphiques dans le code C++, vous trouverez certainement plus pratique de concevoir vos interfaces utilisateur avec `Glade` et de les charger avec `Gtk::Builder` à l'exécution de l'application. Consultez le chapitre Glade et Gtk::Builder.

Même si les instances d'éléments graphiques gtkmm ont des durées de vie et des portées comme toute autre classe C++, gtkmm dispose d'une fonctionnalité optionnelle que vous pourrez observer dans certains exemples ; elle permet de gagner du temps. `Gtk::manage()` vous permet d'indiquer qu'un élément graphique enfant est détenu par le conteneur dans lequel vous le placez. Cela permet de créer l'élément graphique avec `new`, l'ajouter au conteneur et ne pas vous préoccuper de sa destruction. Vous en apprendrez plus au sujet des techniques de gestion de la mémoire dans gtkmm dans le chapitre Gestion de la mémoire.

### Signaux

gtkmm, comme la plupart des boîtes à outils GUI, est piloté par événements. Lorsqu'un événement survient, comme un clic de bouton de souris, le signal approprié est émis par l'élément graphique pointé. Chaque élément graphique dispose d'un jeu de signaux à émettre. Pour qu'un clic de bouton se traduise par une action, nous mettons en œuvre un gestionnaire de signal pour capturer le signal « clicked » du bouton.

gtkmm utilise la bibliothèque libsigc++ pour implémenter les signaux. Voici un exemple de ligne de code qui connecte le signal « clicked » émis par un Gtk::Button à un gestionnaire de signal nommé « on_button_clicked » :

    m_button1.signal_clicked().connect( sigc::mem_fun(*this,
      &HelloWorld::on_button_clicked) );

Pour plus de détails à propos des signaux, consultez cette annexe.

Pour des informations sur l'implémentation de vos propres signaux au lieu d'une simple connexion aux signaux prédéfinis de gtkmm, consultez cette annexe.

### Glib::ustring

Peut-être serez-vous surpris d'apprendre que gtkmm n'utilise pas la classe std::string dans ses interfaces. À la place, gtkmm utilise la classe Glib::ustring ; les deux classes sont tout à fait semblables et tellement amalgamées que vous pouvez vraiment prétendre que chaque Glib::ustring est un std::string et ignorer la suite de ce paragraphe. Mais poursuivez la lecture si vous voulez utiliser des langues autres que l'anglais dans vos applications.

std::string utilise 8 bits par caractère, mais 8 bits ne sont pas suffisants pour coder des langues telles que l'arabe, le chinois ou le japonais. Même si les codages pour ces langues ont maintenant été définis par le Consortium Unicode, les langages informatiques C et C++ ne fournissent pas encore une prise en charge normalisée de l'Unicode. GTK+ et GNOME ont choisi d'implémenter l'Unicode en utilisant l'UTF-8 ; c'est ce codage qui est intégré dans Glib::ustring. Il fournit une interface pratiquement identique à std::string, tout en permettant des conversions automatiques de ou vers std::string.

Un des avantages de UTF-8 est que son utilisation n'est pas obligatoire, sauf à le vouloir ; vous n'avez pas besoin de retoucher tout votre code sur le champ. std::string fonctionne toujours bien avec les chaînes ASCII 7 bits. Mais si vous essayez de régionaliser vos applications pour des langues comme le chinois, par exemple, vous constaterez des erreurs étranges, voire des blocages. Alors, il ne vous reste plus qu'à utiliser dès maintenant Glib::ustring à la place.

Notez que UTF-8 n'est pas compatible avec des encodages 8 bits comme ISO-8859-1. Par exemple, les trémas de l'allemand ne font pas partie de la gamme des caractères ASCII ; ils nécessitent plus d'un octet en UTF-8. Si votre code comporte des chaînes littérales sur 8 bits, vous devez les convertir en UTF-8 (par exemple, la formule de salut bavaroise « Grüß Gott » devient « Gr\xC3\xBC\xC3\x9F Gott »).

Vous devez éviter les arithmétiques de pointeurs dans le style du C et les fonctions comme strlen(). En UTF-8, chaque caractère peut nécessiter de 1 à 6 octets ; il n'est donc pas possible de présupposer que l'octet suivant est un nouveau caractère. Glib::ustring se préoccupe de ces détails à votre place ; vous pouvez employer des fonctions membres telles que Glib::ustring::substr() en pensant caractères et non octets.

Contrairement à la solution de l'Unicode UCS-2 de Windows, UTF-8 ne requiert aucune option spéciale de compilation pour le traitement des chaînes de caractères ; en conséquence, il n'existe pas de bibliothèque ou d'exécutable Unicode incompatible avec ceux en ASCII.

Référence

Consultez le chapitre sur l'Internationalisation pour des informations concernant les chaînes littérales UTF-8.

### Types intermédiaires

Some API related to gtkmm uses intermediate data containers, such as Glib::StringArrayHandle, instead of a specific Standard C++ container such as std::vector or std::list, though gtkmm itself now uses just std::vector since gtkmm 3.0.

You should not declare these types yourself. You should instead use whatever Standard C++ container you prefer. glibmm will do the conversion for you. Here are some of these intermediate types:

- Glib::StringArrayHandle ou Glib::ArrayHandle<Glib::ustring> : utilisez std::vector<Glib::ustring>, std::list<Glib::ustring>, `const char*[]`, etc.

- Glib::ListHandle<Gtk::Widget*> : utilisez std::vector<Gtk::Widget*>, std::list<Gtk::Widget*>, etc.

- Glib::SListHandle<Gtk::Widget*> : utilisez std::vector<Gtk::Widget*>, std::list<Gtk::Widget*>, etc.

### Mélange des API C et C++

Vous pouvez utiliser des API C, si elles n'ont pas encore d'interfaces C++ commodes. Il n'y a généralement aucun problème avec l'utilisation des API C dans le C++ ; gtkmm vous aide en donnant un accès à l'objet C sous-jacent et en facilitant la création d'un objet C++ enveloppe de l'objet C, à condition que l'API C soit également fondée sur le système GObject.

Pour utiliser un élément gtkmm avec une fonction C demandant un type d'objet GObject C, servez-vous de la fonction `gobj()` pour obtenir un pointeur sur l'instance du GObject sous-jacent. Par exemple

    Gtk::Button* button = new Gtk::Button("exemple");
    gtk_button_do_something_new(button->gobj());

Pour obtenir un objet gtkmm à partir d'un élément GObject C, utilisez la fonction Glib::wrap(). Par exemple

    GtkButton* cbutton = get_a_button();
    Gtk::Button* button = Glib::wrap(cbutton);

### Hello World en gtkmm

Nous en savons maintenant assez pour examiner un exemple réel. Pour reprendre une vieille tradition du monde de l'informatique, nous allons maintenant présenter le programme « Hello World » accommodé à la gtkmm :

Code source

File: `helloworld.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_HELLOWORLD_H
    #define GTKMM_EXAMPLE_HELLOWORLD_H

    #include <gtkmm/button.h>
    #include <gtkmm/window.h>

    class HelloWorld : public Gtk::Window
    {

    public:
      HelloWorld();
      virtual ~HelloWorld();

    protected:
      //Signal handlers:
      void on_button_clicked();

      //Member widgets:
      Gtk::Button m_button;
    };

    #endif // GTKMM_EXAMPLE_HELLOWORLD_H

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "helloworld.h"
    #include <gtkmm/main.h>

    int main (int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      HelloWorld helloworld;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(helloworld);

      return 0;
    }

File: `helloworld.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "helloworld.h"
    #include <iostream>

    HelloWorld::HelloWorld()
    : m_button("Hello World")   // creates a new button with label "Hello World".
    {
      // Sets the border width of the window.
      set_border_width(10);

      // When the button receives the "clicked" signal, it will call the
      // on_button_clicked() method defined below.
      m_button.signal_clicked().connect(sigc::mem_fun(*this,
                  &HelloWorld::on_button_clicked));

      // This packs the button into the Window (a container).
      add(m_button);

      // The final step is to display this newly created widget...
      m_button.show();
    }

    HelloWorld::~HelloWorld()
    {
    }

    void HelloWorld::on_button_clicked()
    {
      std::cout << "Hello World" << std::endl;
    }

Essayez de le compiler et de le lancer avant de poursuivre. Vous devriez voir quelque chose comme :

Hello World

Tout à fait palpitant, n'est-ce-pas ? Examinons le code. D'abord, la classe HelloWorld :

    class HelloWorld : public Gtk::Window
    {

    public:
      HelloWorld();
      virtual ~HelloWorld();

    protected:
      //Gestionnaire de signal :
      virtual void on_button_clicked();

      //éléments graphiques membres :
      Gtk::Button m_button;
    };

Cette classe implémente la fenêtre « Hello World ». Elle est dérivée de la classe Gtk::Window et possède un simple Gtk::Button comme membre. Nous avons pris le parti d'utiliser le constructeur pour faire toutes les tâches d'initialisation de la fenêtre, y compris la définition des signaux. Voici le code, les commentaires sont omis :

    HelloWorld::HelloWorld()
    :
      m_button ("Hello World")
    {
      set_border_width(10);
      m_button.signal_clicked().connect(sigc::mem_fun(*this,
        &HelloWorld::on_button_clicked));
      add(m_button);.
      m_button.show();
    }

Notez que nous avons utilisé une instruction d'initialisation pour étiqueter l'objet `m_button` avec « Hello World ».

Puis nous appelons la fonction membre set_border_width() de l'objet Window. Elle fixe la dimension de l'espace entre les côtés de la fenêtre et l'élément graphique qu'elle contient.

Ensuite, nous raccordons un gestionnaire de signal pour le signal `clicked` du `m_button`. Le gestionnaire affiche sur `stdout` notre salut amical.

Puis, nous utilisons la fonction membre add() avec l'objet Window pour y placer le `m_button` (add() est une fonction membre de la classe Gtk::Container que nous décrirons dans le chapitre des éléments graphiques conteneurs). La fonction add() place l'élément graphique dans la fenêtre, mais elle ne l'affiche pas. Les éléments graphiques gtkmm sont toujours invisibles à leur création — pour les afficher, vous devez faire appel à la fonction show(), ce que nous faisons à la ligne suivante.

Maintenant examinons la fonction `main()` du programme. La voici, sans commentaire :

    int main(int argc, char** argv)
    {
      Gtk::Main kit(argc, argv);

      HelloWorld helloworld;
      Gtk::Main::run(helloworld);

      return 0;
    }

Tout d'abord nous créons un exemplaire d'un objet nommé `kit`. Il est du type Gtk::Main. Tout programme gtkmm doit en posséder un. Nous passons les paramètres en ligne de commande à son constructeur. Il prélève les arguments dont il a besoin et vous laisse le reste, comme nous l'avons expliqué plus haut.

Ensuite nous définissons un objet de la classe HelloWorld dont le constructeur ne prend pas de paramètres ; il n'est pas encore visible. Quand nous appelons Gtk::Main::run(), avec comme paramètre la fenêtre helloworld, la fonction main() affiche la fenêtre et démarre la boucle des événements gtkmm. Lorsque la boucle des événements gtkmm est inactive, elle est en attente des actions de l'utilisateur pour y répondre de façon appropriée. Quand l'utilisateur ferme la fenêtre, la fonction run() retourne et déclenche l'exécution de la dernière ligne de la fonction main(). Et le programme se termine.

## Changes in gtkmm 3

gtkmm-3.0 is a new version of the gtkmm API that installs in parallel with the older gtkmm-2.4 API. The last version of the gtkmm-2.4 API was gtkmm 2.24. gtkmm 3 has no major fundamental differences to gtkmm 2 but does make several small changes that were not possible while maintaining binary compatibility. If you never used the gtkmm-2.4 API then you can safely ignore this chapter.

gtkmm 3's library is called `libgtkmm-3.0` rather than `libgtkmm-2.4` and installs its headers in a similarly-versioned directory, so your pkg-config check should ask for `gtkmm-3.0` rather than `gtkmm-2.4`.

gtkmm 3 added some new classes:

1. Gtk::AppChooser, Gtk::AppChooserButton, Gtk::AppChooserDialog allow the user to select an installed application to open a particularl type of content.

2. Gtk::Grid is a new container widget that will eventually replace Gtk::Box. It arranges its children according to properties of those children rather than its own layout details.

3. Gtk::Switch displays On/Off states more explictly than Gtk::CheckBox. It may be useful, for instance, when allowing users to activate hardware.

gtkmm 3 also made several small changes to the API, which you will probably encounter when porting code that used gtkmm-2.4. Here is a short list:

1. Gtk::CellLayout, used by Gtk::IconView, Gtk::TreeView::Column and Gtk::ComboBox, now has a Gtk::CellArea which can be used to specify more details of how the CellRenderers are arranged and aligned.

2. Gtk::ComboBox now derives from CellLayout, allowing easier layout and alignment of its Gtk::CellRenderers.

3. Gtk::Adjustment and IconSet and Gdk::Cursor are now used via Glib::RefPtr.

4. Gtk::Box, Gtk::ButtonBox, Gtk::IconView, Gtk::Paned, Gtk::ProgressBar, Gtk::ScaleButton, Gtk::ScrollBar and Gtk::Separator now derive from Gtk::Orientable, allowing their orientation (vertical or horizontal) to be specified without requiring the use of a derived class such as Gtk::HBox.

5. Gtk::IconView, Gtk::TextView, Gtk::TreeView and other widgets derive from Scrollable instead of having their own methods such as get_vadjustment() and instead of having their won set_scroll_adjustments signal.

6. Gtk::Style and Gtk::Rc were removed, replaced by Gtk::StyleContext, and Gtk::StyleProviders, such as Gtk::CssProvider.

7. Widget::on_expose_event() was replaced by Widget::on_draw(), which assumes that cairomm is used for drawing, via the provided Cairo::Context and does not require you to call Cairo::Context::clip().

8. Gdk::RGBA replaces Color, adding an alpha component for opacity. Colormap was removed, along with its awkward use to allocate colors.

9. Gdk::Pixmap and Gdk::Bitmap were removed in favour of Gdk::Pixbuf.

10. Gdk::Drawable was removed, with its methods moving into Gdk::Window.

11. We now use std::vector in several methods instead of the intermediate *Handle types to make the API clearer.

All deprecated API was removed in gtkmm 3.0, though there will be new deprecations in future versions.

As a first step to porting your source code to gtkmm-3.0; you should probably ensure that your application builds with the deprecated gtkmm-2.4; API disabled, by defining macro such as GTK_DISABLE_DEPRECATED. There are some autotools macros that can help with this by defining them optionally at build time. See the gtkmm 3 porting wiki page for more details.

## Boutons

gtkmm met à votre disposition quatre types basiques de boutons :

Bouton poussoir

  Gtk::Button. Standard buttons, usually marked with a label or picture. Pushing one triggers an action. See the Button section.

Bouton bascule

  Gtk::ToggleButton. Unlike a normal Button, which springs back up, a ToggleButton stays down until you press it again. It might be useful as an on/off switch. See the ToggleButton section.

Case à cocher

  Gtk::CheckButton. These act like ToggleButtons, but show their state in small squares, with their label at the side. They should be used in most situations which require an on/off setting. See the CheckBox section.

Bouton radio

  Gtk::RadioButton. Named after the station selectors on old car radios, these buttons are used in groups for options which are mutually exclusive. Pressing one causes all the others in its group to turn off. They are similar to CheckBoxes (a small widget with a label at the side), but usually look different. See the RadioButton section.

Notez qu'en raison du système des thèmes d'apparence de GTK+, l'aspect de ces éléments graphiques peut varier. Dans le cas des cases à cocher et des boutons radio, les variations peuvent être conséquentes.

### Bouton

#### Constructeurs

Il y a deux façons de créer un bouton. Vous pouvez indiquer la chaîne étiquette dans le constructeur de Gtk::Button ou bien la définir plus tard avec set_label().

Pour définir une touche d'accès direct de navigation au clavier, placez un caractère souligné avant l'un des caractères de l'étiquette et définissez à `true` le paramètre optionnel `mnemonic` (mnémonique). Par exemple :

    Gtk::Button* pButton = new Gtk::Button("_Quelquechose", true);

Chaque fois que cela est possible, vous devez utiliser les éléments du catalogue pour être cohérent avec les autres applications et en améliorer l'aspect en utilisant des icônes. Par exemple,

    Gtk::Button* pButton = new Gtk::Button(Gtk::Stock::OK);

utilise un texte normalisé, dans toutes les langues, avec un raccourci clavier et une icône standard.

Gtk::Button est aussi un conteneur ; vous pouvez donc y mettre n'importe quel autre élément graphique à l'intérieur, comme une Gtk::Image.

Référence

#### Exemple

Cet exemple crée un bouton avec image et étiquette.

Exemple de bouton

Code source

File: `buttons.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_BUTTONS_H
    #define GTKMM_EXAMPLE_BUTTONS_H

    #include <gtkmm/window.h>
    #include <gtkmm/button.h>

    class Buttons : public Gtk::Window
    {
    public:
      Buttons();
      virtual ~Buttons();

    protected:
      //Signal handlers:
      void on_button_clicked();

      //Child widgets:
      Gtk::Button m_button;
    };

    #endif //GTKMM_EXAMPLE_BUTTONS_H

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "buttons.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      Buttons buttons;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(buttons);

      return 0;
    }

File: `buttons.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "buttons.h"
    #include <iostream>

    Buttons::Buttons()
    {
      m_button.add_pixlabel("info.xpm", "cool button");

      set_title("Pixmap'd buttons!");
      set_border_width(10);

      m_button.signal_clicked().connect( sigc::mem_fun(*this,
                  &Buttons::on_button_clicked) );

      add(m_button);

      show_all_children();
    }

    Buttons::~Buttons()
    {
    }

    void Buttons::on_button_clicked()
    {
      std::cout << "The Button was clicked." << std::endl;
    }

#### Signaux

L'élément graphique Gtk::Button émet les signaux suivants, mais la plupart du temps vous ne gérerez que le signal `clicked` (cliqué) :

`pressed (enfoncé)`

  Émis quand le bouton est enfoncé.

`released (relâché)`

  Émis quand le bouton est relâché.

`clicked (cliqué)`

  Émis quand le bouton est enfoncé et relâché.

`enter (entré)`

  Émis quand le pointeur de souris entre dans la fenêtre du bouton.

`leave (quitté)`

  Émis lorsque le pointeur de souris sort de la fenêtre du bouton.

### Bouton bascule

Un objet de la classe ToggleButton est semblable à un objet de la classe Button, mais les boutons bascules restent activés, ou enfoncés, jusqu'à ce qu'ils soient à nouveau cliqués.

Pour obtenir l'état du ToggleButton, utilisez la fonction membre get_active(). Elle renvoie `true` si le bouton est « enfoncé ». Vous pouvez aussi définir l'état du bouton bascule avec set_active(). Notez que, si vous faites cet appel et que l'état du bouton est effectivement modifié, le signal « clicked » sera émis : ce comportement est celui habituellement recherché.

Utilisez la fonction membre toggled() pour inverser l'état du bouton, au lieu de l'obliger à être enfoncé ou pas : l'état du bouton est modifié et le signal `toggled` (basculé) est émis.

Gtk::ToggleButton est de grande utilité en tant que classe de base pour les classes Gtk::CheckButton et Gtk::RadioButton.

Référence

### Case à cocher

La classe Gtk::CheckButton hérite de la classe Gtk::ToggleButton. La seule réelle différence entre les deux classes se situe au niveau de l'aspect graphique du Gtk::CheckButton. Vous obtenez, définissez et inversez son état à l'aide des mêmes fonctions membres que Gtk::ToggleButton.

Référence

#### Exemple

Case à cocher

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_BUTTONS_H
    #define GTKMM_EXAMPLE_BUTTONS_H

    #include <gtkmm/window.h>
    #include <gtkmm/checkbutton.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_clicked();

      //Child widgets:
      Gtk::CheckButton m_button;
    };

    #endif //GTKMM_EXAMPLE_BUTTONS_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_button("something")
    {
      set_title("checkbutton example");
      set_border_width(10);

      m_button.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_clicked) );

      add(m_button);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_clicked()
    {
      std::cout << "The Button was clicked: state="
          << (m_button.get_active() ? "true" : "false")
          << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

### Bouton radio

De même que les cases à cocher, les boutons radio héritent aussi des propriétés des Gtk::ToggleButton, mais les boutons radio fonctionnent en groupe et, dans un groupe, un seul et unique bouton radio peut être sélectionné à un moment donné.

#### Groupes

Il y a deux façons de définir un groupe de boutons radio. La première est de créer les boutons et de définir leur groupement après-coup. Seuls les deux premiers constructeurs sont utilisés dans ce cas. Dans l'exemple suivant, nous créons une nouvelle classe de fenêtre nommée RadioButtons dans laquelle nous plaçons trois boutons radio :

    class RadioButtons : public Gtk::Window
    {
    public:
        RadioButtons();

    protected:
        Gtk::RadioButton m_rb1, m_rb2, m_rb3;
    };

    RadioButtons::RadioButtons()
      : m_rb1("Bouton1"),
        m_rb2("Bouton2"),
        m_rb3("Bouton3")
    {
        Gtk::RadioButton::Group group = m_rb1.get_group();
        m_rb2.set_group(group);
        m_rb3.set_group(group);
    }

Nous indiquons à gtkmm de placer les trois objets RadioButton dans un même groupe en obtenant un pointeur sur le groupe avec get_group() et en utilisant set_group() pour faire en sorte que les autres RadioButton partagent le même groupe.

Notez qu'il n'est pas possible d'écrire simplement

    m_rb2.set_group(m_rb1.get_group()); // ne fonctionne pas !

étant donné que set_group() modifie le groupe et qu'en conséquence, le pointeur n'est pas constant.

La deuxième façon pour grouper des boutons radio consiste à créer un groupement au préalable, puis y intégrer les boutons. Voici un exemple :

    class RadioButtons : public Gtk::Window
    {
    public:
        RadioButtons();
    };

    RadioButtons::RadioButtons()
    {
        Gtk::RadioButton::Group group;
        Gtk::RadioButton *m_rb1 = Gtk::manage(
          new Gtk::RadioButton(group,"Bouton1"));
        Gtk::RadioButton *m_rb2 = manage(
          new Gtk::RadioButton(group,"Bouton2"));
        Gtk::RadioButton *m_rb3 = manage(
          new Gtk::RadioButton(group,"Bouton3"));
    }

Nous générons un nouveau groupe par une simple déclaration de variable, `group`, du type Gtk::RadioButton::Group, puis nous créons trois boutons radio avec le constructeur indiquant qu'ils font partie du groupe `group`.

#### Fonctions membres

À leur création, les objets de la classe RadioButtons sont « inactifs », donc, lors de la création du groupe, tous les boutons sont désactivés. N'oubliez donc pas d'en activer un avec set_active() :

Référence

#### Exemple

L'exemple suivant montre l'utilisation de la classe RadioButton :

Bouton radio

Code source

File: `radiobuttons.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_RADIOBUTTONS_H
    #define GTKMM_EXAMPLE_RADIOBUTTONS_H

    #include <gtkmm/box.h>
    #include <gtkmm/window.h>
    #include <gtkmm/radiobutton.h>
    #include <gtkmm/separator.h>

    class RadioButtons : public Gtk::Window
    {
    public:
      RadioButtons();
      virtual ~RadioButtons();

    protected:
      //Signal handlers:
      void on_button_clicked();

      //Child widgets:
      Gtk::Box m_Box_Top, m_Box1, m_Box2;
      Gtk::RadioButton m_RadioButton1, m_RadioButton2, m_RadioButton3;
      Gtk::Separator m_Separator;
      Gtk::Button m_Button_Close;
    };

    #endif //GTKMM_EXAMPLE_RADIOBUTTONS_H

File: `radiobuttons.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "radiobuttons.h"

    RadioButtons::RadioButtons() :
      m_Box_Top(Gtk::ORIENTATION_VERTICAL),
      m_Box1(Gtk::ORIENTATION_VERTICAL, 10),
      m_Box2(Gtk::ORIENTATION_VERTICAL, 10),
      m_RadioButton1("button1"),
      m_RadioButton2("button2"),
      m_RadioButton3("button3"),
      m_Button_Close("close")
    {
      // Set title and border of the window
      set_title("radio buttons");
      set_border_width(0);

      // Put radio buttons 2 and 3 in the same group as 1:
      Gtk::RadioButton::Group group = m_RadioButton1.get_group();
      m_RadioButton2.set_group(group);
      m_RadioButton3.set_group(group);

      // Add outer box to the window (because the window
      // can only contain a single widget)
      add(m_Box_Top);

      //Put the inner boxes and the separator in the outer box:
      m_Box_Top.pack_start(m_Box1);
      m_Box_Top.pack_start(m_Separator);
      m_Box_Top.pack_start(m_Box2);

      // Set the inner boxes' borders
      m_Box2.set_border_width(10);
      m_Box1.set_border_width(10);

      // Put the radio buttons in Box1:
      m_Box1.pack_start(m_RadioButton1);
      m_Box1.pack_start(m_RadioButton2);
      m_Box1.pack_start(m_RadioButton3);

      // Set the second button active
      m_RadioButton2.set_active();

      // Put Close button in Box2:
      m_Box2.pack_start(m_Button_Close);

      // Make the button the default widget
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();

      // Connect the clicked signal of the button to
      // RadioButtons::on_button_clicked()
      m_Button_Close.signal_clicked().connect(sigc::mem_fun(*this,
                  &RadioButtons::on_button_clicked) );

      // Show all children of the window
      show_all_children();
    }

    RadioButtons::~RadioButtons()
    {
    }

    void RadioButtons::on_button_clicked()
    {
      hide(); //to close the application.
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "radiobuttons.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      RadioButtons buttons;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(buttons);

      return 0;
    }

## Éléments graphiques à plage de réglage

Les classes Gtk::Scale et Gtk::Scrollbar dérivent toutes deux de Gtk::Range, elles partagent un grand nombre de fonctionnalités. Elles comportent une « glissière » (ou « coulisse ») et un « curseur » (quelquefois nommé « molette » dans d'autres environnements GUI). Vous déplacez le curseur dans la glissière en le faisant glisser à l'aide du pointeur de souris ; si vous cliquez dans la glissière, le curseur avance vers l'endroit cliqué, soit directement, soit d'un pas donné, selon le bouton de souris utilisé. C'est le comportement habituel des barres de défilement.

Ainsi que nous l'expliquons dans le chapitre Ajustements, tous les éléments graphiques à plage de réglage disposent d'un objet Adjustment associé. Pour modifier les valeurs minimale, maximale ou actuelles associées à la position du curseur dans l'élément graphique, vous devez utiliser les fonctions membres de la classe Adjustment dont on obtient le pointeur avec get_adjustment(). Les constructeurs d'un élément graphique à plage de réglage créent automatiquement, par défaut, un objet Adjustment ; vous pouvez aussi désigner un objet Adjustment préexistant, en vue peut-être de le partager avec un autre élément graphique. Consultez le chapitre Ajustements pour de plus amples détails.

Référence

### Éléments graphiques barres de défilement

Ce sont les barres de défilement classiques. Elles ne s'utilisent que pour déplacer un autre élément graphique, comme un Gtk::Entry ou un Gtk::Viewport, même s'il est habituellement plus facile d'utiliser un élément graphique de la classe Gtk::ScrolledWindow dans la plupart des cas.

Il existe une classe pour les barres de défilement horizontal et une classe pour les barres de défilement vertical — Gtk::HScrollbar et Gtk::VScrollbar.

Référence

### Éléments graphiques échelles de valeur

Les éléments graphiques de la classe Gtk::Scale (« coulisses », « glissières ») permettent à l'utilisateur de sélectionner et manipuler visuellement une valeur dans une plage donnée. Vous les utilisez, par exemple, pour ajuster le niveau de zoom de l'aperçu d'une image, pour contrôler la luminosité d'une couleur ou bien pour définir le nombre de minutes d'inactivité avant le déclenchement de l'économiseur d'écran.

Comme pour les objets de la classe Scrollbar, il existe un type distinct pour l'élément graphique d'allure horizontale et celui d'allure verticale — Gtk::HScale et Gtk::VScale. Le constructeur par défaut crée un objet Adjustment dont toutes les valeurs sont fixées à `0,0`. Ce n'est pas utilisable en l'état : vous devez définir certains détails de l'objet Adjustment pour obtenir un comportement signifiant.

#### Fonctions membres utiles

Les éléments graphiques de la classe Scale peuvent afficher la valeur correspondant à la position actuelle du curseur sous forme d'un nombre près de la glissière. C'est le comportement par défaut, mais vous pouvez modifier ce dernier avec la fonction membre set_draw_value().

La valeur affichée par un élément graphique coulisse est, par défaut, arrondie à un chiffre après la virgule ; cette valeur affichée correspond à celle du champ `value` de l'objet Gtk::Adjustment associé. Vous pouvez modifier la précision avec la fonction membre set_digits().

En outre, la valeur peut être placée à diverses positions par rapport à la glissière ; la position se définit avec la fonction membre set_value_pos().

Référence

### Politiques de mise à jour

Le principe de mise à jour d'un élément graphique de la classe Range définit le moment où, au cours des interactions de l'utilisateur, le champ `value` de l'objet Gtk::Adjustment sera modifié et le signal `value_changed` (valeur modifiée) émis. Les principes de mises à jour, définis avec la fonction membre set_update_policy(), sont les suivants :

- `Gtk::UPDATE_CONTINUOUS` — C'est la valeur par défaut. Le signal `value_changed` est émis de manière continue, c'est-à-dire même si le curseur est déplacé d'une quantité infime.

- `Gtk::UPDATE_DISCONTINUOUS` — Le signal `value_changed` n'est émis que lorsque le curseur n'est plus déplacé et que l'utilisateur a relâché le bouton de la souris.

- `Gtk::UPDATE_DELAYED` — Le signal `value_changed` n'est émis que lorsque l'utilisateur a relâché le bouton de la souris ou si la coulisse n'est pas déplacée pendant un court délai.

### Exemple

Cet exemple affiche une fenêtre avec trois éléments graphiques coulisses tous connectés au même ajustement. À côté, sont disposés quelques contrôles pour ajuster certains paramètres mentionnés plus haut (et rappelés au chapitre Ajustements) : vous pouvez ainsi voir comment ils modifient la façon dont ces éléments graphiques réagissent vis à vis de l'utilisateur.

Éléments graphiques à plage de réglage

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_RANGEWIDGETS_H
    #define GTKMM_EXAMPLE_RANGEWIDGETS_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_checkbutton_toggled();
      void on_menu_position(Gtk::PositionType type);
      void on_adjustment1_value_changed();
      void on_adjustment2_value_changed();
      void on_button_quit();

      //Child widgets:
      Gtk::Box m_VBox_Top, m_VBox2, m_VBox_HScale;
      Gtk::Box m_HBox_Scales, m_HBox_Digits, m_HBox_PageSize;

      Glib::RefPtr<Gtk::Adjustment> m_adjustment, m_adjustment_digits, m_adjustment_pagesize;

      Gtk::Scale m_VScale;
      Gtk::Scale m_HScale, m_Scale_Digits, m_Scale_PageSize;

      Gtk::Separator m_Separator;

      Gtk::CheckButton m_CheckButton;

      Gtk::Scrollbar m_Scrollbar;

      Gtk::Menu m_Menu_Position;

      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLE_RANGEWIDGETS_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <iostream>

    ExampleWindow::ExampleWindow()
    :
      m_VBox_Top(Gtk::ORIENTATION_VERTICAL, 0),
      m_VBox2(Gtk::ORIENTATION_VERTICAL, 20),
      m_VBox_HScale(Gtk::ORIENTATION_VERTICAL, 10),
      m_HBox_Scales(Gtk::ORIENTATION_HORIZONTAL, 10),
      m_HBox_Digits(Gtk::ORIENTATION_HORIZONTAL, 10),
      m_HBox_PageSize(Gtk::ORIENTATION_HORIZONTAL, 10),

      // Value, lower, upper, step_increment, page_increment, page_size:
      // Note that the page_size value only makes a difference for
      // scrollbar widgets, and the highest value you'll get is actually
      // (upper - page_size).
      m_adjustment( Gtk::Adjustment::create(0.0, 0.0, 101.0, 0.1, 1.0, 1.0) ),
      m_adjustment_digits( Gtk::Adjustment::create(1.0, 0.0, 5.0, 1.0, 2.0) ),
      m_adjustment_pagesize( Gtk::Adjustment::create(1.0, 1.0, 101.0) ),

      m_VScale(m_adjustment, Gtk::ORIENTATION_VERTICAL),
      m_HScale(m_adjustment, Gtk::ORIENTATION_HORIZONTAL),
      m_Scale_Digits(m_adjustment_digits),
      m_Scale_PageSize(m_adjustment_pagesize),

      // A checkbutton to control whether the value is displayed or not:
      m_CheckButton("Display value on scale widgets", 0),

      // Reuse the same adjustment again.
      // Notice how this causes the scales to always be updated
      // continuously when the scrollbar is moved.
      m_Scrollbar(m_adjustment),

      m_Button_Quit("Quit")
    {
      set_title("range controls");
      set_default_size(300, 350);

      //VScale:
      m_VScale.set_digits(1);
      m_VScale.set_value_pos(Gtk::POS_TOP);
      m_VScale.set_draw_value();
      m_VScale.set_inverted(); // highest value at top

      //HScale:
      m_HScale.set_digits(1);
      m_HScale.set_value_pos(Gtk::POS_TOP);
      m_HScale.set_draw_value();

      add(m_VBox_Top);
      m_VBox_Top.pack_start(m_VBox2);
      m_VBox2.set_border_width(10);
      m_VBox2.pack_start(m_HBox_Scales);

      //Put VScale and HScale (above scrollbar) side-by-side.
      m_HBox_Scales.pack_start(m_VScale);
      m_HBox_Scales.pack_start(m_VBox_HScale);

      m_VBox_HScale.pack_start(m_HScale);

      //Scrollbar:
      m_VBox_HScale.pack_start(m_Scrollbar);

      //CheckButton:
      m_CheckButton.set_active();
      m_CheckButton.signal_toggled().connect( sigc::mem_fun(*this,
        &ExampleWindow::on_checkbutton_toggled) );
      m_VBox2.pack_start(m_CheckButton, Gtk::PACK_SHRINK);

      //Menus:
      Gtk::MenuItem* item = Gtk::manage(new Gtk::MenuItem("Top"));
      item->signal_activate().connect(
        sigc::bind(sigc::mem_fun(*this,
          &ExampleWindow::on_menu_position), Gtk::POS_TOP));
      m_Menu_Position.append(*item);

      item = Gtk::manage(new Gtk::MenuItem("Bottom"));
      item->signal_activate().connect(
        sigc::bind(sigc::mem_fun(*this,
          &ExampleWindow::on_menu_position), Gtk::POS_BOTTOM));
      m_Menu_Position.append(*item);

      item = Gtk::manage(new Gtk::MenuItem("Left"));
      item->signal_activate().connect(
        sigc::bind(sigc::mem_fun(*this,
          &ExampleWindow::on_menu_position), Gtk::POS_LEFT));
      m_Menu_Position.append(*item);

      item = Gtk::manage(new Gtk::MenuItem("Right"));
      item->signal_activate().connect(
        sigc::bind(sigc::mem_fun(*this,
          &ExampleWindow::on_menu_position), Gtk::POS_RIGHT));
      m_Menu_Position.append(*item);

      //Digits:
      m_HBox_Digits.pack_start(
        *Gtk::manage(new Gtk::Label("Scale Digits:", 0)), Gtk::PACK_SHRINK);
      m_Scale_Digits.set_digits(0);
      m_adjustment_digits->signal_value_changed().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_adjustment1_value_changed));
      m_HBox_Digits.pack_start(m_Scale_Digits);

      //Page Size:
      m_HBox_PageSize.pack_start(
        *Gtk::manage(new Gtk::Label("Scrollbar Page Size:", 0)),
        Gtk::PACK_SHRINK);
      m_Scale_PageSize.set_digits(0);
      m_adjustment_pagesize->signal_value_changed().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_adjustment2_value_changed));
      m_HBox_PageSize.pack_start(m_Scale_PageSize);

      m_VBox2.pack_start(m_HBox_Digits, Gtk::PACK_SHRINK);
      m_VBox2.pack_start(m_HBox_PageSize, Gtk::PACK_SHRINK);
      m_VBox_Top.pack_start(m_Separator, Gtk::PACK_SHRINK);
      m_VBox_Top.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);

      m_Button_Quit.set_can_default();
      m_Button_Quit.grab_default();
      m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_button_quit));
      m_Button_Quit.set_border_width(10);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_checkbutton_toggled()
    {
      m_VScale.set_draw_value(m_CheckButton.get_active());
      m_HScale.set_draw_value(m_CheckButton.get_active());
    }

    void ExampleWindow::on_menu_position(Gtk::PositionType postype)
    {
      m_VScale.set_value_pos(postype);
      m_HScale.set_value_pos(postype);
    }

    void ExampleWindow::on_adjustment1_value_changed()
    {
      const double val = m_adjustment_digits->get_value();
      m_VScale.set_digits((int)val);
      m_HScale.set_digits((int)val);
    }

    void ExampleWindow::on_adjustment2_value_changed()
    {
      const double val = m_adjustment_pagesize->get_value();
      m_adjustment->set_page_size(val);
      m_adjustment->set_page_increment(val);

      // Note that we don't have to emit the "changed" signal
      // because gtkmm does this for us.
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

## Éléments graphiques divers

### Étiquette

Les étiquettes sont le moyen essentiel pour placer du texte non-modifiable dans une fenêtre, par exemple pour placer un intitulé à côté de l'élément graphique Entry. Vous pouvez définir le texte dans le constructeur ou, plus tard, à l'aide des fonctions membres set_text() ou set_markup().

La largeur de l'étiquette sera ajustée automatiquement. Vous pouvez écrire des étiquettes sur plusieurs lignes en mettant des sauts de ligne (« \n ») dans la chaîne de l'étiquette.

Le texte de l'étiquette peut être justifié avec la fonction membre set_justify(). L'élément graphique est également susceptible de prendre en charge le retour à ligne automatique, fonctionnalité activée avec la fonction membre set_line_wrap().

Gtk::Label support some simple formatting, for instance allowing you to make some text bold, colored, or larger. You can do this by providing a string to set_markup(), using the Pango Markup syntax. For instance, `<b>bold text</b> and <s>strikethrough text</s>` .

Référence

#### Exemple

Ci-dessous se trouve un court exemple pour illustrer ces fonctions. Cet exemple utilise l'élément graphique cadre pour mieux séparer les styles d'étiquettes (l'élément graphique cadre est exposé au paragraphe Cadre).

Étiquette

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      //Child widgets:
      Gtk::Box m_HBox;
      Gtk::Box m_VBox, m_VBox2;
      Gtk::Frame m_Frame_Normal, m_Frame_Multi, m_Frame_Left, m_Frame_Right,
        m_Frame_LineWrapped, m_Frame_FilledWrapped, m_Frame_Underlined;
      Gtk::Label m_Label_Normal, m_Label_Multi, m_Label_Left, m_Label_Right,
        m_Label_LineWrapped, m_Label_FilledWrapped, m_Label_Underlined;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <iostream>

    ExampleWindow::ExampleWindow()
    :
      m_HBox(Gtk::ORIENTATION_HORIZONTAL, 5),
      m_VBox(Gtk::ORIENTATION_VERTICAL, 5),
      m_VBox2(Gtk::ORIENTATION_VERTICAL, 5),
      m_Frame_Normal("Normal Label"),
      m_Frame_Multi("Multi-line Label"),
      m_Frame_Left("Left Justified Label"),
      m_Frame_Right("Right Justified Label"),
      m_Frame_LineWrapped("Line wrapped label"),
      m_Frame_FilledWrapped("Filled, wrapped label"),
      m_Frame_Underlined("Underlined label"),
      m_Label_Normal("_This is a Normal label", true),
      m_Label_Multi("This is a Multi-line label.\nSecond line\nThird line"),
      m_Label_Left("This is a Left-Justified\nMulti-line label.\nThird line"),
      m_Label_Right("This is a Right-Justified\nMulti-line label.\nThird line"),
      m_Label_Underlined("This label is underlined!\n"
              "This one is underlined in quite a funky fashion")
    {
      set_title("Label");
      set_border_width(5);

      add(m_HBox);

      m_HBox.pack_start(m_VBox, Gtk::PACK_SHRINK);

      m_Frame_Normal.add(m_Label_Normal);
      m_VBox.pack_start(m_Frame_Normal, Gtk::PACK_SHRINK);

      m_Frame_Multi.add(m_Label_Multi);
      m_VBox.pack_start(m_Frame_Multi, Gtk::PACK_SHRINK);

      m_Label_Left.set_justify(Gtk::JUSTIFY_LEFT);
      m_Frame_Left.add(m_Label_Left);
      m_VBox.pack_start(m_Frame_Left, Gtk::PACK_SHRINK);

      m_Label_Right.set_justify(Gtk::JUSTIFY_RIGHT);
      m_Frame_Right.add(m_Label_Right);
      m_VBox.pack_start(m_Frame_Right, Gtk::PACK_SHRINK);

      m_HBox.pack_start(m_VBox2, Gtk::PACK_SHRINK);

      m_Label_LineWrapped.set_text(
              "This is an example of a line-wrapped label.  It "
              /* add a big space to the next line to test spacing */
              "should not be taking up the entire             "
              "width allocated to it, but automatically "
              "wraps the words to fit.  "
              "The time has come, for all good men, to come to "
              "the aid of their party.  "
              "The sixth sheik's six sheep's sick.\n"
              "     It supports multiple paragraphs correctly, "
              "and  correctly   adds "
              "many          extra  spaces. ");
      m_Label_LineWrapped.set_line_wrap();
      m_Frame_LineWrapped.add(m_Label_LineWrapped);
      m_VBox2.pack_start(m_Frame_LineWrapped, Gtk::PACK_SHRINK);

      m_Label_FilledWrapped.set_text(
              "This is an example of a line-wrapped, filled label.  "
              "It should be taking "
              "up the entire              width allocated to it.  "
              "Here is a sentence to prove "
              "my point.  Here is another sentence. "
              "Here comes the sun, do de do de do.\n"
              "    This is a new paragraph.\n"
              "    This is another newer, longer, better "
              "paragraph.  It is coming to an end, "
              "unfortunately.");
      m_Label_FilledWrapped.set_justify(Gtk::JUSTIFY_FILL);
      m_Label_FilledWrapped.set_line_wrap();
      m_Frame_FilledWrapped.add(m_Label_FilledWrapped);
      m_VBox2.pack_start(m_Frame_FilledWrapped, Gtk::PACK_SHRINK);

      m_Label_Underlined.set_justify(Gtk::JUSTIFY_LEFT);
      m_Label_Underlined.set_pattern (
              "_________________________ _ _________ _ ______"
              "     __ _______ ___");
      m_Frame_Underlined.add(m_Label_Underlined);
      m_VBox2.pack_start(m_Frame_Underlined, Gtk::PACK_SHRINK);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

### Champ de saisie

#### Utilisation simple

Les éléments graphiques Entry permettent à l'utilisateur de saisir du texte. Vous pouvez en modifier le contenu avec la fonction membre set_text() et en lire le contenu actuel avec la fonction membre get_text().

Parfois, vous voudrez que le contenu d'un élément graphique Entry soit en lecture seule. Vous obtenez ce résultat en passant le paramètre `false` à la fonction membre set_editable().

Pour la saisie de mots de passe, phrases de passe et autres informations que vous ne souhaitez pas voir reprises à l'affichage, l'appel de la fonction membre set_visibility() avec `false` comme paramètre provoque le masquage du texte.

Vous pouvez vouloir être prévenu chaque fois que l'utilisateur saisit du texte dans un contrôle de saisie. À cette fin, Gtk::Entry dispose de deux signaux : `activate` (activé) et `changed` (modifié). `activate` est émis quand l'utilisateur presse la touche Entrée dans l'élément graphique, `changed` quand le contenu de l'élément graphique est modifié. Vous pouvez vous servir de ces signaux, par exemple, pour valider ou filtrer le texte que l'utilisateur saisit.

Référence

##### Exemple simple de saisie

Cet exemple utilise la classe Gtk::Entry. Deux cases à cocher de la classe CheckButton vous permettent d'inverser les marqueurs « editable » et « visible ».

Champ de saisie

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_checkbox_editable_toggled();
      void on_checkbox_visibility_toggled();
      void on_button_close();

      //Child widgets:
      Gtk::Box m_HBox;
      Gtk::Box m_VBox;
      Gtk::Entry m_Entry;
      Gtk::Button m_Button_Close;
      Gtk::CheckButton m_CheckButton_Editable, m_CheckButton_Visible;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Close("Close"),
      m_CheckButton_Editable("Editable"),
      m_CheckButton_Visible("Visible")
    {
      set_size_request(200, 100);
      set_title("Gtk::Entry");

      add(m_VBox);

      m_Entry.set_max_length(50);
      m_Entry.set_text("hello");
      m_Entry.set_text(m_Entry.get_text() + " world");
      m_Entry.select_region(0, m_Entry.get_text_length());
      m_VBox.pack_start(m_Entry);

      // Note that add() can also be used instead of pack_xxx()
      m_VBox.add(m_HBox);

      m_HBox.pack_start(m_CheckButton_Editable);
      m_CheckButton_Editable.signal_toggled().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbox_editable_toggled) );
      m_CheckButton_Editable.set_active(true);

      m_HBox.pack_start(m_CheckButton_Visible);
      m_CheckButton_Visible.signal_toggled().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbox_visibility_toggled) );
      m_CheckButton_Visible.set_active(true);

      m_Button_Close.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_close) );
      m_VBox.pack_start(m_Button_Close);
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_checkbox_editable_toggled()
    {
      m_Entry.set_editable(m_CheckButton_Editable.get_active());
    }

    void ExampleWindow::on_checkbox_visibility_toggled()
    {
      m_Entry.set_visibility(m_CheckButton_Visible.get_active());
    }

    void ExampleWindow::on_button_close()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Complétion de saisie

Un élément graphique Entry peut offrir une liste déroulante de choix préétablis à partir des premiers caractères saisis par l'utilisateur. Par exemple, une boîte de dialogue de recherche peut suggérer un texte en fonction des recherches antérieures.

Pour activer cette fonctionnalité, vous devez créer un objet EntryCompletion et le mettre à disposition de l'élément graphique Entry par l'intermédiaire de la fonction membre set_completion().

L'objet EntryCompletion peut utiliser une classe TreeModel contenant les entrées possibles définies à l'aide de set_model(). Faites ensuite appel à set_text_column() pour définir quelles colonnes de votre modèle doivent être utilisées pour chercher une possible concordance avec le texte saisi.

Autrement, si la liste complète des saisies possibles est trop grande ou trop délicate à produire, il est possible de définir l'emplacement d'une fonction de rappel à l'aide de la fonction membre set_match_func(), dont le paramètre est un pointeur sur la-dite fonction de rappel. Cela peut se révéler utile si vous souhaitez chercher une concordance sur une partie de chaîne littérale autre que son début.

Référence

##### Exemple de complétion de saisie

Dans cet exemple, nous créons un objet Gtk::EntryCompletion et nous l'associons à un élément graphique Gtk::Entry. La complétion fait appel à un objet Gtk::TreeModel pour les diverses saisies possibles et quelques actions supplémentaires.

Complétion de saisie

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_close();

      void on_completion_action_activated(int index);

      //See the comment in the implementation:
      //bool on_completion_match(const Glib::ustring& key, const Gtk::TreeModel::const_iterator& iter);

      //Tree model columns, for the EntryCompletion's filter model:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); }

        Gtk::TreeModelColumn<unsigned int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
      };

      ModelColumns m_Columns;

      typedef std::map<int, Glib::ustring> type_actions_map;
      type_actions_map m_CompletionActions;

      //Child widgets:
      Gtk::Box m_HBox;
      Gtk::Box m_VBox;
      Gtk::Entry m_Entry;
      Gtk::Label m_Label;
      Gtk::Button m_Button_Close;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Label("Press a or b to see a list of possible completions and actions."),
      m_Button_Close("Close")
    {
      //set_size_request(200, 100);
      set_title("Gtk::EntryCompletion");

      add(m_VBox);
      m_VBox.pack_start(m_Entry, Gtk::PACK_SHRINK);

      m_VBox.pack_start(m_Label, Gtk::PACK_EXPAND_WIDGET);

      m_Button_Close.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_close) );
      m_VBox.pack_start(m_Button_Close, Gtk::PACK_SHRINK);
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();

      //Add an EntryCompletion:
      Glib::RefPtr<Gtk::EntryCompletion> completion =
          Gtk::EntryCompletion::create();
      m_Entry.set_completion(completion);

      //Create and fill the completion's filter model
      Glib::RefPtr<Gtk::ListStore> refCompletionModel =
          Gtk::ListStore::create(m_Columns);
      completion->set_model(refCompletionModel);

      // For more complex comparisons, use a filter match callback, like this.
      // See the comment below for more details:
      //completion->set_match_func( sigc::mem_fun(*this,
                  //&ExampleWindow::on_completion_match) );

      //Fill the TreeView's model
      Gtk::TreeModel::Row row = *(refCompletionModel->append());
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "Alan Zebedee";

      row = *(refCompletionModel->append());
      row[m_Columns.m_col_id] = 2;
      row[m_Columns.m_col_name] = "Adrian Boo";

      row = *(refCompletionModel->append());
      row[m_Columns.m_col_id] = 3;
      row[m_Columns.m_col_name] = "Bob McRoberts";

      row = *(refCompletionModel->append());
      row[m_Columns.m_col_id] = 4;
      row[m_Columns.m_col_name] = "Bob McBob";

      //Tell the completion what model column to use to
      //- look for a match (when we use the default matching, instead of
      //  set_match_func().
      //- display text in the entry when a match is found.
      completion->set_text_column(m_Columns.m_col_name);

      //Add actions to the completion:
      //These are just extra items shown at the bottom of the list of possible
      //completions.

      //Remember them for later.
      m_CompletionActions[0] = "Use Wizard";
      m_CompletionActions[1] = "Browse for Filename";

      for(type_actions_map::iterator iter = m_CompletionActions.begin();
              iter != m_CompletionActions.end(); ++iter)
      {
        int position = iter->first;
        Glib::ustring title = iter->second;
        completion->insert_action_text(title, position);
      }

      completion->signal_action_activated().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_completion_action_activated) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_close()
    {
      hide();
    }

    /* You can do more complex matching with a handler like this.
     * For instance, you could check for substrings inside the string instead of the start,
     * or you could look for the key in extra model columns as well as the model column that will be displayed.
     * The code here is not actually more complex - it's a reimplementation of the default behaviour.
     *
    bool ExampleWindow::on_completion_match(const Glib::ustring& key, const
            Gtk::TreeModel::const_iterator& iter)
    {
      if(iter)
      {
        Gtk::TreeModel::Row row = *iter;

        Glib::ustring::size_type key_length = key.size();
        Glib::ustring filter_string = row[m_Columns.m_col_name];

        Glib::ustring filter_string_start = filter_string.substr(0, key_length);
        //The key is lower-case, even if the user input is not.
        filter_string_start = filter_string_start.lowercase();

        if(key == filter_string_start)
          return true; //A match was found.
      }

      return false; //No match.
    }
    */

    void ExampleWindow::on_completion_action_activated(int index)
    {
      type_actions_map::iterator iter = m_CompletionActions.find(index);
      if(iter != m_CompletionActions.end()) //If it's in the map
      {
        Glib::ustring title = iter->second;
        std::cout << "Action selected: " << title << std::endl;
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Icône dans un champ de saisie

Un élément graphique Entry peut afficher une icône au début ou à la fin de la zone de texte. L'icône est définie par des fonctions membres telles que set_icon_from_pixbuf() ou set_icon_from_stock(). Une application peut répondre à un utilisateur qui clique sur l'icône en prenant en charge le signal signal_icon_press.

##### Exemple d'icône dans un champ de saisie

Cet exemple montre un élément graphique Gtk::Entry avec une icône « rechercher » prise dans le catalogue. Le texte dans le champ de saisie est reproduit dans la fenêtre du terminal quand l'icône est cliquée.

Saisie avec icône

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_icon_pressed(Gtk::EntryIconPosition icon_pos, const GdkEventButton* event);
      void on_button_close();

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Entry m_Entry;
      Gtk::Button m_Button_Close;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Close("Close")
    {
      set_title("Gtk::Entry");

      add(m_VBox);

      m_Entry.set_max_length(50);
      m_Entry.set_text("Hello world");
      m_VBox.pack_start(m_Entry, Gtk::PACK_SHRINK);

      m_Entry.set_icon_from_stock(Gtk::Stock::FIND);
      m_Entry.signal_icon_press().connect( sigc::mem_fun(*this, &ExampleWindow::on_icon_pressed) );

      m_Button_Close.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_close) );
      m_VBox.pack_start(m_Button_Close, Gtk::PACK_SHRINK);
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_icon_pressed(Gtk::EntryIconPosition /* icon_pos */, const GdkEventButton* /* event */)
    {
      std::cout << "Icon pressed." << std::endl;
    }

    void ExampleWindow::on_button_close()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Saisie avec barre de progression

Un élément graphique Entry peut afficher une barre de progression dans la zone de saisie du texte, en arrière plan du texte. La barre de progression est affichée en faisant appel aux fonctions membres set_progress_fraction() ou set_progress_pulse_step().

##### Exemple de saisie avec barre de progression

Cet exemple montre un élément graphique Gtk::Entry avec barre de progression.

Saisie avec barre de progression

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      bool on_timeout();
      void on_button_close();

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Entry m_Entry;
      Gtk::Button m_Button_Close;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Close("Close")
    {
      set_title("Gtk::Entry");

      add(m_VBox);

      m_Entry.set_max_length(50);
      m_Entry.set_text("Hello world");
      m_VBox.pack_start(m_Entry, Gtk::PACK_SHRINK);

      //Change the progress fraction every 0.1 second:
      Glib::signal_timeout().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_timeout),
        100
      );

      m_Button_Close.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_close) );
      m_VBox.pack_start(m_Button_Close, Gtk::PACK_SHRINK);
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    bool ExampleWindow::on_timeout()
    {
      static double fraction = 0;
      m_Entry.set_progress_fraction(fraction);

      fraction += 0.01;
      if(fraction > 1)
        fraction = 0;

      return true;
    }

    void ExampleWindow::on_button_close()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

### Bouton compteur

Un objet SpinButton permet à l'utilisateur de sélectionner une valeur à l'intérieur d'un segment de valeurs numériques. Il est constitué d'un contrôle saisie de texte avec des boutons flèche en haut et flèche en bas sur le côté. Le fait de cliquer sur un des boutons fait « tourner » la valeur affichée en l'incrémentant ou la décrémentant dans les limites de la plage des valeurs admises. Il est aussi possible de saisir directement une valeur dans l'élément Entry.

Le nombre de décimales après la virgule de la valeur est ajustable, de même que la valeur de l'incrément. Le SpinButton dispose d'une fonctionnalité de « répétition automatique » : si l'option est retenue, le fait de maintenir enfoncée l'une des flèches provoque une accélération des changements de valeur en fonction de la durée d'appui sur le bouton.

Un objet SpinButton utilise un objet Ajustement pour mémoriser l'information sur la plage des valeurs permises. Le compteur utilise les attributs de l'objet Adjustment comme suit :

- `value` : valeur initiale du compteur

- `lower` : limite inférieure de la plage

- `upper` : limite supérieure de la plage

- `step_increment` : valeur de l'incrément/ du décrément lors d'un clic avec le bouton 1 de la souris sur une flèche du compteur

- `page_increment` : valeur de l'incrément/de décrément lors d'un clic avec le bouton 2 de la souris sur une flèche du compteur

- `page_size` : inutilisé

De plus, il est possible d'utiliser le bouton 3 de la souris pour sauter directement aux valeurs `upper` ou `lower`.

L'objet SpinButton crée un objet Adjustment par défaut dont le pointeur est accessible avec la fonction membre get_adjustment(). Vous pouvez également préciser un objet Adjustment existant dans le constructeur.

#### Fonctions membres

Le nombre de décimales est modifié à l'aide de la fonction membre set_digits().

Il est possible de définir la valeur du compteur avec la fonction membre set_value() et de la récupérer avec get_value().

La fonction membre spin() fait « tourner » le SpinButton, comme si l'une des flèches avait été cliquée. Il est nécessaire de préciser un Gtk::SpinType pour définir le sens de modification ou une nouvelle position du compteur.

Pour empêcher l'utilisateur d'entrer des caractères non-numériques dans le champ de saisie, passez le paramètre `true` à la fonction membre set_numeric().

Pour que le SpinButton « boucle » de la limite supérieure à la limite inférieure de la plage de valeurs (et inversement), utilisez la fonction membre set_wrap().

Pour forcer le SpinButton à arrondir sa valeur au `step_increment` (pas d'incrément) le plus proche, utilisez la fonction membre set_snap_to_ticks().

Vous pouvez modifier la politique de mise à jour avec la fonction membre set_update_policy() en choisissant, soit `Gtk::UPDATE_ALWAYS`, soit `Gtk::UPDATE_IF_VALID`. Si vous sélectionnez `Gtk::UPDATE_ALWAYS`, le SpinButton ignore les erreurs de conversion en valeur numérique du texte saisi dans la boîte. Par conséquent, ce réglage autorise le SpinButton à accepter également des valeurs non-numériques. Vous pouvez forcer une mise à jour immédiate avec la fonction membre update().

Référence

#### Exemple

Voici un exemple de SpinButton en action :

Bouton compteur

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_checkbutton_snap();
      void on_checkbutton_numeric();
      void on_spinbutton_digits_changed();
      void on_button_close();

      enum enumValueFormats
      {
        VALUE_FORMAT_INT,
        VALUE_FORMAT_FLOAT
      };
      void on_button_getvalue(enumValueFormats display);

      //Child widgets:
      Gtk::Frame m_Frame_NotAccelerated, m_Frame_Accelerated;
      Gtk::Box m_HBox_NotAccelerated, m_HBox_Accelerated,
        m_HBox_Buttons;
      Gtk::Box m_VBox_Main, m_VBox, m_VBox_Day, m_VBox_Month, m_VBox_Year,
        m_VBox_Accelerated, m_VBox_Value, m_VBox_Digits;
      Gtk::Label m_Label_Day, m_Label_Month, m_Label_Year,
        m_Label_Value, m_Label_Digits,
        m_Label_ShowValue;
      Glib::RefPtr<Gtk::Adjustment> m_adjustment_day, m_adjustment_month, m_adjustment_year,
        m_adjustment_value, m_adjustment_digits;
      Gtk::SpinButton m_SpinButton_Day, m_SpinButton_Month, m_SpinButton_Year,
        m_SpinButton_Value, m_SpinButton_Digits;
      Gtk::CheckButton m_CheckButton_Snap, m_CheckButton_Numeric;
      Gtk::Button m_Button_Int, m_Button_Float, m_Button_Close;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <iostream>
    #include <cstdio>

    ExampleWindow::ExampleWindow()
    :
      m_Frame_NotAccelerated("Not accelerated"),
      m_Frame_Accelerated("Accelerated"),
      m_VBox_Main(Gtk::ORIENTATION_VERTICAL, 5),
      m_Label_Day("Day: "),
      m_Label_Month("Month: "),
      m_Label_Year("Year: "),
      m_Label_Value("Value: "),
      m_Label_Digits("Digits: "),
      m_adjustment_day( Gtk::Adjustment::create(1.0, 1.0, 31.0, 1.0, 5.0, 0.0) ),
      m_adjustment_month( Gtk::Adjustment::create(1.0, 1.0, 12.0, 1.0, 5.0, 0.0) ),
      m_adjustment_year( Gtk::Adjustment::create(1998.0, 0.0, 2100.0, 1.0, 100.0, 0.0) ),
      m_adjustment_value( Gtk::Adjustment::create(0.0, -10000.0, 10000.0, 0.5, 100.0, 0.0) ),
      m_adjustment_digits( Gtk::Adjustment::create(2.0, 1.0, 5.0, 1.0, 1.0, 0.0) ),
      m_SpinButton_Day(m_adjustment_day),
      m_SpinButton_Month(m_adjustment_month),
      m_SpinButton_Year(m_adjustment_year),
      m_SpinButton_Value(m_adjustment_value, 1.0, 2),
      m_SpinButton_Digits(m_adjustment_digits),
      m_CheckButton_Snap("Snap to 0.5-ticks"),
      m_CheckButton_Numeric("Numeric only input mode"),
      m_Button_Int("Value as Int"),
      m_Button_Float("Value as Float"),
      m_Button_Close("Close")
    {
      set_title("SpinButton");

      m_VBox_Main.set_border_width(10);
      add(m_VBox_Main);

      m_VBox_Main.pack_start(m_Frame_NotAccelerated);

      m_VBox.set_border_width(5);
      m_Frame_NotAccelerated.add(m_VBox);

      /* Day, month, year spinners */

      m_VBox.pack_start(m_HBox_NotAccelerated, Gtk::PACK_EXPAND_WIDGET, 5);

      m_Label_Day.set_alignment(Gtk::ALIGN_START);
      m_VBox_Day.pack_start(m_Label_Day);

      m_SpinButton_Day.set_wrap();

      m_VBox_Day.pack_start(m_SpinButton_Day);

      m_HBox_NotAccelerated.pack_start(m_VBox_Day, Gtk::PACK_EXPAND_WIDGET, 5);

      m_Label_Month.set_alignment(Gtk::ALIGN_START);
      m_VBox_Month.pack_start(m_Label_Month);

      m_SpinButton_Month.set_wrap();
      m_VBox_Month.pack_start(m_SpinButton_Month);

      m_HBox_NotAccelerated.pack_start(m_VBox_Month, Gtk::PACK_EXPAND_WIDGET, 5);

      m_Label_Year.set_alignment(Gtk::ALIGN_START);
      m_VBox_Year.pack_start(m_Label_Year);

      m_SpinButton_Year.set_wrap();
      m_SpinButton_Year.set_size_request(55, -1);
      m_VBox_Year.pack_start(m_SpinButton_Year);

      m_HBox_NotAccelerated.pack_start(m_VBox_Year, Gtk::PACK_EXPAND_WIDGET, 5);

      //Accelerated:
      m_VBox_Main.pack_start(m_Frame_Accelerated);

      m_VBox_Accelerated.set_border_width(5);
      m_Frame_Accelerated.add(m_VBox_Accelerated);

      m_VBox_Accelerated.pack_start(m_HBox_Accelerated, Gtk::PACK_EXPAND_WIDGET, 5);

      m_HBox_Accelerated.pack_start(m_VBox_Value, Gtk::PACK_EXPAND_WIDGET, 5);

      m_Label_Value.set_alignment(Gtk::ALIGN_START);
      m_VBox_Value.pack_start(m_Label_Value);

      m_SpinButton_Value.set_wrap();
      m_SpinButton_Value.set_size_request(100, -1);
      m_VBox_Value.pack_start(m_SpinButton_Value);

      m_HBox_Accelerated.pack_start(m_VBox_Digits, Gtk::PACK_EXPAND_WIDGET, 5);

      m_Label_Digits.set_alignment(Gtk::ALIGN_START);
      m_VBox_Digits.pack_start(m_Label_Digits);

      m_SpinButton_Digits.set_wrap();
      m_adjustment_digits->signal_value_changed().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_spinbutton_digits_changed) );

      m_VBox_Digits.pack_start(m_SpinButton_Digits);

      //CheckButtons:
      m_VBox_Accelerated.pack_start(m_CheckButton_Snap);
      m_CheckButton_Snap.set_active();
      m_CheckButton_Snap.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbutton_snap) );

      m_VBox_Accelerated.pack_start(m_CheckButton_Numeric);
      m_CheckButton_Numeric.set_active();
      m_CheckButton_Numeric.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbutton_numeric) );

      //Buttons:
      m_VBox_Accelerated.pack_start (m_HBox_Buttons, Gtk::PACK_SHRINK, 5);

      m_Button_Int.signal_clicked().connect( sigc::bind( sigc::mem_fun(*this,
                      &ExampleWindow::on_button_getvalue), VALUE_FORMAT_INT) );
      m_HBox_Buttons.pack_start(m_Button_Int, Gtk::PACK_EXPAND_WIDGET, 5);

      m_Button_Float.signal_clicked().connect( sigc::bind( sigc::mem_fun(*this,
                      &ExampleWindow::on_button_getvalue), VALUE_FORMAT_FLOAT) );
      m_HBox_Buttons.pack_start(m_Button_Float, Gtk::PACK_EXPAND_WIDGET, 5);

      m_VBox_Accelerated.pack_start(m_Label_ShowValue);
      m_Label_ShowValue.set_text("0");

      //Close button:
      m_Button_Close.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_close) );
      m_VBox_Main.pack_start(m_Button_Close, Gtk::PACK_SHRINK);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_close()
    {
      hide();
    }

    void ExampleWindow::on_checkbutton_snap()
    {
      m_SpinButton_Value.set_snap_to_ticks( m_CheckButton_Snap.get_active() );
    }

    void ExampleWindow::on_checkbutton_numeric()
    {
      m_SpinButton_Value.set_numeric( m_CheckButton_Numeric.get_active() );
    }

    void ExampleWindow::on_spinbutton_digits_changed()
    {
      m_SpinButton_Value.set_digits( m_SpinButton_Digits.get_value_as_int() );
    }

    void ExampleWindow::on_button_getvalue(enumValueFormats display)
    {
      gchar buf[32];

      if (display == VALUE_FORMAT_INT)
        sprintf (buf, "%d", m_SpinButton_Value.get_value_as_int());
      else
        sprintf (buf, "%0.*f", m_SpinButton_Value.get_digits(),
                m_SpinButton_Value.get_value());

      m_Label_ShowValue.set_text(buf);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

### Barres de progression

Les barres de progression s'utilisent pour afficher l'avancement d'une opération en cours. Par exemple, un objet ProgressBar peut afficher le pourcentage de réalisation d'une tâche.

Pour modifier la valeur affichée, utilisez la fonction membre set_fraction() à laquelle vous passez une valeur de type double comprise entre 0 et 1 pour définir le nouveau pourcentage.

Le paramètre `percentage` est un nombre, entre 0 et 1, indiquant la proportion de remplissage de la barre.

Par défaut, un objet ProgressBar est disposé horizontalement et le remplissage s'effectue de la gauche vers la droite, mais il est possible de disposer cette barre verticalement avec la fonction membre set_orientation().

Référence

#### Mode activité

Outre l'indication du taux de progression d'une tâche, la barre de progression peut aussi s'utiliser pour indiquer qu'il y a une certaine activité ; cela s'effectue en mettant la barre de progression en mode activité. Dans ce mode, la barre de progression affiche un petit rectangle se déplaçant d'une extrémité à l'autre de la barre. Ce mode est utile dans les cas où le taux de progression d'une opération ne peut pas être calculé sous forme de valeur numérique (par exemple, pour la réception d'un fichier de taille inconnue).

Pour basculer dans ce mode, appelez la fonction membre pulse() à intervalles réguliers. Vous pourrez aussi choisir la durée des intervalles d'appel avec set_pulse_step().

En mode continu, la barre de progression peut aussi afficher un texte configurable dans la glissière, en utilisant la fonction membre set_text().

#### Exemple

Barres de progression

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_checkbutton_text();
      void on_checkbutton_activity();
      void on_checkbutton_inverted();
      virtual bool on_timeout();
      void on_button_close();

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Alignment m_Alignment;
      Gtk::Table m_Table;
      Gtk::ProgressBar m_ProgressBar;
      Gtk::Separator m_Separator;
      Gtk::CheckButton m_CheckButton_Text, m_CheckButton_Activity, m_CheckButton_Inverted;
      Gtk::Button m_Button_Close;

      int m_connection_id_timeout;
      bool m_bActivityMode;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL, 5),
      m_Alignment(0.5, 0.5, 0, 0),
      m_Table(2, 2, true),
      m_CheckButton_Text("Show text"),
      m_CheckButton_Activity("Activity mode"),
      m_CheckButton_Inverted("Right to Left"),
      m_Button_Close("Close"),
      m_bActivityMode(false)
    {
      set_resizable();
      set_title("Gtk::ProgressBar");

      m_VBox.set_border_width(10);
      add(m_VBox);

      m_VBox.pack_start(m_Alignment, Gtk::PACK_SHRINK, 5);
      m_Alignment.add(m_ProgressBar);
      m_ProgressBar.set_text("some text");
      m_ProgressBar.set_show_text(false);

      //Add a timer callback to update the value of the progress bar:
      m_connection_id_timeout = Glib::signal_timeout().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_timeout), 50 );

      m_VBox.pack_start(m_Separator, Gtk::PACK_SHRINK);
      m_VBox.pack_start(m_Table);

      //Add a check button to select displaying of the trough text:
      m_Table.attach(m_CheckButton_Text, 0, 1, 0, 1, Gtk::EXPAND | Gtk::FILL,
              Gtk::EXPAND | Gtk::FILL, 5, 5);
      m_CheckButton_Text.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbutton_text) );

      //Add a check button to toggle activity mode:
      m_Table.attach(m_CheckButton_Activity, 0, 1, 1, 2, Gtk::EXPAND | Gtk::FILL,
              Gtk::EXPAND | Gtk::FILL, 5, 5);
      m_CheckButton_Activity.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbutton_activity) );

      //Add a check button to select growth from left to right or from right to left:
      m_Table.attach(m_CheckButton_Inverted, 0, 1, 2, 3, Gtk::EXPAND | Gtk::FILL,
              Gtk::EXPAND | Gtk::FILL, 5, 5);
      m_CheckButton_Inverted.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbutton_inverted) );

      //Add a button to exit the program.
      m_VBox.pack_start(m_Button_Close, Gtk::PACK_SHRINK);
      m_Button_Close.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_close) );
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_checkbutton_text()
    {
      const bool show_text = m_CheckButton_Text.get_active();
      m_ProgressBar.set_show_text(show_text);
    }

    void ExampleWindow::on_checkbutton_activity()
    {
      m_bActivityMode = m_CheckButton_Activity.get_active();

      if(m_bActivityMode)
        m_ProgressBar.pulse();
      else
        m_ProgressBar.set_fraction(0.0);
    }

    void ExampleWindow::on_checkbutton_inverted()
    {
      const bool inverted = m_CheckButton_Inverted.get_active();
      m_ProgressBar.set_inverted(inverted);
    }

    void ExampleWindow::on_button_close()
    {
      hide();
    }

    /* Update the value of the progress bar so that we get
     * some movement */
    bool ExampleWindow::on_timeout()
    {
      if(m_bActivityMode)
        m_ProgressBar.pulse();
      else
      {
        double new_val = m_ProgressBar.get_fraction() + 0.01;

        if(new_val > 1.0)
          new_val = 0.0;

        //Set the new value:
        m_ProgressBar.set_fraction(new_val);
      }

      //As this is a timeout function, return true so that it
      //continues to get called
      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

### Infobarre

Un objet InfoBar permet d'afficher de courts éléments d'informations ou de poser de brèves questions. Contrairement à l'objet Dialog, il apparaît au dessus de la fenêtre actuelle au lieu d'ouvrir une nouvelle fenêtre. Son API est tout à fait semblable à celle de l'objet Gtk::Dialog.

Référence

#### Exemple

Infobarre

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_infobar_response(int response);
      void on_button_quit();
      void on_button_clear();
      void on_textbuffer_changed();

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TextView m_TextView;

      Glib::RefPtr<Gtk::TextBuffer> m_refTextBuffer;

      Gtk::InfoBar m_InfoBar;
      Gtk::Label m_Message_Label;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit, m_Button_Clear;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL, 6),
      m_Button_Quit(Gtk::Stock::QUIT),
      m_Button_Clear("Clear")
    {
      set_title("Gtk::InfoBar example");
      set_border_width(6);
      set_default_size(400, 200);

      add(m_VBox);

      // Add the message label to the InfoBar:
      Gtk::Container* infoBarContainer =
        dynamic_cast<Gtk::Container*>(m_InfoBar.get_content_area());
      if (infoBarContainer)
        infoBarContainer->add(m_Message_Label);

      // Add an ok button to the InfoBar:
      m_InfoBar.add_button(Gtk::Stock::OK, 0);

      // Add the InfoBar to the vbox:
      m_VBox.pack_start(m_InfoBar, Gtk::PACK_SHRINK);

      // Create the buffer and set it for the TextView:
      m_refTextBuffer = Gtk::TextBuffer::create();
      m_TextView.set_buffer(m_refTextBuffer);

      // Add the TreeView, inside a ScrolledWindow:
      m_ScrolledWindow.add(m_TextView);

      // Show the scrollbars only when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);

      // Add button box:
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Clear, Gtk::PACK_SHRINK);
      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_spacing(6);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);

      // Connect signals:
      m_InfoBar.signal_response().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_infobar_response) );
      m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );
      m_Button_Clear.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_clear) );
      m_refTextBuffer->signal_changed().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_textbuffer_changed) );

      show_all_children();

      // Keep the InfoBar hidden until a message needs to be shown:
      m_InfoBar.hide();

      // Make the clear button insensitive until text is typed in the buffer.  When
      // the button is sensitive and it is pressed, the InfoBar is displayed with a
      // message.
      m_Button_Clear.set_sensitive(false);
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_infobar_response(int)
    {
      // Clear the message and hide the info bar:
      m_Message_Label.set_text("");
      m_InfoBar.hide();
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

    void ExampleWindow::on_button_clear()
    {
      m_refTextBuffer->set_text("");
      m_Message_Label.set_text("Cleared the text.");
      m_InfoBar.set_message_type(Gtk::MESSAGE_INFO);
      m_InfoBar.show();
    }

    void ExampleWindow::on_textbuffer_changed()
    {
      m_Button_Clear.set_sensitive(m_refTextBuffer->size() > 0);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

### Infobulles

L'infobulle est un petite fenêtre informative qui apparaît quand vous laissez votre pointeur de souris sur un élément graphique pendant quelques secondes. Servez-vous de la fonction membre set_tooltip_text() pour définir une chaîne textuelle d'infobulle sur n'importe quel élément graphique de la classe Widget. Les objets Gtk::ToolItem ne sont pas des objets de la classe Widget, mais disposent des mêmes fonctions membres pour des raisons de commodité. Gtk::Tooltip s'utilise pour une utilisation plus sophistiquée des infobulles, comme l'affichage d'images et de texte.

Référence pour les éléments graphiques

Référence Infobulles

#### Exemple

Infobulle

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:

      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      //Methods:
      void prepare_textview();
      void connect_signals();

      //Signal handlers:
      void on_markup_checkbutton_click();
      bool on_textview_query_tooltip(int x, int y, bool keyboard_tooltip, const Glib::RefPtr<Gtk::Tooltip>& tooltip);
      bool on_button_query_tooltip(int x, int y, bool keyboard_tooltip, const Glib::RefPtr<Gtk::Tooltip>& tooltip);

      //Child widgets:
      Gtk::Box m_vbox;

      Gtk::CheckButton m_checkbutton;
      Gtk::Label m_label;

      Gtk::ScrolledWindow m_scrolled_window;
      Gtk::TextView m_text_view;
      Glib::RefPtr<Gtk::TextBuffer> m_ref_text_buffer;
      Glib::RefPtr<Gtk::TextTag> m_ref_bold_tag;

      Gtk::Button m_button;
      Gtk::Window m_button_tooltip_window;

    };

    #endif // GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    #include <vector>

    const Glib::ustring app_title = "gtkmm tooltips example";
    const Glib::ustring non_markedup_tip = "A tooltip without markup.";
    const Glib::ustring markedup_tip = "<i>Markup</i> in a tooltip.";

    ExampleWindow::ExampleWindow()
      :
      m_vbox(Gtk::ORIENTATION_VERTICAL, 3),
      m_checkbutton("Click to alternate markup in tooltip"),
      m_label("A label"),
      m_button("Custom widget in tooltip window"),
      m_button_tooltip_window(Gtk::WINDOW_POPUP)
    {
      //Set up window and the top-level container:
      set_title(app_title);
      set_border_width(10);

      add(m_vbox);

      //Check button with markup in tooltip:
      m_checkbutton.set_tooltip_text(non_markedup_tip);
      m_vbox.pack_start(m_checkbutton, Gtk::PACK_SHRINK);

      //Label:
      m_label.set_tooltip_text("Another tooltip");
      m_vbox.pack_start(m_label, Gtk::PACK_SHRINK);

      //Textview:
      prepare_textview();

      //Button:
      // set_tooltip_window(), like set_tooltip_text(),
      // will call set_has_tooltip() for us.
      m_button.set_tooltip_window(m_button_tooltip_window);
      m_vbox.pack_start(m_button, Gtk::PACK_SHRINK);

      //Button's custom tooltip window:
      m_button_tooltip_window.set_default_size(250, 30);
      Gtk::Label* label =
        Gtk::manage(new Gtk::Label("A label in a custom tooltip window"));
      label->show();
      m_button_tooltip_window.add(*label);

      connect_signals();

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::prepare_textview()
    {
      Gtk::TextIter iter;
      std::vector< Glib::RefPtr<Gtk::TextTag> > tags;

      //Set up a scrolled window:
      m_scrolled_window.add(m_text_view);
      m_scrolled_window.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
      m_vbox.pack_start(m_scrolled_window);

      //Create a text buffer with some text:
      m_ref_text_buffer = Gtk::TextBuffer::create();

      iter = m_ref_text_buffer->end();
      m_ref_text_buffer->insert(iter, "Hover over the text ");

      //Insert some text with a tag.
      //In the tooltip signal handler below, we will show a tooltip
      //when mouse pointer is above this tagged text.
      m_ref_bold_tag = m_ref_text_buffer->create_tag("bold");
      m_ref_bold_tag->set_property("weight", Pango::WEIGHT_BOLD);

      tags.push_back(m_ref_bold_tag);

      iter = m_ref_text_buffer->end();
      m_ref_text_buffer->insert_with_tags(iter, "in bold", tags);

      iter = m_ref_text_buffer->end();
      m_ref_text_buffer->insert(iter, " to see its' tooltip");

      m_text_view.set_buffer(m_ref_text_buffer);

      m_text_view.set_size_request(320, 50);

      //When only connecting to the query-tooltip signal, and not using any
      //of set_tooltip_text(), set_tooltip_markup() or set_tooltip_window(),
      //we need to explicitly tell GTK+ that the widget has a tooltip which
      //we'll show.
      m_text_view.set_has_tooltip();
    }

    void ExampleWindow::connect_signals()
    {
      m_checkbutton.signal_clicked().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_markup_checkbutton_click));

      m_text_view.signal_query_tooltip().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_textview_query_tooltip));

      m_button.signal_query_tooltip().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_button_query_tooltip));
    }

    void ExampleWindow::on_markup_checkbutton_click()
    {
      if (m_checkbutton.get_active() == true)
      {
        m_checkbutton.set_tooltip_markup(markedup_tip);
      }
      else
      {
        m_checkbutton.set_tooltip_markup(non_markedup_tip);
      }
    }

    bool ExampleWindow::on_textview_query_tooltip(int x, int y, bool keyboard_tooltip, const Glib::RefPtr<Gtk::Tooltip>& tooltip)
    {
      Gtk::TextIter iter;

      if (keyboard_tooltip)
      {
        int offset = m_ref_text_buffer->property_cursor_position().get_value();
        iter = m_ref_text_buffer->get_iter_at_offset(offset);
      }
      else
      {
        int mouse_x, mouse_y, trailing;
        m_text_view.window_to_buffer_coords(Gtk::TEXT_WINDOW_TEXT,
                                            x, y, mouse_x, mouse_y);
        m_text_view.get_iter_at_position(iter, trailing, mouse_x, mouse_y);
      }

      //Show a tooltip if the cursor or mouse pointer is over the text
      //with the specific tag:
      if (iter.has_tag(m_ref_bold_tag))
      {
        tooltip->set_markup("<b>Information</b> attached to a text tag");
        tooltip->set_icon_from_stock (Gtk::Stock::INFO, Gtk::ICON_SIZE_MENU);
      }
      else
      {
        return false;
      }

      return true;
    }

    bool ExampleWindow::on_button_query_tooltip(int, int, bool, const Glib::RefPtr<Gtk::Tooltip>&)
    {
      //We already have a custom window ready, just return true to show it:
      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

## Éléments graphiques conteneurs

Tous les éléments conteneurs dérivent de la classe Gtk::Container, mais pas toujours directement. Quelques éléments conteneurs, tels que Gtk::Table, peuvent incorporer plusieurs éléments graphiques enfants ; leur interface est donc bien évidemment plus complexe. D'autres, comme Gtk::Frame, ne comportent qu'un seul élément graphique enfant.

### Conteneurs mono-éléments

Les éléments conteneurs mono-éléments dérivent de la classe Gtk::Bin ; cette classe comporte les fonctions membres add() et remove() pour les éléments graphiques enfants. Notez que les objets de la classe Gtk::Button et Gtk::Window sont techniquement des conteneurs mono-éléments ; nous l'avons déjà signalé par ailleurs.

Nous évoquerons également l'élément graphique Gtk::Paned qui vous permet de partager une fenêtre en deux « volets » séparés. Cet élément graphique comporte en réalité deux éléments graphiques enfants, mais comme ce nombre est fixe, son classement dans les mono-éléments paraît approprié.

#### Cadre

Les cadres, avec un intitulé en option, peuvent entourer un ou un groupe d'éléments graphiques dans une boîte. Par exemple, vous pouvez placer un groupe de RadioButton ou de CheckButton dans un objet Frame.

Référence

##### Exemple

Cadre

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      //Child widgets:
      Gtk::Frame m_Frame;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    {
     /* Set some window properties */
      set_title("Frame Example");
      set_size_request(300, 300);

      /* Sets the border width of the window. */
      set_border_width(10);

      add(m_Frame);

      /* Set the frames label */
      m_Frame.set_label("Gtk::Frame Widget");

      /* Align the label at the right of the frame */
      //m_Frame.set_label_align(Gtk::ALIGN_END, Gtk::ALIGN_START);

      /* Set the style of the frame */
      m_Frame.set_shadow_type(Gtk::SHADOW_ETCHED_OUT);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Volets

Les volets résultent de la division d'un élément graphique en deux parties délimitées par une séparation mobile. Il existe deux sortes d'éléments graphiques de ce type : Gtk::HPaned avec une division horizontale et Gtk::VPaned avec une division verticale.

Contrairement aux autres éléments graphiques de ce chapitre, les éléments graphiques à volet comportent non pas un, mais deux éléments graphiques enfants, un dans chaque volet. C'est pourquoi, vous devez utilisez les fonctions membres add1() et add2() au lieu de la fonction membre add().

Il est possible d'ajuster la position de la division avec la fonction membre set_position() ; vous aurez certainement besoin de le faire.

Référence

##### Exemple

Volets

Code source

File: `messageslist.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MESSAGESLIST_H
    #define GTKMM_EXAMPLE_MESSAGESLIST_H

    #include <gtkmm.h>

    class MessagesList: public Gtk::ScrolledWindow
    {
    public:
      MessagesList();
      virtual ~MessagesList();

      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_text); }

        Gtk::TreeModelColumn<Glib::ustring> m_col_text;
      };

      ModelColumns m_Columns;

    protected:
      Glib::RefPtr<Gtk::ListStore> m_refListStore; //The Tree Model.
      Gtk::TreeView m_TreeView; //The Tree View.
    };
    #endif //GTKMM_EXAMPLE_MESSAGESLIST_H

File: `messagetext.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MESSAGETEXT_H
    #define GTKMM_EXAMPLE_MESSAGETEXT_H

    #include <gtkmm.h>

    class MessageText : public Gtk::ScrolledWindow
    {
    public:
      MessageText();
      virtual ~MessageText();

      void insert_text();

    protected:
      Gtk::TextView m_TextView;
    };

    #endif //GTKMM_EXAMPLE_MESSAGETEXT_H

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include "messageslist.h"
    #include "messagetext.h"
    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      //Child widgets:
      Gtk::Paned m_VPaned;
      MessagesList m_MessagesList;
      MessageText m_MessageText;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `messagetext.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "messagetext.h"

    MessageText::MessageText()
    {
      set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      add(m_TextView);
      insert_text();

      show_all_children();
    }

    MessageText::~MessageText()
    {
    }

    void MessageText::insert_text()
    {
      Glib::RefPtr<Gtk::TextBuffer> refTextBuffer = m_TextView.get_buffer();

      Gtk::TextBuffer::iterator iter = refTextBuffer->get_iter_at_offset(0);
      refTextBuffer->insert(iter,
        "From: pathfinder@nasa.gov\n"
        "To: mom@nasa.gov\n"
        "Subject: Made it!\n"
        "\n"
        "We just got in this morning. The weather has been\n"
        "great - clear but cold, and there are lots of fun sights.\n"
        "Sojourner says hi. See you soon.\n"
        " -Path\n");
    }

File: `messageslist.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "messageslist.h"
    #include <sstream>

    MessagesList::MessagesList()
    {
      /* Create a new scrolled window, with scrollbars only if needed */
      set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      add(m_TreeView);

      /* create list store */
      m_refListStore = Gtk::ListStore::create(m_Columns);

      m_TreeView.set_model(m_refListStore);

      /* Add some messages to the window */
      for(int i = 0; i < 10; ++i)
      {
        std::ostringstream text;
        text << "message #" << i;

        Gtk::TreeModel::Row row = *(m_refListStore->append());
        row[m_Columns.m_col_text] = text.str();
      }

      //Add the Model's column to the View's columns:
      m_TreeView.append_column("Messages", m_Columns.m_col_text);

      show_all_children();
    }

    MessagesList::~MessagesList()
    {
    }

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VPaned(Gtk::ORIENTATION_VERTICAL)
    {
      set_title ("Paned Windows");
      set_border_width(10);
      set_default_size(450, 400);

      /* Add a vpaned widget to our toplevel window */
      add(m_VPaned);

      /* Now add the contents of the two halves of the window */
      m_VPaned.add1(m_MessagesList);
      m_VPaned.add2(m_MessageText);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Fenêtre à défilement

Les éléments graphiques ScrolledWindow créent une zone qu'il est possible de faire défiler. Vous pouvez insérer n'importe quel type d'élément graphique dans une fenêtre de la classe ScrolledWindow ; cet élément graphique restera totalement accessible quelle que soit sa taille grâce aux barres de défilement. Notez que la classe ScrolledWindow ne dérive pas de la classe Gtk::Window, même si les dénominations peuvent prêter à confusion.

La fenêtre déroulante définit une politique de barres de défilement pour indiquer comment son objet Scrollbar doit être affiché. Cette politique est définie à l'aide de la fonction membre set_policy(). Le paramètre `policy` prend l'une des deux valeurs suivantes : `Gtk::POLICY_AUTOMATIC` ou bien `Gtk::POLICY_ALWAYS`. `Gtk::POLICY_AUTOMATIC` déclenche l'affichage de la barre de défilement uniquement si l'élément graphique incorporé est plus grand que la zone visible. Avec `Gtk::POLICY_ALWAYS`, les barres de défilement sont toujours affichées.

Référence

##### Exemple

Voici un exemple simple qui place 100 boutons bascules dans une fenêtre à défilement. Essayez de redimensionner la fenêtre pour voir comment les barres de défilement réagissent.

Fenêtre à défilement

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Dialog
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_close();

      //Child widgets:
      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::Table m_Table;
      Gtk::Button m_Button_Close;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <cstdio>

    ExampleWindow::ExampleWindow()
    : m_Table(10, 10),
      m_Button_Close("Close")
    {
      set_title("Gtk::ScrolledWindow example");
      set_border_width(0);
      set_size_request(300, 300);

      m_ScrolledWindow.set_border_width(10);

      /* the policy is one of Gtk::POLICY AUTOMATIC, or Gtk::POLICY_ALWAYS.
       * Gtk::POLICY_AUTOMATIC will automatically decide whether you need
       * scrollbars, whereas Gtk::POLICY_ALWAYS will always leave the scrollbars
       * there.  The first one is the horizontal scrollbar, the second,
       * the vertical. */
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_ALWAYS);

      get_content_area()->pack_start(m_ScrolledWindow);

      /* set the spacing to 10 on x and 10 on y */
      m_Table.set_row_spacings(10);
      m_Table.set_col_spacings(10);

      /* pack the table into the scrolled window */
      m_ScrolledWindow.add(m_Table);

      /* this simply creates a grid of toggle buttons on the table
       * to demonstrate the scrolled window. */
      for(int i = 0; i < 10; i++)
      {
         for(int j = 0; j < 10; j++)
         {
            char buffer[32];
            sprintf(buffer, "button (%d,%d)\n", i, j);
            Gtk::Button* pButton = Gtk::manage(new Gtk::ToggleButton(buffer));
            m_Table.attach(*pButton, i, i + 1, j, j + 1);
         }
      }

      /* Add a "close" button to the bottom of the dialog */
      m_Button_Close.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_close));

      /* this makes it so the button is the default. */
      m_Button_Close.set_can_default();

      Gtk::Box* pBox = get_action_area();
      if(pBox)
        pBox->pack_start(m_Button_Close);

      /* This grabs this button to be the default button. Simply hitting
       * the "Enter" key will cause this button to activate. */
      m_Button_Close.grab_default();

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_close()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Cadre proportionné

L'élément graphique de la classe AspectFrame est semblable à l'élément graphique Frame, mais, en plus, il impose à l'élément graphique enfant de garder un rapport de proportion (rapport de la largeur à la hauteur) constant ; il laisse un espace libre si nécessaire. Par exemple, vous pourrez afficher une photographie sans que l'utilisateur puisse la déformer horizontalement ou verticalement lorsqu'il la redimensionne.

Référence

##### Exemple

Le programme suivant utilise un objet Gtk::AspectFrame pour afficher une surface de tracé dont les proportions sont toujours égales à 2:1 quelles que soient les dimensions données à la fenêtre principale par l'utilisateur.

Cadre proportionné

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      //Child widgets:
      Gtk::AspectFrame m_AspectFrame;
      Gtk::DrawingArea m_DrawingArea;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_AspectFrame("2x1", /* label */
        Gtk::ALIGN_CENTER, /* center x */
        Gtk::ALIGN_CENTER, /* center y */
        2.0, /* xsize/ysize = 2 */
        false /* ignore child's aspect */)
    {
      set_title("Aspect Frame");
      set_border_width(10);

      // Add a child widget to the aspect frame */
      // Ask for a 200x200 window, but the AspectFrame will give us a 200x100
      // window since we are forcing a 2x1 aspect ratio */
      m_DrawingArea.set_size_request(200, 200);
      m_AspectFrame.add(m_DrawingArea);

      // Add the aspect frame to our toplevel window:
      add(m_AspectFrame);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Alignement

L'élément conteneur Alignment vous permet de placer dans une fenêtre un élément graphique dont la taille et la position sont mesurés en rapport de celle du conteneur Alignment lui-même. Par exemple, vous pourrez l'utiliser pour centrer un contrôle.

Il est nécessaire de préciser les caractéristiques de l'objet Alignment dans son constructeur, ou bien à l'aide de la fonction membre set(). En particulier, vous ne noterez aucun effet si vous ne définissez pas un nombre différent de 1.0 pour les paramètres `xscale` et `yscale` ; en effet, 1.0 signifie simplement que l'élément graphique enfant doit prendre tout l'espace disponible.

Référence

##### Exemple

Cet exemple aligne à droite un bouton dans une fenêtre à l'aide de l'élément conteneur Alignment.

Alignement

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_clicked();

      //Child widgets:
      Gtk::Alignment m_Alignment;
      Gtk::Button m_Button;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_Alignment(Gtk::ALIGN_END, Gtk::ALIGN_CENTER, 0.0, 0.0),
      m_Button("Close")
    {
      set_title("Gtk::Alignement");
      set_border_width(10);
      set_default_size(200, 50);

      add(m_Alignment);

      m_Alignment.add(m_Button);

      m_Button.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_clicked) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_clicked()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

Dans le paragraphe sur les Barres de progression, vous pourrez voir un autre exemple d'utilisation de la classe Alignment.

### Conteneurs multi-éléments

Les éléments graphiques conteneurs multi-éléments héritent de la classe Gtk::Container ; comme avec Gtk::Bin, vous utilisez les fonctions membres add() et remove() pour ajouter ou supprimer des éléments graphiques du conteneur. Mais, contrairement à Gtk::Bin::remove(), la fonction membre remove() de la classe Gtk::Container exige un paramètre désignant l'élément graphique à enlever.

#### Empaquetage

Vous avez probablement remarqué que les fenêtres gtkmm semblent « élastiques » — elles peuvent être étirées de diverses manières. Cette propriété résulte du système « d'empaquetage des éléments graphiques ».

Beaucoup de boîtes à outils GUI exigent que les éléments graphiques soient placés avec précision dans une fenêtre, avec un positionnement absolu, souvent en utilisant un utilitaire visuel. Plusieurs problèmes en découlent :

- Les éléments graphiques ne se réarrangent pas par eux-mêmes quand la fenêtre est redimensionnée. Certains éléments graphiques sont masqués quand la fenêtre est rapetissée et des espaces libres inutiles apparaissent quand la fenêtre est agrandie.

- Il n'est pas possible de prévoir l'espace nécessaire à un texte après traduction en d'autres langues ou après affichage avec une police différente. Sur Unix, il est également impossible d'anticiper les effets de chaque thème ou de chaque gestionnaire de fenêtres.

- Modifier la disposition d'une fenêtre « à la volée », pour faire apparaître quelques éléments graphiques supplémentaires, par exemple, est compliqué. Cela demande un nouveau calcul ennuyeux de la position de chaque élément graphique.

gtkmm utilise un système d'empaquetage pour résoudre ces problèmes. Plutôt que de définir la position et la taille de chaque élément graphique dans la fenêtre, vous pouvez les disposer en rangées, en colonnes ou en tableaux. gtkmm dimensionne votre fenêtre automatiquement, selon la taille des éléments graphiques qu'elle contient. Les tailles des éléments graphiques sont, à leur tour, déterminées par la quantité de texte contenue ou bien par les tailles minimales ou maximales fixées de même que par les règles voulues pour le partage des espaces libres entre les jeux d'éléments graphiques. Vous pouvez parfaire la disposition en définissant les dimensions des remplissages et des valeurs de centrage pour chacun des éléments graphiques. gtkmm utilise ces informations pour redimensionner et repositionner chaque élément intelligemment et souplement quand l'utilisateur manipule la fenêtre.

gtkmm dispose les éléments graphiques de manière hiérarchique en utilisant des conteneurs. Un élément graphique conteneur contient d'autres éléments graphiques. La plupart des éléments graphiques gtkmm sont des conteneurs. Fenêtres, onglets de bloc-notes et boutons sont tous des éléments graphiques conteneurs. Il existe deux sortes de conteneurs : les conteneurs mono-enfant, qui dérivent tous de la classe Gtk::Bin et les conteneurs multi-enfants qui héritent de la classe Gtk::Container. La plupart des éléments graphiques de gtkmm dérivent de la classe Gtk::Bin, y compris Gtk::Window.

Oui, ceci est correct : un objet Window peut contenir au plus un élément graphique. Comment, alors, se servir utilement d'une fenêtre ? En y plaçant un conteneur multi-enfants. Les conteneurs d'éléments graphiques les plus utiles sont les objets Gtk:Grid, Gtk:VBox, Gtk::HBox et Gtk::Table.

- Gtk::Grid disposent respectivement leurs éléments graphiques enfants en lignes et en colonnes. Utilisez attach(), attach_next_to() et add() pour insérer des éléments graphiques enfants.

- Gtk::VBox et Gtk::HBox disposent respectivement leurs éléments graphiques enfants verticalement et horizontalement. Utilisez pack_start() et pack_end() pour insérer des éléments graphiques enfants.

- Gtk::Table place ses éléments graphiques sur une grille. Utilisez attach() pour insérer les éléments graphiques.

Il existe plusieurs autres conteneurs. Nous en parlerons également.

Si vous n'avez jamais utilisé auparavant un utilitaire d'empaquetage, son utilisation nécessitera une prise en main. Toutefois, vous constaterez probablement que, contrairement à d'autres boîtes à outils, il n'y a pas besoin de faire appel à un éditeur de type visuel.

#### Un Hello World amélioré

Regardons un `helloworld` légèrement perfectionné en se servant de nos nouvelles connaissances.

Hello World 2

Code source

File: `helloworld.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_HELLOWORLD_H
    #define GTKMM_EXAMPLE_HELLOWORLD_H

    #include <gtkmm/box.h>
    #include <gtkmm/button.h>
    #include <gtkmm/window.h>

    class HelloWorld : public Gtk::Window
    {
    public:
      HelloWorld();
      virtual ~HelloWorld();

    protected:

      // Signal handlers:
      // Our new improved on_button_clicked(). (see below)
      void on_button_clicked(Glib::ustring data);

      // Child widgets:
      Gtk::Box m_box1;
      Gtk::Button m_button1, m_button2;
    };

    #endif // GTKMM_EXAMPLE_HELLOWORLD_H

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "helloworld.h"
    #include <gtkmm/main.h>

    int main (int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      HelloWorld helloworld;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(helloworld);

      return 0;
    }

File: `helloworld.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "helloworld.h"
    #include <iostream>

    HelloWorld::HelloWorld()
    : m_button1("Button 1"),
      m_button2("Button 2")
    {
      // This just sets the title of our new window.
      set_title("Hello Buttons!");

      // sets the border width of the window.
      set_border_width(10);

      // put the box into the main window.
      add(m_box1);

      // Now when the button is clicked, we call the "on_button_clicked" function
      // with a pointer to "button 1" as it's argument
      m_button1.signal_clicked().connect(sigc::bind<Glib::ustring>(
                  sigc::mem_fun(*this, &HelloWorld::on_button_clicked), "button 1"));

      // instead of gtk_container_add, we pack this button into the invisible
      // box, which has been packed into the window.
      // note that the pack_start default arguments are Gtk::EXPAND | Gtk::FILL, 0
      m_box1.pack_start(m_button1);

      // always remember this step, this tells GTK that our preparation
      // for this button is complete, and it can be displayed now.
      m_button1.show();

      // call the same signal handler with a different argument,
      // passing a pointer to "button 2" instead.
      m_button2.signal_clicked().connect(sigc::bind<-1, Glib::ustring>(
                  sigc::mem_fun(*this, &HelloWorld::on_button_clicked), "button 2"));

      m_box1.pack_start(m_button2);

      // Show the widgets.
      // They will not really be shown until this Window is shown.
      m_button2.show();
      m_box1.show();
    }

    HelloWorld::~HelloWorld()
    {
    }

    // Our new improved signal handler.  The data passed to this method is
    // printed to stdout.
    void HelloWorld::on_button_clicked(Glib::ustring data)
    {
      std::cout << "Hello World - " << data << " was pressed" << std::endl;
    }

Après avoir construit et lancé ce programme, essayez de redimensionner la fenêtre pour voir son comportement. Également, essayez de jouer avec les options de la fonction membre pack_start() après avoir lu le paragraphe relatif aux boîtes.

#### Boîtes

Beaucoup d'empaquetages utilisent des boîtes comme dans l'exemple précédent. Ce sont des conteneurs invisibles dans lesquels nous pouvons placer les éléments graphiques. Si nous empaquetons dans une boîte horizontale, les objets seront insérés horizontalement de la gauche vers la droite ou inversement selon que l'on utilise pack_start() ou pack_end(). Dans une boîte verticale, les éléments graphiques sont empaquetés du haut vers le bas ou vice versa. Vous pouvez utiliser toute combinaison de boîtes dans ou à côté d'autres boîtes pour créer les effets voulus.

##### Ajout d'éléments graphiques

###### Options d'empaquetage par enfant

Les fonctions membres pack_start() et pack_end() placent les éléments graphiques dans ces conteneurs. La fonction membre pack_start() débute l'insertion en haut de l'objet VBox et va en descendant ; elle empaquette de gauche vers la droite dans un objet HBox. La fonction membre pack_end() fait l'inverse. Elle empaquette de bas en haut dans un VBox, de droite à gauche dans un HBox. L'utilisation de ces fonctions membres vous permet de justifier à droite ou à gauche les éléments graphiques. Nous nous servirons de pack_start() dans la plupart de nos exemples.

Il y a plusieurs options régissant la manière dont les éléments graphiques doivent être empaquetés ; cela peut sembler confus au début. Si vous avez des difficultés, nous vous suggérons l'idée de manipuler le concepteur GUI glade pour voir ce qui est possible. Vous pourrez même décider d'utiliser l'API Gtk::Builder pour charger les interfaces utilisateur au lancement du programme.

À la base, il y cinq styles différents comme illustré dans cette figure :

Empaquetage dans boîte n°1

Chaque ligne est constituée d'une boîte horizontale (HBox) avec plusieurs boutons. Chacun des boutons de la ligne est empaqueté dans l'objet HBox avec les mêmes paramètres à l'aide de la fonction membre pack_start().

Voici la déclaration de la fonction membre pack_start() :

    void pack_start(Gtk::Widget& child,
                    PackOptions options = PACK_EXPAND_WIDGET,
                    guint padding = 0);

Le premier paramètre désigne l'élément graphique à empaquer. Dans notre exemple, ce sont tous des objets Button.

Le paramètre options peut prendre une des trois valeurs suivantes :

- `PACK_SHRINK` : l'espace est condensé à la taille des éléments graphiques enfants. L'élément graphique prend la place qui lui est juste nécessaire et n'est jamais étiré.

- `PACK_EXPAND_PADDING` : l'espace excédentaire est constitué de remplissage. Les éléments graphiques sont régulièrement espacés, mais leurs tailles ne varient pas — des espaces vides sont ménagés entre éléments graphiques.

- `PACK_EXPAND_WIDGET` : l'espace excédentaire est occupé par une augmentation de la taille des éléments graphiques enfants, sans modifier la répartition de l'espacement entre éléments graphiques.

Le paramètre padding définit la largeur de la bordure libre autour de l'élément graphique empaqueté.

Référence

###### Options d'empaquetage par conteneur

Voici le constructeur des éléments graphiques de la boîte :

    Gtk::Box(bool homogeneous = false, int spacing = 0);

Si le paramètre homogeneous est défini à `true`, tous les éléments graphiques de la boîte auront la même taille. spacing représente le nombre de pixels (minimum) à laisser entre chaque élément graphique.

Quelle est la différence entre espacement (déterminé quand la boîte est crée) et remplissage (défini quand les éléments sont empaquetés) ? L'espacement est inséré entre les objets alors que le remplissage est ajouté sur les côtés du élément graphique. L'illustration ci-après clarifie cela :

Empaquetage dans boîte n°2

##### Exemple

Voici le code source de l'exemple qui a servi à générer la capture d'écran ci-dessus. Quand vous lancez cet exemple, indiquez un nombre entre 1 et 3 en option de ligne de commande pour voir les diverses options d'empaquetage utilisées.

Code source

File: `packbox.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_PACKBOX_H
    #define GTKMM_EXAMPLE_PACKBOX_H

    #include <gtkmm.h>

    class PackBox : public Gtk::Box
    {
    public:
      PackBox(bool homogeneous, int spacing, Gtk::PackOptions, int padding = 0);
      virtual ~PackBox();

    protected:
      Gtk::Button m_button1, m_button2, m_button3;
      Gtk::Button* m_pbutton4;

      char padstr[80];
    };

    #endif //GTKMM_EXAMPLE_PACKBOX_H

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>
    #include "packbox.h"

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow(int which);
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_quit_clicked();

      //Child widgets:
      Gtk::Button m_button;
      Gtk::Box m_box1;
      Gtk::Box m_boxQuit;
      Gtk::Button m_buttonQuit;

      Gtk::Label m_Label1, m_Label2;

      Gtk::Separator m_seperator1, m_seperator2, m_seperator3, m_seperator4, m_seperator5;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include "examplewindow.h"

    ExampleWindow::ExampleWindow(int which)
    : m_box1(Gtk::ORIENTATION_VERTICAL),
      m_buttonQuit("Quit")
    {
      set_title("Gtk::Box example");

      PackBox *pPackBox1, *pPackBox2, *pPackBox3, *pPackBox4, *pPackBox5;

      switch(which)
      {
        case 1:
        {
          m_Label1.set_text("Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 0);");

          // Align the label to the left side.  We'll discuss this function and
          // others in the section on Widget Attributes.
          m_Label1.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_START);

          // Pack the label into the vertical box (vbox box1).  Remember that
          // widgets added to a vbox will be packed one on top of the other in
          // order.
          m_box1.pack_start(m_Label1, Gtk::PACK_SHRINK);

          // Create a PackBox - homogeneous = false, spacing = 0,
          // options = Gtk::PACK_SHRINK, padding = 0
          pPackBox1 = Gtk::manage(new PackBox(false, 0, Gtk::PACK_SHRINK));
          m_box1.pack_start(*pPackBox1, Gtk::PACK_SHRINK);

          // Create a PackBox - homogeneous = false, spacing = 0,
          // options = Gtk::PACK_EXPAND_PADDING, padding = 0
          pPackBox2 = Gtk::manage(new PackBox(false, 0, Gtk::PACK_EXPAND_PADDING));
          m_box1.pack_start(*pPackBox2, Gtk::PACK_SHRINK);

          // Create a PackBox - homogeneous = false, spacing = 0,
          // options = Gtk::PACK_EXPAND_WIDGET, padding = 0
          pPackBox3 = Gtk::manage(new PackBox(false, 0, Gtk::PACK_EXPAND_WIDGET));
          m_box1.pack_start(*pPackBox3, Gtk::PACK_SHRINK);

          // pack the separator into the vbox.  Remember each of these
          // widgets are being packed into a vbox, so they'll be stacked
          // vertically.
          m_box1.pack_start(m_seperator1, Gtk::PACK_SHRINK, 5);

          // create another new label, and show it.
          m_Label2.set_text("Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 0);");
          m_Label2.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_START);
          m_box1.pack_start(m_Label2, Gtk::PACK_SHRINK);

          // Args are: homogeneous, spacing, options, padding
          pPackBox4 = Gtk::manage(new PackBox(true, 0, Gtk::PACK_EXPAND_PADDING));
          m_box1.pack_start(*pPackBox4, Gtk::PACK_SHRINK);

          // Args are: homogeneous, spacing, options, padding
          pPackBox5 = Gtk::manage(new PackBox(true, 0, Gtk::PACK_EXPAND_WIDGET));
          m_box1.pack_start(*pPackBox5, Gtk::PACK_SHRINK);

          m_box1.pack_start(m_seperator2, Gtk::PACK_SHRINK, 5);

          break;
        }

        case 2:
        {

          m_Label1.set_text("Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 10);");
          m_Label1.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_START);
          m_box1.pack_start(m_Label1, Gtk::PACK_SHRINK);

          pPackBox1 = Gtk::manage(new PackBox(false, 10, Gtk::PACK_EXPAND_PADDING));
          m_box1.pack_start(*pPackBox1, Gtk::PACK_SHRINK);

          pPackBox2 = Gtk::manage(new PackBox(false, 10, Gtk::PACK_EXPAND_WIDGET));
          m_box1.pack_start(*pPackBox2, Gtk::PACK_SHRINK);

          m_box1.pack_start(m_seperator1, Gtk::PACK_SHRINK, 5);

          m_Label2.set_text("Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 0);");
          m_Label2.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_START);
          m_box1.pack_start(m_Label2, Gtk::PACK_SHRINK);

          pPackBox3 = Gtk::manage(new PackBox(false, 0, Gtk::PACK_SHRINK, 10));
          m_box1.pack_start(*pPackBox3, Gtk::PACK_SHRINK);

          pPackBox4 = Gtk::manage(new PackBox(false, 0, Gtk::PACK_EXPAND_WIDGET, 10));
          m_box1.pack_start(*pPackBox4, Gtk::PACK_SHRINK);

          m_box1.pack_start(m_seperator2, Gtk::PACK_SHRINK, 5);

          break;
        }

        case 3:
        {
          // This demonstrates the ability to use Gtk::Box::pack_end() to
          // right justify widgets.  First, we create a new box as before.
          pPackBox1 = Gtk::manage(new PackBox(false, 0, Gtk::PACK_SHRINK));

          // create the label that will be put at the end.
          m_Label1.set_text("end");

          // pack it using pack_end(), so it is put on the right side
          // of the PackBox.
          pPackBox1->pack_end(m_Label1, Gtk::PACK_SHRINK);

          m_box1.pack_start(*pPackBox1, Gtk::PACK_SHRINK);

          // this explicitly sets the separator to 400 pixels wide by 5 pixels
          // high.  This is so the hbox we created will also be 400 pixels wide,
          // and the "end" label will be separated from the other labels in the
          // hbox.  Otherwise, all the widgets in the hbox would be packed as
          // close together as possible.
          m_seperator1.set_size_request(400, 5);

          // pack the separator into ourselves
          m_box1.pack_start(m_seperator1, Gtk::PACK_SHRINK, 5);

          break;
        }

        default:
        {
          std::cerr << "Unexpected command-line option." << std::endl;
          break;
        }
      }

      // Connect the signal to hide the window:
      m_buttonQuit.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit_clicked) );

      // pack the button into the quitbox.
      // The last 2 arguments to Box::pack_start are: options, padding.
      m_boxQuit.pack_start(m_buttonQuit, Gtk::PACK_EXPAND_PADDING);
      m_box1.pack_start(m_boxQuit, Gtk::PACK_SHRINK);

      // pack the vbox (box1) which now contains all our widgets, into the
      // main window.
      add(m_box1);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit_clicked()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>
    #include <iostream>
    #include <cstdlib>

    using std::atoi;

    int main(int argc, char *argv[])
    {
      Gtk::Main main_instance(argc, argv);

      if(argc != 2)
      {
        std::cerr << "usage: packbox num, where num is 1, 2, or 3." << std::endl;
        return 1;
      }

      ExampleWindow window( atoi(argv[1]) );
      Gtk::Main::run(window); //Shows the window and returns when it is closed.

      return 0;
    }

File: `packbox.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "packbox.h"
    #include <cstdio> //For sprintf().

    PackBox::PackBox(bool homogeneous, int spacing, Gtk::PackOptions options,
            int padding)
    : Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, spacing),
      m_button1("box.pack_start("),
      m_button2("button,"),
      m_button3((options == Gtk::PACK_SHRINK) ? "Gtk::PACK_SHRINK" :
                ((options == Gtk::PACK_EXPAND_PADDING) ?
                 "Gtk::PACK_EXPAND_PADDING" : "Gtk::PACK_EXPAND_WIDGET"))
    {
      set_homogeneous(homogeneous);

      pack_start(m_button1, options, padding);
      pack_start(m_button2, options, padding);
      pack_start(m_button3, options, padding);

      sprintf(padstr, "%d);", padding);

      m_pbutton4 = new Gtk::Button(padstr);
      pack_start(*m_pbutton4, options, padding);
    }

    PackBox::~PackBox()
    {
      delete m_pbutton4;
    }

#### Boîtes à boutons

Les boîtes à boutons sont un moyen commode de disposer rapidement un groupe de boutons. Il en existe deux types : un horizontal (Gtk::HButtonBox) et un vertical (Gtk::VButtonBox). Ils sont tout à fait semblables ; ils ne différent que par leur nom et leur orientation.

Les ButtonBox donnent une apparence homogène aux applications en utilisant des réglages normalisés pour l'espacement entre boutons et pour l'empaquetage.

Les boutons sont insérés dans l'objet ButtonBox à l'aide de la fonction membre add().

Les boîtes à boutons prennent en charge divers styles de dispositions. Le style peut être obtenu et modifié avec les fonctions membres get_layout() et set_layout().

Référence

##### Exemple

Boîte à bouton

Code source

File: `examplebuttonbox.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_BUTTONBOX_H
    #define GTKMM_EXAMPLE_BUTTONBOX_H

    #include <gtkmm.h>

    class ExampleButtonBox : public Gtk::Frame
    {
    public:
      ExampleButtonBox(bool horizontal,
           const Glib::ustring& title,
           gint spacing,
           Gtk::ButtonBoxStyle layout);

    protected:
      Gtk::Button m_Button_OK, m_Button_Cancel, m_Button_Help;
    };

    #endif //GTKMM_EXAMPLE_BUTTONBOX_H

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_clicked();

      //Child widgets:
      Gtk::Box m_VBox_Main, m_VBox;
      Gtk::Box m_HBox;
      Gtk::Frame m_Frame_Horizontal, m_Frame_Vertical;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplebuttonbox.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplebuttonbox.h"

    ExampleButtonBox::ExampleButtonBox(bool horizontal,
           const Glib::ustring& title,
           gint spacing,
           Gtk::ButtonBoxStyle layout)
    : Gtk::Frame(title),
      m_Button_OK("OK"),
      m_Button_Cancel("Cancel"),
      m_Button_Help("Help")
    {
      Gtk::ButtonBox* bbox = 0;

      if(horizontal)
        bbox = Gtk::manage( new Gtk::ButtonBox(Gtk::ORIENTATION_HORIZONTAL) );
      else
        bbox = Gtk::manage( new Gtk::ButtonBox(Gtk::ORIENTATION_VERTICAL) );

      bbox->set_border_width(5);

      add(*bbox);

      /* Set the appearance of the Button Box */
      bbox->set_layout(layout);
      bbox->set_spacing(spacing);

      bbox->add(m_Button_OK);
      bbox->add(m_Button_Cancel);
      bbox->add(m_Button_Help);
    }

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include "examplebuttonbox.h"

    ExampleWindow::ExampleWindow()
    : m_VBox_Main(Gtk::ORIENTATION_VERTICAL),
      m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Frame_Horizontal("Horizontal Button Boxes"),
      m_Frame_Vertical("Vertical Button Boxes")
    {
      set_title("Gtk::ButtonBox");
      add(m_VBox_Main);

      m_VBox_Main.pack_start(m_Frame_Horizontal, Gtk::PACK_EXPAND_WIDGET, 10);

      //The horizontal ButtonBoxes:
      m_VBox.set_border_width(10);
      m_Frame_Horizontal.add(m_VBox);

      m_VBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(true, "Spread (spacing 40)", 40,
                      Gtk::BUTTONBOX_SPREAD)),
              Gtk::PACK_EXPAND_WIDGET, 0);

      m_VBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(true, "Edge (spacing 30)", 30,
                      Gtk::BUTTONBOX_EDGE)),
              Gtk::PACK_EXPAND_WIDGET, 5);

      m_VBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(true, "Start (spacing 20)", 20,
                      Gtk::BUTTONBOX_START)),
              Gtk::PACK_EXPAND_WIDGET, 5);

      m_VBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(true, "end (spacing 10)", 10,
                      Gtk::BUTTONBOX_END)),
              Gtk::PACK_EXPAND_WIDGET, 5);

      //The vertical ButtonBoxes:
      m_VBox_Main.pack_start(m_Frame_Vertical, Gtk::PACK_EXPAND_WIDGET, 10);

      m_HBox.set_border_width(10);
      m_Frame_Vertical.add(m_HBox);

      m_HBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(false, "Spread (spacing 5)", 5,
                      Gtk::BUTTONBOX_SPREAD)),
              Gtk::PACK_EXPAND_WIDGET, 0);

      m_HBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(false, "Edge (spacing 30)", 30,
                      Gtk::BUTTONBOX_EDGE)),
              Gtk::PACK_EXPAND_WIDGET, 5);

      m_HBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(false, "Start (spacing 20)", 20,
                      Gtk::BUTTONBOX_START)),
              Gtk::PACK_EXPAND_WIDGET, 5);

      m_HBox.pack_start(*Gtk::manage(new ExampleButtonBox(false, "End (spacing 10)",
                      10, Gtk::BUTTONBOX_END)),
              Gtk::PACK_EXPAND_WIDGET, 5);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_clicked()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Grille

A Grid dynamically lays out child widgets in rows and columns. The dimensions of the grid do not need to be specified in the constructor.

Child widgets can span multiple rows or columns, using attach(), or added next to an existing widget inside the grid with attach_next_to(). Individual rows and columns of the grid can be set to have uniform height or width with set_row_homogeneous() and set_column_homogeneous().

You can set the margin and expand properties of the child Widgets to control their spacing and their behaviour when the Grid is resized.

Référence

##### Exemple

This example creates a window with three buttons in a grid. The first two buttons are in the upper row, from left to right. A third button is attached underneath the first button, in a new lower row, spanning two columns.

Grille

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    private:
      // Signal handlers:
      void on_button_quit();
      void on_button_numbered(const Glib::ustring& data);

      // Child widgets:
      Gtk::Grid m_grid;
      Gtk::Button m_button_1, m_button_2, m_button_quit;
    };

    #endif /* GTKMM_EXAMPLEWINDOW_H */

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_button_1("button 1"),
      m_button_2("button 2"),
      m_button_quit("Quit")
    {
      set_title("Gtk::Grid");
      set_border_width(12);

      add(m_grid);

      m_grid.add(m_button_1);
      m_grid.add(m_button_2);
      m_grid.attach_next_to(m_button_quit, m_button_1, Gtk::POS_BOTTOM, 2, 1);

      m_button_1.signal_clicked().connect(
        sigc::bind<Glib::ustring>( sigc::mem_fun(*this,
          &ExampleWindow::on_button_numbered), "button 1") );
      m_button_2.signal_clicked().connect(
        sigc::bind<Glib::ustring>( sigc::mem_fun(*this,
          &ExampleWindow::on_button_numbered), "button 2") );

      m_button_quit.signal_clicked().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_button_quit) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

    void
    ExampleWindow::on_button_numbered(const Glib::ustring& data)
    {
      std::cout << data << " was pressed" << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      // Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Tableau

Les tableaux permettent de placer les éléments graphiques sur une grille, de manière identique à Gtk::Grid.

##### Constructeur

Il est nécessaire de définir les dimensions de la grille dans le constructeur :

    Gtk::Table(int rows = 1, int columns = 1, bool homogeneous = false);

Le premier paramètre est le nombre de lignes du tableau, le second le nombre de colonnes. Si homogeneous est égal à `true`, toutes les cellules du tableau auront la même taille (la taille du plus grand élément graphique du tableau).

Les lignes et les colonnes sont numérotées à partir de zéro. Si vous définissez rows = 2 et columns = 2, la disposition ressemble à ceci :

     0          1          2
    0+----------+----------+
     |          |          |
    1+----------+----------+
     |          |          |
    2+----------+----------+

Notez que l'origine du système de coordonnées est l'angle supérieur gauche.

##### Ajout d'éléments graphiques

Pour placer un élément graphique dans une cellule, utilisez la fonction membre suivante :

    void Gtk::Table::attach(Gtk::Widget& child,
                            guint left_attach, guint right_attach,
                            guint top_attach, guint bottom_attach,
                            guint xoptions = Gtk::FILL | Gtk::EXPAND,
                            guint yoptions = Gtk::FILL | Gtk::EXPAND,
                            guint xpadding = 0, guint ypadding = 0);

Le premier paramètre est l'élément graphique que vous souhaitez placer dans la table.

Les paramètres left_attach et right_attach indiquent où placer l'élément graphique et combien de cellules utiliser. Par exemple, si vous voulez placer un bouton dans la cellule inférieure droite d'un tableau 2 x 2 et souhaitez qu'il occupe uniquement cette cellule, alors left_attach doit être égal à 1, right_attach à 2, top_attach à 1 et bottom_attach à 2. Si, d'autre part, vous souhaitez que l'élément graphique occupe la totalité de la rangée haute du tableau 2 x 2, vous définirez left_attach = 0, right_attach = 2, top_attach = 0 et bottom_attach = 1.

Les paramètres xoptions et yoptions s'utilisent pour définir les options d'empaquetage. Pour définir des options multiples, il convient de les lier entre elles avec l'opérateur binaire OR. Ces options sont :

`Gtk::FILL`

  Si la cellule du tableau est plus grande que l'élément graphique et si `Gtk::FILL` est indiqué, l'élément graphique sera étiré pour utiliser toute la place disponible.

`Gtk::SHRINK`

  Si l'élément graphique tableau dispose de moins de place que nécessaire (parce que l'utilisateur a redimensionné la fenêtre), les éléments graphiques dans les cellules vont être cachés par le bas de la fenêtre. Si `Gtk::SHRINK` est indiqué, les éléments graphiques vont rétrécir avec le tableau.

`Gtk::EXPAND`

  Cette option va provoquer l'étalement du tableau jusqu'à occuper tout l'espace libre de la fenêtre.

Les paramètres de remplissage fonctionnent exactement comme pour la fonction membre pack_start().

##### Autres fonctions membres

set_row_spacing() et set_col_spacing() définissent l'espacement entre lignes ou entre colonnes pour la ligne ou la colonne indiquée. Notez que, pour les colonnes, l'espacement se situe à droite de la colonne et que, pour les lignes, l'espacement se situe sous la ligne.

Vous pouvez également fixer un espacement d'ensemble pour toutes les lignes et toutes les colonnes avec set_row_spacings() et set_col_spacings(). Notez qu'avec ces fonctions membres, la dernière ligne et la dernière colonne n'ont pas l'espacement indiqué.

Référence

##### Exemple

Dans l'exemple ci-après, nous créons une fenêtre avec trois boutons dans un tableau 2 x 2. Les deux premiers boutons sont placés dans la ligne supérieure. Le troisième bouton est placé dans la ligne inférieure et occupe les deux colonnes.

Tableau

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_quit();
      void on_button_numbered(Glib::ustring data);

      //Child widgets:
      Gtk::Table m_Table;
      Gtk::Button m_Button_1, m_Button_2, m_Button_Quit;

    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_Table(2, 2, true),
      m_Button_1("button 1"),
      m_Button_2("button 2"),
      m_Button_Quit("Quit")
    {
      set_title("Gtk::Table");
      set_border_width(20);

      add(m_Table);

      m_Table.attach(m_Button_1, 0, 1, 0, 1);
      m_Table.attach(m_Button_2, 1, 2, 0, 1);
      m_Table.attach(m_Button_Quit, 0, 2, 1, 2);

      m_Button_1.signal_clicked().connect(
              sigc::bind<Glib::ustring>( sigc::mem_fun(*this,
                      &ExampleWindow::on_button_numbered), "button 1") );
      m_Button_2.signal_clicked().connect(
              sigc::bind<Glib::ustring>( sigc::mem_fun(*this,
                      &ExampleWindow::on_button_numbered), "button 2") );

      m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

    void
    ExampleWindow::on_button_numbered(Glib::ustring data)
    {
      std::cout << "Hello again - " << data << " was pressed" << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Bloc-note

L'objet Notebook est constitué d'un jeu de `pages` empilées, chacune contenant des éléments graphiques. Les onglets étiquetés permettent à l'utilisateur de choisir les pages. Notebook permet de placer plusieurs jeux d'éléments graphiques dans un espace réduit, mais en ne montrant qu'une seule page à la fois. Cet objet est souvent utilisé, par exemple, dans les boîtes de dialogue de préférences.

Servez-vous des fonctions membres append_page(), prepend_page() et insert_page() pour ajouter des pages à onglets dans l'objet `Notebook` en précisant l'élément graphique enfant et le nom de l'onglet.

Pour connaître la page actuellement affichée, utilisez la fonction membre get_current_page(). Elle renvoie un numéro de page, puis, en appelant get_nth_page() avec ce numéro de page, vous obtiendrez un pointeur sur l'élément graphique enfant de la page.

Pour changer de page sélectionnée au cours du programme, utilisez la fonction membre set_current_page().

Référence

##### Exemple

Bloc-note

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_quit();
      void on_notebook_switch_page(Gtk::Widget* page, guint page_num);

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Notebook m_Notebook;
      Gtk::Label m_Label1, m_Label2;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Label1("Contents of tab 1"),
      m_Label2("Contents of tab 2"),
      m_Button_Quit("Quit")
    {
      set_title("Gtk::Notebook example");
      set_border_width(10);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the Notebook, with the button underneath:
      m_Notebook.set_border_width(10);
      m_VBox.pack_start(m_Notebook);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      //Add the Notebook pages:
      m_Notebook.append_page(m_Label1, "First");
      m_Notebook.append_page(m_Label2, "Second");

      m_Notebook.signal_switch_page().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_notebook_switch_page) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

    void ExampleWindow::on_notebook_switch_page(Gtk::Widget* /* page */, guint page_num)
    {
      std::cout << "Switched to tab with index " << page_num << std::endl;

      //You can also use m_Notebook.get_current_page() to get this index.
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Assistant

Un objet Assistant divise une opération complexe en étapes successives. À chaque étape correspond une page, avec un en-tête, un élément graphique enfant et une zone d'action. La zone d'action de l'assistant possède des boutons de navigation qui se mettent à jour automatiquement selon le type de page fixé avec set_page_type().

Utilisez les fonctions membres append_page(), prepend_page et insert_page() pour ajouter des pages à un objet Assistant, tout en indiquant l'élément graphique enfant pour chacune d'entre elles.

Pour connaître la page en cours d'utilisation, servez-vous de la fonction membre get_current_page(), passez le résultat à get_nth_page() qui vous renverra un pointeur sur l'élément graphique affiché. Pour changer en cours de programme la page active, utilisez la fonction membre set_current_page().

Pour définir le titre de la page, servez-vous de la fonction membre set_page_title(). Les images de l'en-tête et du côté de la page sont insérées avec les fonctions membres set_page_header_image() et set_page_side_image().

Pour ajouter des éléments graphiques dans la zone d'action, utilisez la fonction membre add_action_widget(). Ils seront empaquetés à côté des boutons par défaut. Servez-vous de la fonction membre remove_action_widget() pour enlever des éléments graphiques.

Référence

##### Exemple

Assistant

Code source

File: `exampleassistant.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEASSISTANT_H
    #define GTKMM_EXAMPLEASSISTANT_H

    #include <gtkmm.h>

    class ExampleAssistant : public Gtk::Assistant
    {
    public:
      ExampleAssistant();
      virtual ~ExampleAssistant();

      void get_result(bool& check_state, Glib::ustring& entry_text);

    private:
      // Signal handlers:
      void on_assistant_apply();
      void on_assistant_cancel();
      void on_assistant_close();
      void on_assistant_prepare(Gtk::Widget* widget);
      void on_entry_changed();

      // Member functions:
      void print_status();

      // Child widgets:
      Gtk::Box m_box;
      Gtk::Label m_label1, m_label2;
      Gtk::CheckButton m_check;
      Gtk::Entry m_entry;
    };

    #endif /* GTKMM_EXAMPLEASSISTANT_H */

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include "exampleassistant.h"
    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    private:
      // Signal handlers:
      void on_button_clicked();
      void on_assistant_apply();

      // Child widgets:
      Gtk::Table m_table;
      Gtk::Button m_button;
      Gtk::Label m_label1, m_label2;
      Gtk::CheckButton m_check;
      Gtk::Entry m_entry;
      ExampleAssistant m_assistant;
    };

    #endif /* GTKMM_EXAMPLEWINDOW_H */

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include "exampleassistant.h"

    ExampleWindow::ExampleWindow()
    : m_table(3, 2),
      m_button("Show the assistant"),
      m_label1("State of assistant checkbutton:"),
      m_label2("Contents of assistant entry:")
    {
      set_title("Gtk::Assistant example");
      set_border_width(12);

      m_table.attach(m_button, 0, 2, 0, 1, Gtk::FILL, Gtk::EXPAND);
      m_table.attach(m_label1, 0, 1, 1, 2, Gtk::FILL, Gtk::EXPAND);
      m_table.attach(m_label2, 0, 1, 2, 3, Gtk::FILL, Gtk::EXPAND);
      m_table.attach(m_check, 1, 2, 1, 2);
      m_table.attach(m_entry, 1, 2, 2, 3);
      add(m_table);

      m_label1.set_alignment(0.0, 0.5);
      m_label2.set_alignment(0.0, 0.5);

      m_button.signal_clicked().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_button_clicked));
      m_assistant.signal_apply().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_assistant_apply));

      m_check.set_sensitive(false);
      m_entry.set_sensitive(false);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_assistant_apply()
    {
      bool check_state;
      Glib::ustring entry_text;

      m_assistant.get_result(check_state, entry_text);
      m_check.set_active(check_state);
      m_entry.set_text(entry_text);
    }

    void ExampleWindow::on_button_clicked()
    {
      m_assistant.show();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      // Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

File: `exampleassistant.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include "exampleassistant.h"

    ExampleAssistant::ExampleAssistant()
    : m_box(Gtk::ORIENTATION_HORIZONTAL, 12),
      m_label1("Type text to allow the assistant to continue:"),
      m_label2("Confirmation page"),
      m_check("Optional extra information")
    {
      set_title("Gtk::Assistant example");
      set_border_width(12);
      set_default_size(400, 300);

      m_box.pack_start(m_label1);
      m_box.pack_start(m_entry);

      append_page(m_box);
      append_page(m_check);
      append_page(m_label2);

      set_page_title(*get_nth_page(0), "Page 1");
      set_page_title(*get_nth_page(1), "Page 2");
      set_page_title(*get_nth_page(2), "Confirmation");

      set_page_complete(m_check, true);
      set_page_complete(m_label2, true);

      set_page_type(m_box, Gtk::ASSISTANT_PAGE_INTRO);
      set_page_type(m_label2, Gtk::ASSISTANT_PAGE_CONFIRM);

      signal_apply().connect(sigc::mem_fun(*this,
        &ExampleAssistant::on_assistant_apply));
      signal_cancel().connect(sigc::mem_fun(*this,
        &ExampleAssistant::on_assistant_cancel));
      signal_close().connect(sigc::mem_fun(*this,
        &ExampleAssistant::on_assistant_close));
      signal_prepare().connect(sigc::mem_fun(*this,
        &ExampleAssistant::on_assistant_prepare));

      m_entry.signal_changed().connect(sigc::mem_fun(*this,
        &ExampleAssistant::on_entry_changed));

      show_all_children();
    }

    ExampleAssistant::~ExampleAssistant()
    {
    }

    void ExampleAssistant::get_result(bool& check_state, Glib::ustring& entry_text)
    {
      check_state = m_check.get_active();
      entry_text = m_entry.get_text();
    }

    void ExampleAssistant::on_assistant_apply()
    {
      std::cout << "Apply was clicked";
      print_status();
    }

    void ExampleAssistant::on_assistant_cancel()
    {
      std::cout << "Cancel was clicked";
      print_status();
      hide();
    }

    void ExampleAssistant::on_assistant_close()
    {
      std::cout << "Assistant was closed";
      print_status();
      hide();
    }

    void ExampleAssistant::on_assistant_prepare(Gtk::Widget* /* widget */)
    {
      set_title(Glib::ustring::compose("Gtk::Assistant example (Page %1 of %2)",
        get_current_page() + 1, get_n_pages()));
    }

    void ExampleAssistant::on_entry_changed()
    {
      // The page is only complete if the entry contains text.
      if(m_entry.get_text_length())
        set_page_complete(m_box, true);
      else
        set_page_complete(m_box, false);
    }

    void ExampleAssistant::print_status()
    {
      std::cout << ", entry contents: \"" << m_entry.get_text()
        << "\", checkbutton status: " << m_check.get_active() << std::endl;
    }

## L'élément graphique arborescence

L'élément graphique Gtk::TreeView peut incorporer des listes ou des arborescences de données, disposées en colonnes.

### Le modèle

Chaque objet Gtk::TreeView possède un objet Gtk::TreeModel associé ; il contient les données à afficher par l'objet TreeView. Tout Gtk::TreeModel peut être utilisé par plus d'un Gtk::TreeView. Par exemple, il est possible d'afficher et modifier simultanément sous deux formes différentes les mêmes données sous-jacentes ; ou bien encore, les deux vues peuvent afficher des colonnes différentes à partir du même modèle de données, tout comme deux requêtes SQL (ou « vues ») sont susceptibles d'afficher des champs différents à partir d'une même base de données.

Même si vous pouvez théoriquement implémenter votre propre modèle, vous utiliserez normalement, soit la classe modèle ListStore, soit la classe modèle TreeStore.

Référence

#### Modèle listStore, pour des colonnes

Un objet ListStore contient de simples colonnes de données et chaque colonne n'a pas d'enfant.

TreeView - ListStore

Référence

#### Modèle treeStore, pour une hiérarchie

L'objet TreeStore contient des colonnes de données et chaque colonne peut avoir des colonnes enfants.

TreeView - TreeStore

Référence

#### Modèle colonnes

La classe TreeModelColumnRecord s'utilise pour enregistrer les colonnes et leurs types de données. Vous ajoutez des exemplaires de TreeModelColumn au ColumnRecord, puis utilisez ces TreeModelColumns pour obtenir ou placer les données dans les colonnes du modèle. Vous trouverez certainement commode de dériver un nouveau TreeModelColumnRecord incorporant vos exemplaires de TreeModelColumn en tant que données membres.

    class ModelColumns : public Gtk::TreeModelColumnRecord
    {
    public:

      ModelColumns()
        { add(m_col_text); add(m_col_number); }

      Gtk::TreeModelColumn<Glib::ustring> m_col_text;
      Gtk::TreeModelColumn<int> m_col_number;
    };

    ModelColumns m_Columns;

Vous précisez le ColumnRecord à la création du modèle, ainsi :

    Glib::RefPtr<Gtk::ListStore> refListStore =
        Gtk::ListStore::create(m_Columns);

Notez que les exemplaires de colonnes (tels que m_Columns ici) ne sont habituellement pas qualifiés « static », étant donné qu'ils doivent être instanciés après que glibmm l'ait été lui-même.

#### Ajout de lignes

Ajoutez des lignes au modèle avec les fonctions membres append(), prepend() ou insert().

    Gtk::TreeModel::iterator iter = m_refListStore->append();

Vous pouvez déréférencer l'itérateur pour obtenir la ligne :

    Gtk::TreeModel::Row row = *iter;

##### Ajout de colonnes enfants

Les modèles Gtk::TreeStore peuvent avoir des éléments enfants. Pour les ajouter, servez-vous des fonctions membres append(), prepend() ou insert(), ainsi :

    Gtk::TreeModel::iterator iter_child =
        m_refListStore->append(row.children());

#### Définition des valeurs

Vous pouvez utiliser la surdéfinition de operator[] pour définir les données d'une colonne désignée dans la ligne en indiquant le TreeModelColumn utilisé pour créer le modèle.

    row[m_Columns.m_col_text] = "textedonné";

#### Obtention des valeurs

Vous pouvez utiliser la surdéfinition de operator[] pour obtenir les données d'une colonne particulière dans une ligne, en précisant le TreeModelColumn qui a été utilisé pour créer le modèle.

    Glib::ustring strText = row[m_Columns.m_col_text];
    int number = row[m_Columns.m_col_number];

Le compilateur se plaint si vous utilisez un type inapproprié et génère, par exemple, l'erreur de compilation suivante :

    //compiler error - no conversion from ustring to int.
    int number = row[m_Columns.m_col_text];

#### Colonnes « cachées »

Vous pouvez associer des données supplémentaires à chaque ligne. Pour ce faire, ajoutez-les en tant que colonne du modèle, mais sans les placer dans la vue.

### La vue

La vue est l'élément graphique (Gtk::TreeView) qui affiche concrètement les données du modèle (Gtk::TreeModel) et qui autorise l'utilisateur à interagir. Elle peut afficher, de diverses manières, toutes les colonnes du modèle ou seulement quelques unes.

Référence

#### Utilisation d'un modèle

Vous pouvez définir le modèle Gtk::TreeModel à la construction de l'objet vue Gtk::TreeView ou bien vous pouvez utiliser la fonction membre set_model(), comme suit :

    m_TreeView.set_model(m_refListStore);

#### Ajout de colonnes à la vue

Vous pouvez utiliser la fonction membre append_column() pour demander à la vue d'afficher certaines colonnes du modèle, dans un certain ordre, avec un certain intitulé.

    m_TreeView.append_column("Messages", m_Columns.m_col_text);

En utilisant cette simple surdéfinition de append_column(), l'objet TreeView affiche la donnée du modèle avec un CellRenderer approprié. Par exemple, les chaînes littérales et les nombres sont affichés dans un simple contrôle Gtk::Entry et les booléens dans un Gtk::CheckButton. Cela correspond aux besoins habituels. Pour des colonnes relatives à d'autres types, vous pouvez, soit connecter une fonction de rappel qui convertit avec TreeViewColumn::set_cell_data_func() le type en chaîne littérale le représentant, soit créer par dérivation un CellRenderer personnalisé. Notez que le type `(unsigned) short` n'est pas pris en charge par défaut — à la place, vous pouvez utiliser le type `(unsigned) int` ou `(unsigned) long`.

#### Plus d'une colonne de modèle par colonne de vue

Pour afficher à l'écran plus d'une colonne du modèle dans une colonne de vue, vous aurez besoin de créer un élément graphique TreeView::Column manuellement et d'utiliser la fonction membre pack_start() pour y ajouter les colonnes du modèle.

Ensuite, avec append_column(), ajoutez la colonne à la vue. Vous noterez que Gtk::View::append_column() a été surdéfini pour accepter, soit un élément graphique Gtk::View::Column préalablement construit, soit uniquement un TreeModelColumn à partir duquel cette fonction membre génére un élément graphique Gtk::View::Column approprié.

Voici quelques exemples de code extraits de `demos/gtk-demo/example_stockbrowser.cc`, qui possède une icône pixelisée et du texte dans une même colonne :

    Gtk::TreeView::Column* pColumn =
        Gtk::manage( new Gtk::TreeView::Column("Symbole") );

    // m_columns.icon et m_columns.symbol sont des colonnes du modèle.
    // pColumn est la colonne dans l'objet TreeView :
    pColumn->pack_start(m_columns.icon, false); //false = ne pas développer.
    pColumn->pack_start(m_columns.symbol);

    m_TreeView.append_column(*pColumn);

#### Détails pour la définition du CellRenderer

Le comportement par défaut de la classe CellRenderers suffit en règle générale, mais vous pouvez dans certains cas avoir besoin d'un contrôle plus fin. Ainsi, cet exemple de code, pris dans `demos/gtk-demo/example_treestore.cc`, construit manuellement un élément graphique Gtk::CellRenderer et le programme pour qu'il effectue un rendu avec variations d'aspect selon les données des diverses colonnes du modèle.

    Gtk::CellRendererToggle* pRenderer =
        Gtk::manage( new Gtk::CellRendererToggle() );
    int cols_count = m_TreeView.append_column("Alex", *pRenderer);
    Gtk::TreeViewColumn* pColumn = m_TreeView.get_column(cols_count-1);
    if(pColumn)
    {
      pColumn->add_attribute(pRenderer->property_active(),
          m_columns.alex);
      pColumn->add_attribute(pRenderer->property_visible(),
          m_columns.visible);
      pColumn->add_attribute(pRenderer->property_activatable(),
          m_columns.world);

Vous pouvez aussi connecter les signaux du CellRenderer pour détecter des actions utilisateur. Par exemple :

    Gtk::CellRendererToggle* pRenderer =
        Gtk::manage( new Gtk::CellRendererToggle() );
    pRenderer->signal_toggled().connect(
        sigc::bind( sigc::mem_fun(*this,
            &Example_TreeView_TreeStore::on_cell_toggled), m_columns.dave)
    );

#### Cellules modifiables

##### Cellules modifiables à enregistrement automatique.

Des cellules d'un objet TreeView peuvent être modifiées in-situ par l'utilisateur. Pour permettre ce comportement, utilisez les fonctions membres Gtk::TreeView insert_column_editable() et append_column_editable() au lieu de insert_column() et append_column(). Quand ces colonnes sont modifiées, les nouvelles valeurs sont immédiatement enregistrées dans le modèle. Notez que ces fonctions membres sont des prototypes qui ne peuvent être utilisés que dans le cas de types de colonnes simples tels que des Glib::ustring, des `int` et des `long`.

##### Implémentation d'une logique personnalisée pour les cellules modifiables.

Toutefois, vous pouvez vouloir que les nouvelles valeurs ne soient pas immédiatement enregistrées. Vous voulez, par exemple, limiter la saisie à certains caractères ou plages de valeurs.

Pour réaliser cela, utilisez les fonctions membres normales Gtk::TreeView insert_column() et append_column(), puis, avec get_column_cell_renderer(), obtenez le pointeur sur le Gtk::CellRenderer utilisé par cette colonne.

Ensuite vous ferez un forçage du type de ce pointeur Gtk::CellRenderer* vers un CellRenderer donné, conforme à vos attentes. Vous utilisez ainsi une API particulière.

Par exemple, pour un CellRendererText, vous définissez la propriété editable égale à `true`, comme ceci :

    cell.property_editable() = true;

Pour un « CellRendererToggle », vous paramétrez la propriété activatable à la place.

Vous pouvez alors connecter le signal « edited » approprié, par exemple, connecter à Gtk::CellRendererText::signal_edited() ou Gtk::CellRendererToggle::signal_toggled(). Si la colonne comprend plus d'un CellRenderer, vous aurez besoin d'utiliser Gtk::TreeView::get_column(), puis d'appeler get_cell_renderers() sur cette colonne de la vue.

Dans le gestionnaire de signal, vous devriez examiner la nouvelle valeur et l'enregistrer dans le modèle si vous la jugez appropriée pour l'application.

### Itération parmi les colonnes du modèle

Gtk::TreeModel fournit un conteneur dans le style de la bibliothèque standard C++ pour ses enfants par l'intermédiaire de la fonction membre children(). Vous pouvez utiliser les fonctions membres habituelles begin() et end() pour incrémenter un itérateur, comme ceci :

    typedef Gtk::TreeModel::Children type_children; // minimise la longueur du code.
    type_children children = refModel->children();
    for(type_children::iterator iter = children.begin();
        iter != children.end(); ++iter)
    {
      Gtk::TreeModel::Row row = *iter;
      // Faire quelque chose avec la ligne - voir plus haut pour set/get.
    }

#### Ligne enfant

Si vous vous servez d'un objet Gtk::TreeStore, les lignes peuvent avoir des lignes enfants qui, à leur tour, peuvent avoir leur propres enfants. Utilisez Gtk::TreeModel::Row::children() pour obtenir le conteneur des objets Row enfants :

    Gtk::TreeModel::Children children = row.children();

### La sélection

Pour retrouver quelles sont les lignes sélectionnées par l'utilisateur, obtenez l'objet Gtk::TreeView::Selection du TreeView ainsi :

    Glib::RefPtr<Gtk::TreeSelection> refTreeSelection =
        m_TreeView.get_selection();

#### Sélection simple ou multiple

Par défaut, vous ne pouvez sélectionner qu'une seule ligne, mais la sélection multiple est possible en activant le mode correspondant, comme ceci :

    refTreeSelection->set_mode(Gtk::SELECTION_MULTIPLE);

#### Les lignes sélectionnées

Pour une simple sélection, appelez simplement la fonction membre get_selected(), comme suit :

    TreeModel::iterator iter = refTreeSelection->get_selected();
    if(iter) // si quelque chose est sélectionné
    {
      TreeModel::Row row = *iter;
      // Faire quelque chose avec la ligne.
    }

Pour une sélection multiple, vous aurez besoin de définir une fonction de rappel et de la fournir en paramètre à selected_foreach(), selected_foreach_path() ou selected_foreach_iter(), ainsi :

    refTreeSelection->selected_foreach_iter(
        sigc::mem_fun(*this, &TheClass::selected_row_callback) );

    void TheClass::selected_row_callback(
        const Gtk::TreeModel::iterator& iter)
    {
      TreeModel::Row row = *iter;
      // Faire quelque chose avec la ligne.
    }

#### Le signal « changed »

Pour répondre à l'utilisateur qui clique sur une ligne ou une plage de lignes, connectez le signal ainsi :

    refTreeSelection->signal_changed().connect(
        sigc::mem_fun(*this, &Example_StockBrowser::on_selection_changed)
    );

#### Empêcher la sélection de lignes

Il est possible que l'utilisateur n'ait pas le droit de sélectionner tous les éléments d'une liste ou d'une arborescence. Ainsi, dans le programme gtk-demo, vous pouvez choisir un exemple pour voir le code source, mais choisir une catégorie d'exemples n'a pas de sens.

Pour contrôler quelles lignes peuvent être sélectionnées, utilisez la fonction membre set_select_function() et passez lui en paramètre un signal de rappel sigc::slot. Par exemple :

    m_refTreeSelection->set_select_function( sigc::mem_fun(*this,
        &DemoWindow::select_function) );

puis

    bool DemoWindow::select_function(
        const Glib::RefPtr<Gtk::TreeModel>& model,
        const Gtk::TreeModel::Path& path, bool)
    {
      const Gtk::TreeModel::iterator iter = model->get_iter(path);
      // n'autoriser que la sélection des nœuds d'extrémité
      return iter->children().empty();
    }

#### Modification de la sélection

Pour modifier la sélection, précisez un Gtk::TreeModel::iterator ou Gtk::TreeModel::Row, ainsi :

    Gtk::TreeModel::Row row = m_refModel->children()[5]; // 5ième ligne.
    if(row)
      refTreeSelection->select(row);

ou

    Gtk::TreeModel::iterator iter = m_refModel->children().begin()
    if(iter)
      refTreeSelection->select(iter);

### Tris

Les modèles standard d'arborescence (TreeStore et ListStore) dérivent de la classe TreeSortable ; ils offrent donc la possibilité de tri. Par exemple, faites appel à set_sort_column() pour trier le modèle sur la colonne donnée, ou bien définissez une fonction de rappel pour set_sort_func() pour implémenter un algorithme de tri plus complexe.

Référence de TreeSortable

#### Tri en cliquant sur l'en-tête de colonne

Pour implémenter le tri par clic sur l'en-tête d'une colonne d'un objet TreeView afin d'ordonner son contenu, appelez Gtk::TreeViewModel::set_sort_column() en indiquant la colonne du modèle sur laquelle le tri est effectué quand l'en-tête est cliquée. Par exemple :

    Gtk::TreeView::Column* pColumn = treeview.get_column(0);
    if(pColumn)
      pColumn->set_sort_column(m_columns.m_col_id);

#### Vues d'un même modèle triées de manière indépendante

Nous avons déjà vu que la classe TreeView vous permet d'afficher le même TreeModel dans deux éléments graphiques TreeView distincts. Si vous avez besoin qu'un des TreeView trie le modèle de manière différente de l'autre, vous devez utiliser un objet TreeModelSort au lieu d'utiliser uniquement Gtk::TreeViewModel::set_sort_column(), par exemple. TreeModelSort est un modèle contenant une version triée d'un autre modèle. Par exemple, vous pouvez ajouter une autre version triée d'un modèle à un objet TreeView ainsi :

    Glib::RefPtr<Gtk::TreeModelSort> sorted_model =
        Gtk::TreeModelSort::create(model);
    sorted_model->set_sort_column(columns.m_col_name, Gtk::SORT_ASCENDING);
    treeview.set_model(sorted_model);

Notez, toutefois, que la vue arborescente fournit des itérateurs sur le modèle trié. Vous devez les convertir en itérateurs du modèle enfant sous-jacent pour effectuer des opérations sur ce modèle. Par exemple :

    void ExampleWindow::on_button_delete()
    {
      Glib::RefPtr<Gtk::TreeSelection> refTreeSelection =
          m_treeview.get_selection();
      if(refTreeSelection)
      {
        Gtk::TreeModel::iterator sorted_iter =
            m_refTreeSelection->get_selected();
        if(sorted_iter)
        {
          Gtk::TreeModel::iterator iter =
              m_refModelSort->convert_iter_to_child_iter(sorted_iter);
          m_refModel->erase(iter);
        }
      }
    }

Référence de TreeModelSort

### Glisser-déposer

Gtk::TreeView implémente déjà le simple glisser-déposer lorsqu'on l'utilise avec des modèles Gtk::ListStore ou Gtk::TreeStore. Mais, si nécessaire, il vous permet d'implémenter des comportements plus complexes lorsque les éléments sont glissés et déposés en utilisant l'API classique du glisser-déposer.

#### Réarrangement de lignes

Si vous faites appel à la fonction membre Gtk::TreeView::set_reorderable(), les éléments d'un objet TreeView peuvent être déplacés au sein même de la vue arborescente. Ceci est montré dans l'exemple TreeStore.

Toutefois, cela ne vous donne aucun contrôle sur les éléments qu'il est possible de faire glisser et sur l'emplacement où ils peuvent être déposés. Si vous avez besoin de ce contrôle supplémentaire, vous devez créer un `Gtk::TreeModel` dérivé de `Gtk::TreeStore` ou `Gtk::ListStore` et opérer une surdéfinition des fonctions membres virtuelles `Gtk::TreeDragSource::row_draggable()` et `Gdk::TreeDragDest::row_drop_possible()`. Vous examinez alors les `Gtk::TreeModel::Path` fournis et autorisez/interdisez le glisser ou le déposer en renvoyant `true` ou `false`.

Cette construction est montrée dans l'exemple du glisser-déposer.

### Menu contextuel

Nombre de programmeurs ont besoin d'implémenter des menus contextuels s'ouvrant d'un clic droit de souris sur des objets TreeView. Pour vous faire gagner du temps, nous allons expliquer ici comment faire. À un ou deux points près, cela ressemble tout à fait à un menu contextuel normal tel que décrit dans le chapitre Menus.

#### Gestion du signal `button_press_event`

Pour détecter un clic du bouton droit de la souris, il faut gérer le signal `button_press_event` et vérifier quel est exactement le bouton pressé. Comme TreeView gère normalement ce signal intégralement, vous devrez, soit procéder à la surdéfinition du gestionnaire de signal par défaut dans une classe TreeView dérivée, soit utiliser la fonction membre connect_notify() à la place de connect(). Vous souhaiterez probablement aussi appeler le gestionnaire par défaut avant de faire quoi que ce soit d'autre ; un clic-droit provoque donc au préalable la sélection de la ligne.

Ceci est montré dans l'exemple Menu contextuel personnalisé.

### Exemples

#### ListStore

Voici un exemple d'élément graphique Gtk::TreeView avec un modèle Gtk::ListStore.

TreeView - ListStore

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_quit();

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); add(m_col_number); add(m_col_percentage);}

        Gtk::TreeModelColumn<unsigned int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
        Gtk::TreeModelColumn<short> m_col_number;
        Gtk::TreeModelColumn<int> m_col_percentage;
      };

      ModelColumns m_Columns;

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TreeView m_TreeView;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit("Quit")
    {
      set_title("Gtk::TreeView (ListStore) example");
      set_border_width(5);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the TreeView, inside a ScrolledWindow, with the button underneath:
      m_ScrolledWindow.add(m_TreeView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(5);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      //Create the Tree model:
      m_refTreeModel = Gtk::ListStore::create(m_Columns);
      m_TreeView.set_model(m_refTreeModel);

      //Fill the TreeView's model
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "Billy Bob";
      row[m_Columns.m_col_number] = 10;
      row[m_Columns.m_col_percentage] = 15;

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 2;
      row[m_Columns.m_col_name] = "Joey Jojo";
      row[m_Columns.m_col_number] = 20;
      row[m_Columns.m_col_percentage] = 40;

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 3;
      row[m_Columns.m_col_name] = "Rob McRoberts";
      row[m_Columns.m_col_number] = 30;
      row[m_Columns.m_col_percentage] = 70;

      //Add the TreeView's view columns:
      //This number will be shown with the default numeric formatting.
      m_TreeView.append_column("ID", m_Columns.m_col_id);
      m_TreeView.append_column("Name", m_Columns.m_col_name);

      m_TreeView.append_column_numeric("Formatted number", m_Columns.m_col_number,
              "%010d" /* 10 digits, using leading zeroes. */);

      //Display a progress bar instead of a decimal number:
      Gtk::CellRendererProgress* cell = Gtk::manage(new Gtk::CellRendererProgress);
      int cols_count = m_TreeView.append_column("Some percentage", *cell);
      Gtk::TreeViewColumn* pColumn = m_TreeView.get_column(cols_count - 1);
      if(pColumn)
      {
        pColumn->add_attribute(cell->property_value(), m_Columns.m_col_percentage);
      }

      //Make all the columns reorderable:
      //This is not necessary, but it's nice to show the feature.
      //You can use TreeView::set_column_drag_function() to more
      //finely control column drag and drop.
      for(guint i = 0; i < 2; i++)
      {
        Gtk::TreeView::Column* pColumn = m_TreeView.get_column(i);
        pColumn->set_reorderable();
      }

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### TreeStore

C'est exemple est tout à fait semblable au précédent, mais il utilise un modèle Gtk::TreeStore à la place et il ajoute des enfants aux colonnes.

TreeView - TreeStore

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_quit();
      void on_treeview_row_activated(const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn* column);

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); }

        Gtk::TreeModelColumn<int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
      };

      ModelColumns m_Columns;

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TreeView m_TreeView;
      Glib::RefPtr<Gtk::TreeStore> m_refTreeModel;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit("Quit")
    {
      set_title("Gtk::TreeView (TreeStore) example");
      set_border_width(5);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the TreeView, inside a ScrolledWindow, with the button underneath:
      m_ScrolledWindow.add(m_TreeView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(5);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      //Create the Tree model:
      m_refTreeModel = Gtk::TreeStore::create(m_Columns);
      m_TreeView.set_model(m_refTreeModel);

      //All the items to be reordered with drag-and-drop:
      m_TreeView.set_reorderable();

      //Fill the TreeView's model
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "Billy Bob";

      Gtk::TreeModel::Row childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 11;
      childrow[m_Columns.m_col_name] = "Billy Bob Junior";

      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 12;
      childrow[m_Columns.m_col_name] = "Sue Bob";

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 2;
      row[m_Columns.m_col_name] = "Joey Jojo";

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 3;
      row[m_Columns.m_col_name] = "Rob McRoberts";

      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 31;
      childrow[m_Columns.m_col_name] = "Xavier McRoberts";

      //Add the TreeView's view columns:
      m_TreeView.append_column("ID", m_Columns.m_col_id);
      m_TreeView.append_column("Name", m_Columns.m_col_name);

      //Connect signal:
      m_TreeView.signal_row_activated().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_treeview_row_activated) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

    void ExampleWindow::on_treeview_row_activated(const Gtk::TreeModel::Path& path,
            Gtk::TreeViewColumn* /* column */)
    {
      Gtk::TreeModel::iterator iter = m_refTreeModel->get_iter(path);
      if(iter)
      {
        Gtk::TreeModel::Row row = *iter;
        std::cout << "Row activated: ID=" << row[m_Columns.m_col_id] << ", Name="
            << row[m_Columns.m_col_name] << std::endl;
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Cellules modifiables

Cet exemple est identique à l'exemple avec ListStore, mais il utilise TreeView::append_column_editable() à la place de TreeView::append_column().

TreeView - Cellules modifiables

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_quit();

      void treeviewcolumn_validated_on_cell_data(Gtk::CellRenderer* renderer, const Gtk::TreeModel::iterator& iter);
      void cellrenderer_validated_on_editing_started(Gtk::CellEditable* cell_editable, const Glib::ustring& path);
      void cellrenderer_validated_on_edited(const Glib::ustring& path_string, const Glib::ustring& new_text);

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); add(m_col_foo); add(m_col_number); add(m_col_number_validated); }

        Gtk::TreeModelColumn<unsigned int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
        Gtk::TreeModelColumn<bool> m_col_foo;
        Gtk::TreeModelColumn<int> m_col_number;
        Gtk::TreeModelColumn<int> m_col_number_validated;
      };

      ModelColumns m_Columns;

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TreeView m_TreeView;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;

      //For the validated column:
      //You could also use a CellRendererSpin or a CellRendererProgress:
      Gtk::CellRendererText m_cellrenderer_validated;
      Gtk::TreeView::Column m_treeviewcolumn_validated;
      bool m_validate_retry;
      Glib::ustring m_invalid_text_for_retry;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include <cstdio>
    #include <cstdlib>
    #include "examplewindow.h"

    using std::sprintf;
    using std::strtol;

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit("Quit"),
      m_validate_retry(false)
    {
      set_title("Gtk::TreeView Editable Cells example");
      set_border_width(5);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the TreeView, inside a ScrolledWindow, with the button underneath:
      m_ScrolledWindow.add(m_TreeView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(5);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      //Create the Tree model:
      m_refTreeModel = Gtk::ListStore::create(m_Columns);
      m_TreeView.set_model(m_refTreeModel);

      //Fill the TreeView's model
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "Billy Bob";
      row[m_Columns.m_col_foo] = true;
      row[m_Columns.m_col_number] = 10;

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 2;
      row[m_Columns.m_col_name] = "Joey Jojo";
      row[m_Columns.m_col_foo] = true;
      row[m_Columns.m_col_number] = 20;

      row = *(m_refTreeModel->append());

      row[m_Columns.m_col_id] = 3;
      row[m_Columns.m_col_name] = "Rob McRoberts";
      row[m_Columns.m_col_foo] = false;
      row[m_Columns.m_col_number] = 30;

      //Add the TreeView's view columns:
      //We use the *_editable convenience methods for most of these,
      //because the default functionality is enough:
      m_TreeView.append_column_editable("ID", m_Columns.m_col_id);
      m_TreeView.append_column_editable("Name", m_Columns.m_col_name);
      m_TreeView.append_column_editable("foo", m_Columns.m_col_foo);
      m_TreeView.append_column_numeric_editable("foo", m_Columns.m_col_number,
              "%010d");

      //For this column, we create the CellRenderer ourselves, and connect our own
      //signal handlers, so that we can validate the data that the user enters, and
      //control how it is displayed.
      m_treeviewcolumn_validated.set_title("validated (<10)");
      m_treeviewcolumn_validated.pack_start(m_cellrenderer_validated);
      m_TreeView.append_column(m_treeviewcolumn_validated);

      //Tell the view column how to render the model values:
      m_treeviewcolumn_validated.set_cell_data_func(m_cellrenderer_validated,
              sigc::mem_fun(*this,
                  &ExampleWindow::treeviewcolumn_validated_on_cell_data) );

      //Make the CellRenderer editable, and handle its editing signals:
      m_cellrenderer_validated.property_editable() = true;

      m_cellrenderer_validated.signal_editing_started().connect(
              sigc::mem_fun(*this,
            &ExampleWindow::cellrenderer_validated_on_editing_started) );

      m_cellrenderer_validated.signal_edited().connect( sigc::mem_fun(*this,
                  &ExampleWindow::cellrenderer_validated_on_edited) );

      //If this was a CellRendererSpin then you would have to set the adjustment:
      //m_cellrenderer_validated.property_adjustment() = m_spin_adjustment;

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

    void ExampleWindow::treeviewcolumn_validated_on_cell_data(
            Gtk::CellRenderer* /* renderer */,
            const Gtk::TreeModel::iterator& iter)
    {
      //Get the value from the model and show it appropriately in the view:
      if(iter)
      {
        Gtk::TreeModel::Row row = *iter;
        int model_value = row[m_Columns.m_col_number_validated];

        //This is just an example.
        //In this case, it would be easier to use append_column_editable() or
        //append_column_numeric_editable()
        char buffer[32];
        sprintf(buffer, "%d", model_value);

        Glib::ustring view_text = buffer;
        m_cellrenderer_validated.property_text() = view_text;
      }
    }

    void ExampleWindow::cellrenderer_validated_on_editing_started(
            Gtk::CellEditable* cell_editable, const Glib::ustring& /* path */)
    {
      //Start editing with previously-entered (but invalid) text,
      //if we are allowing the user to correct some invalid data.
      if(m_validate_retry)
      {
        //This is the CellEditable inside the CellRenderer.
        Gtk::CellEditable* celleditable_validated = cell_editable;

        //It's usually an Entry, at least for a CellRendererText:
        Gtk::Entry* pEntry = dynamic_cast<Gtk::Entry*>(celleditable_validated);
        if(pEntry)
        {
          pEntry->set_text(m_invalid_text_for_retry);
          m_validate_retry = false;
          m_invalid_text_for_retry.clear();
        }
      }

    }

    void ExampleWindow::cellrenderer_validated_on_edited(
            const Glib::ustring& path_string,
            const Glib::ustring& new_text)
    {
      Gtk::TreePath path(path_string);

      //Convert the inputed text to an integer, as needed by our model column:
      char* pchEnd = 0;
      int new_value = strtol(new_text.c_str(), &pchEnd, 10);

      if(new_value > 10)
      {
        //Prevent entry of numbers higher than 10.

        //Tell the user:
        Gtk::MessageDialog dialog(*this,
                "The number must be less than 10. Please try again.",
                false, Gtk::MESSAGE_ERROR);
        dialog.run();

        //Start editing again, with the bad text, so that the user can correct it.
        //A real application should probably allow the user to revert to the
        //previous text.

        //Set the text to be used in the start_editing signal handler:
        m_invalid_text_for_retry = new_text;
        m_validate_retry = true;

        //Start editing again:
        m_TreeView.set_cursor(path, m_treeviewcolumn_validated,
                m_cellrenderer_validated, true /* start_editing */);
      }
      else
      {
        //Get the row from the path:
        Gtk::TreeModel::iterator iter = m_refTreeModel->get_iter(path);
        if(iter)
        {
          Gtk::TreeModel::Row row = *iter;

          //Put the new value in the model:
          row[m_Columns.m_col_number_validated] = new_value;
        }
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Glisser-déposer

Cet exemple est similaire à l'exemple TreeStore, mais il a deux colonnes supplémentaires, une pour indiquer si la ligne peut être glissée, une pour indiquer si elle accepte des lignes déposées. Il se sert d'une classe Gtk::TreeStore dérivée dans laquelle s'opère une surdéfinition des fonctions virtuelles comme décrit dans le paragraphe TreeView et glisser-déposer.

TreeView - Glisser-déposer

Code source

File: `treemodel_dnd.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_TREEMODEL_DND_H
    #define GTKMM_EXAMPLE_TREEMODEL_DND_H

    #include <gtkmm.h>

    class TreeModel_Dnd : public Gtk::TreeStore
    {
    protected:
      TreeModel_Dnd();

    public:

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); add(m_col_draggable); add(m_col_receivesdrags); }

        Gtk::TreeModelColumn<int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
        Gtk::TreeModelColumn<bool> m_col_draggable;
        Gtk::TreeModelColumn<bool> m_col_receivesdrags;
      };

      ModelColumns m_Columns;

      static Glib::RefPtr<TreeModel_Dnd> create();

    protected:
      //Overridden virtual functions:
      virtual bool row_draggable_vfunc(const Gtk::TreeModel::Path& path) const;
      virtual bool row_drop_possible_vfunc(const Gtk::TreeModel::Path& dest, const Gtk::SelectionData& selection_data) const;

    };

    #endif //GTKMM_EXAMPLE_TREEMODEL_DND_H

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>
    #include "treemodel_dnd.h"

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_quit();

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TreeView m_TreeView;
      Glib::RefPtr<TreeModel_Dnd> m_refTreeModel;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `treemodel_dnd.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "treemodel_dnd.h"
    #include <iostream>

    TreeModel_Dnd::TreeModel_Dnd()
    {
      //We can't just call Gtk::TreeModel(m_Columns) in the initializer list
      //because m_Columns does not exist when the base class constructor runs.
      //And we can't have a static m_Columns instance, because that would be
      //instantiated before the gtkmm type system.
      //So, we use this method, which should only be used just after creation:
      set_column_types(m_Columns);
    }

    Glib::RefPtr<TreeModel_Dnd> TreeModel_Dnd::create()
    {
      return Glib::RefPtr<TreeModel_Dnd>( new TreeModel_Dnd() );
    }

    bool
    TreeModel_Dnd::row_draggable_vfunc(const Gtk::TreeModel::Path& path) const
    {
      // Make the value of the "draggable" column determine whether this row can
      // be dragged:

      //TODO: Add a const version of get_iter to TreeModel:
      TreeModel_Dnd* unconstThis = const_cast<TreeModel_Dnd*>(this);
      const_iterator iter = unconstThis->get_iter(path);
      //const_iterator iter = get_iter(path);
      if(iter)
      {
        Row row = *iter;
        bool is_draggable = row[m_Columns.m_col_draggable];
        return is_draggable;
      }

      return Gtk::TreeStore::row_draggable_vfunc(path);
    }

    bool
    TreeModel_Dnd::row_drop_possible_vfunc(const Gtk::TreeModel::Path& dest,
            const Gtk::SelectionData& selection_data) const
    {
      //Make the value of the "receives drags" column determine whether a row can be
      //dragged into it:

      //dest is the path that the row would have after it has been dropped:
      //But in this case we are more interested in the parent row:
      Gtk::TreeModel::Path dest_parent = dest;
      bool dest_is_not_top_level = dest_parent.up();
      if(!dest_is_not_top_level || dest_parent.empty())
      {
        //The user wants to move something to the top-level.
        //Let's always allow that.
      }
      else
      {
        //Get an iterator for the row at this path:
        //We must unconst this. This should not be necessary with a future version
        //of gtkmm.
        //TODO: Add a const version of get_iter to TreeModel:
        TreeModel_Dnd* unconstThis = const_cast<TreeModel_Dnd*>(this);
        const_iterator iter_dest_parent = unconstThis->get_iter(dest_parent);
        //const_iterator iter_dest_parent = get_iter(dest);
        if(iter_dest_parent)
        {
          Row row = *iter_dest_parent;
          bool receives_drags = row[m_Columns.m_col_receivesdrags];
          return receives_drags;
        }
      }

      //You could also examine the row being dragged (via selection_data)
      //if you must look at both rows to see whether a drop should be allowed.
      //You could use
      //TODO: Add const version of get_from_selection_data(): Glib::RefPtr<const
      //Gtk::TreeModel> refThis = Glib::RefPtr<const Gtk::TreeModel>(this);
      //
      //Glib::RefPtr<Gtk::TreeModel> refThis =
      //Glib::RefPtr<Gtk::TreeModel>(const_cast<TreeModel_Dnd*>(this));
      //refThis->reference(); //, true /* take_copy */)
      //Gtk::TreeModel::Path path_dragged_row;
      //Gtk::TreeModel::Path::get_from_selection_data(selection_data, refThis,
      //path_dragged_row);

      return Gtk::TreeStore::row_drop_possible_vfunc(dest, selection_data);
    }

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit(Gtk::Stock::QUIT)
    {
      set_title("Gtk::TreeView (Drag and Drop) example");
      set_border_width(5);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the TreeView, inside a ScrolledWindow, with the button underneath:
      m_ScrolledWindow.add(m_TreeView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(5);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      //Create the Tree model:
      //Use our derived model, which overrides some Gtk::TreeDragDest and
      //Gtk::TreeDragSource virtual functions:
      //The columns are declared in the overridden TreeModel.
      m_refTreeModel = TreeModel_Dnd::create();
      m_TreeView.set_model(m_refTreeModel);

      //Enable Drag-and-Drop of TreeView rows:
      //See also the derived TreeModel's *_vfunc overrides.
      m_TreeView.enable_model_drag_source();
      m_TreeView.enable_model_drag_dest();

      //Fill the TreeView's model
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_refTreeModel->m_Columns.m_col_id] = 1;
      row[m_refTreeModel->m_Columns.m_col_name] = "Billy Bob";
      row[m_refTreeModel->m_Columns.m_col_draggable] = true;
      row[m_refTreeModel->m_Columns.m_col_receivesdrags] = true;

      Gtk::TreeModel::Row childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_refTreeModel->m_Columns.m_col_id] = 11;
      childrow[m_refTreeModel->m_Columns.m_col_name] = "Billy Bob Junior";
      childrow[m_refTreeModel->m_Columns.m_col_draggable] = true;
      childrow[m_refTreeModel->m_Columns.m_col_receivesdrags] = true;

      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_refTreeModel->m_Columns.m_col_id] = 12;
      childrow[m_refTreeModel->m_Columns.m_col_name] = "Sue Bob";
      childrow[m_refTreeModel->m_Columns.m_col_draggable] = true;
      childrow[m_refTreeModel->m_Columns.m_col_receivesdrags] = true;

      row = *(m_refTreeModel->append());
      row[m_refTreeModel->m_Columns.m_col_id] = 2;
      row[m_refTreeModel->m_Columns.m_col_name] = "Joey Jojo";
      row[m_refTreeModel->m_Columns.m_col_draggable] = true;
      row[m_refTreeModel->m_Columns.m_col_receivesdrags] = true;

      row = *(m_refTreeModel->append());
      row[m_refTreeModel->m_Columns.m_col_id] = 3;
      row[m_refTreeModel->m_Columns.m_col_name] = "Rob McRoberts";
      row[m_refTreeModel->m_Columns.m_col_draggable] = true;
      row[m_refTreeModel->m_Columns.m_col_receivesdrags] = true;

      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_refTreeModel->m_Columns.m_col_id] = 31;
      childrow[m_refTreeModel->m_Columns.m_col_name] = "Xavier McRoberts";
      childrow[m_refTreeModel->m_Columns.m_col_draggable] = true;
      childrow[m_refTreeModel->m_Columns.m_col_receivesdrags] = true;

      //Add the TreeView's view columns:
      m_TreeView.append_column("ID", m_refTreeModel->m_Columns.m_col_id);
      m_TreeView.append_column("Name", m_refTreeModel->m_Columns.m_col_name);
      m_TreeView.append_column_editable("Draggable",
              m_refTreeModel->m_Columns.m_col_draggable);
      m_TreeView.append_column_editable("Receives Drags",
              m_refTreeModel->m_Columns.m_col_receivesdrags);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Menu contextuel

Cet exemple est tout à fait semblable à l'exemple ListStore, excepté qu'il crée un TreeView personnalisé par dérivation pour permettre la surdéfinition de `button_press_event` et pour encapsuler le code du modèle d'arborescence dans cette classe dérivée. Consultez le paragraphe Menu contextuel et TreeView.

TreeView - Menu contextuel

Code source

File: `treeview_withpopup.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_TREEVIEW_WITHPOPUP_H
    #define GTKMM_EXAMPLE_TREEVIEW_WITHPOPUP_H

    #include <gtkmm.h>

    class TreeView_WithPopup : public Gtk::TreeView
    {
    public:
      TreeView_WithPopup();
      virtual ~TreeView_WithPopup();

    protected:
      // Override Signal handler:
      // Alternatively, use signal_button_press_event().connect_notify()
      virtual bool on_button_press_event(GdkEventButton *ev);

      //Signal handler for popup menu items:
      void on_menu_file_popup_generic();

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); }

        Gtk::TreeModelColumn<unsigned int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
      };

      ModelColumns m_Columns;

      //The Tree model:
      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;

      Gtk::Menu m_Menu_Popup;
    };

    #endif //GTKMM_EXAMPLE_TREEVIEW_WITHPOPUP_H

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>
    #include "treeview_withpopup.h"

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_quit();

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      TreeView_WithPopup m_TreeView;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `treeview_withpopup.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "treeview_withpopup.h"
    #include <iostream>

    TreeView_WithPopup::TreeView_WithPopup()
    {
      //Create the Tree model:
      m_refTreeModel = Gtk::ListStore::create(m_Columns);
      set_model(m_refTreeModel);

      //Fill the TreeView's model
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "right-click on this";

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 2;
      row[m_Columns.m_col_name] = "or this";

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 3;
      row[m_Columns.m_col_name] = "or this, for a popup context menu";

      //Add the TreeView's view columns:
      append_column("ID", m_Columns.m_col_id);
      append_column("Name", m_Columns.m_col_name);

      //Fill popup menu:
      Gtk::MenuItem* item = Gtk::manage(new Gtk::MenuItem("_Edit", true));
      item->signal_activate().connect(
        sigc::mem_fun(*this, &TreeView_WithPopup::on_menu_file_popup_generic) );
      m_Menu_Popup.append(*item);

      item = Gtk::manage(new Gtk::MenuItem("_Process", true));
      item->signal_activate().connect(
        sigc::mem_fun(*this, &TreeView_WithPopup::on_menu_file_popup_generic) );
      m_Menu_Popup.append(*item);

      item = Gtk::manage(new Gtk::MenuItem("_Remove", true));
      item->signal_activate().connect(
        sigc::mem_fun(*this, &TreeView_WithPopup::on_menu_file_popup_generic) );
      m_Menu_Popup.append(*item);

      m_Menu_Popup.accelerate(*this);
      m_Menu_Popup.show_all(); //Show all menu items when the menu pops up

    #ifndef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
      signal_button_press_event()
        .connect(sigc::mem_fun(*this, &TreeView_WithPopup::on_button_press_event), false);
    #endif
    }

    TreeView_WithPopup::~TreeView_WithPopup()
    {
    }

    bool TreeView_WithPopup::on_button_press_event(GdkEventButton* event)
    {
      bool return_value = false;

      //Call base class, to allow normal handling,
      //such as allowing the row to be selected by the right-click:
      return_value = TreeView::on_button_press_event(event);

      //Then do our custom stuff:
      if( (event->type == GDK_BUTTON_PRESS) && (event->button == 3) )
      {
        m_Menu_Popup.popup(event->button, event->time);
      }

      return return_value;
    }

    void TreeView_WithPopup::on_menu_file_popup_generic()
    {
      std::cout << "A popup menu item was selected." << std::endl;

      Glib::RefPtr<Gtk::TreeView::Selection> refSelection = get_selection();
      if(refSelection)
      {
        Gtk::TreeModel::iterator iter = refSelection->get_selected();
        if(iter)
        {
          int id = (*iter)[m_Columns.m_col_id];
          std::cout << "  Selected ID=" << id << std::endl;
        }
      }
    }

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit("Quit")
    {
      set_title("Gtk::TreeView (ListStore) example");
      set_border_width(5);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the TreeView, inside a ScrolledWindow, with the button underneath:
      m_ScrolledWindow.add(m_TreeView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(5);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

## Boîtes combinées

Les éléments graphiques de la classe ComboBox offrent une liste (ou un arbre) de choix dans un menu déroulant. Opportunément, elle peut afficher des informations supplémentaires concernant chacun des éléments, comme du texte, une image, une case à cocher ou une barre de progression. L'élément graphique ComboBox n'autorise habituellement que les choix prédéfinis, mais il peut à l'occasion posséder une boîte Entry, permettant à l'utilisateur de saisir un texte quelconque si aucun de ceux qui sont proposés ne lui conviennent.

La liste est donnée via un objet TreeModel et les colonnes provenant de ce modèle sont insérées dans la vue de la boîte combinée avec la fonction membre ComboBox::pack_start(). Cela procure beaucoup de souplesse et de sécurité sur les types de données à la compilation ; mais la classe ComboBoxText dispose d'un paramétrage texte simple pour les cas où cette souplesse n'est pas recherchée.

Référence

### Le modèle

Le modèle d'une boîte combinée se définit et se remplit exactement comme un objet TreeView. Par exemple, vous pouvez dériver à partir de ComboBox une classe comportant une colonne d'entiers et une colonne texte comme suit :

    ModelColumns()
    { add(m_col_id); add(m_col_name); }

      Gtk::TreeModelColumn<int> m_col_id;
      Gtk::TreeModelColumn<Glib::ustring> m_col_name;
    };

    ModelColumns m_columns;

Après avoir ajouté des lignes à ce modèle, intégrez le modèle dans l'objet ComboBox avec la fonction membre set_model(). Puis, servez-vous des fonctions membres pack_start() ou pack_end() pour définir les colonnes à afficher dans la boîte combinée. Comme avec une vue arborescente vous pouvez, soit utiliser le moteur de rendu par défaut en passant le TreeModelColumn aux fonctions membres d'empaquetage, soit créer un exemplaire particulier de CellRenderer en définissant une correspondance personnalisée avec add_attribute() ou set_cell_data_func(). Notez que ces fonctions membres font partie de la classe de base CellLayout.

### L'élément choisi

Pour savoir quel élément, s'il y lieu, a été sélectionné dans la boîte combinée par l'utilisateur, faites appel à ComboBox::get_active(). Cette fonction membre renvoie un pointeur sur un TreeModel::iterator que vous pouvez déréférencer pour obtenir un objet Row afin de lire les valeurs des colonnes. Ainsi, vous pourriez lire à partir du modèle une valeur d'identification sous forme d'un entier, même si vous avez choisi de n'afficher qu'une description littérale dans la boîte combinée. Par exemple :

    Gtk::TreeModel::iterator iter = m_Combo.get_active();
    if(iter)
    {
      Gtk::TreeModel::Row row = *iter;

      // Obtenir les données de la ligne choisie grâce à notre
      // connaissance du modèle d'arborescence :
      int id = row[m_Columns.m_col_id];
      set_something_id_chosen(id); // Votre fonction.
    }
    else
      set_nothing_chosen(); // Votre fonction.

### Réponse à une modification

Vous pouvez avoir besoin de réagir à un changement de sélection dans la boîte combinée, par exemple pour mettre à jour d'autres éléments graphiques. Pour cela, vous devez gérer le signal « changed ». Par exemple :

    m_combo.signal_changed().connect( sigc::mem_fun(*this,
          &ExampleWindow::on_combo_changed) );

### Exemple complet

ComboBox

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm/window.h>
    #include <gtkmm/comboboxtext.h>
    #include <gtkmm/liststore.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_combo_changed();

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); }

        Gtk::TreeModelColumn<int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
      };

      ModelColumns m_Columns;

      //Child widgets:
      Gtk::ComboBox m_Combo;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/stock.h>
    #include <iostream>

    ExampleWindow::ExampleWindow()
    {
      set_title("ComboBox example");

      //Create the Tree model:
      //m_refTreeModel = Gtk::TreeStore::create(m_Columns);
      m_refTreeModel = Gtk::ListStore::create(m_Columns);
      m_Combo.set_model(m_refTreeModel);

      //Fill the ComboBox's Tree Model:
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "Billy Bob";
      /*
      Gtk::TreeModel::Row childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 11;
      childrow[m_Columns.m_col_name] = "Billy Bob Junior";

      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 12;
      childrow[m_Columns.m_col_name] = "Sue Bob";
      */

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 2;
      row[m_Columns.m_col_name] = "Joey Jojo";

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 3;
      row[m_Columns.m_col_name] = "Rob McRoberts";

      /*
      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 31;
      childrow[m_Columns.m_col_name] = "Xavier McRoberts";
      */

      //Add the model columns to the Combo (which is a kind of view),
      //rendering them in the default way:
      m_Combo.pack_start(m_Columns.m_col_id);
      m_Combo.pack_start(m_Columns.m_col_name);

      //Add the ComboBox to the window.
      add(m_Combo);

      //Connect signal handler:
      m_Combo.signal_changed().connect( sigc::mem_fun(*this, &ExampleWindow::on_combo_changed) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_combo_changed()
    {
      Gtk::TreeModel::iterator iter = m_Combo.get_active();
      if(iter)
      {
        Gtk::TreeModel::Row row = *iter;
        if(row)
        {
          //Get the data for the selected row, using our knowledge of the tree
          //model:
          int id = row[m_Columns.m_col_id];
          Glib::ustring name = row[m_Columns.m_col_name];

          std::cout << " ID=" << id << ", name=" << name << std::endl;
        }
      }
      else
        std::cout << "invalid iter" << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

### Exemple texte simple

ComboBox

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm/window.h>
    #include <gtkmm/comboboxtext.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_combo_changed();

      //Child widgets:
      Gtk::ComboBoxText m_Combo;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/stock.h>
    #include <iostream>

    ExampleWindow::ExampleWindow()
    {
      set_title("ComboBoxText example");

      //Fill the combo:
      m_Combo.append("something");
      m_Combo.append("something else");
      m_Combo.append("something or other");

      add(m_Combo);

      //Connect signal handler:
      m_Combo.signal_changed().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_combo_changed) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_combo_changed()
    {
      Glib::ustring text = m_Combo.get_active_text();
      if(!(text.empty()))
        std::cout << "Combo changed: " << text << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

### Boîte combinée avec saisie

Une ComboBox peut contenir un élément graphique Entry afin de saisir un texte arbitraire en fixant à true (vrai) le paramètre `has_entry` du constructeur.

#### La colonne texte

So that the Entry can interact with the drop-down list of choices, you must specify which of your model columns is the text column, with set_text_column(). For instance:

    m_combo.set_text_column(m_columns.m_col_name);

Si vous faites une sélection dans le menu déroulant, la valeur de cette colonne sera placée dans l'élément graphique Entry.

#### La saisie

Étant donné que l'utilisateur peut saisir n'importe quel texte, une ligne active du modèle ne suffit pas pour indiquer quel est le texte saisi par l'utilisateur. C'est pourquoi, vous devez retrouver l'élément graphique Entry avec la fonction membre ComboBoxEntry::get_entry() et appeler get_text() sur cet objet.

#### Exemple complet

Boîte combinée avec saisie

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm/window.h>
    #include <gtkmm/combobox.h>
    #include <gtkmm/liststore.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_combo_changed();

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); }

        Gtk::TreeModelColumn<Glib::ustring> m_col_id; //The data to choose - this must be text.
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
      };

      ModelColumns m_Columns;

      //Child widgets:
      Gtk::ComboBox m_Combo;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/stock.h>
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_Combo(true /* has_entry */)
    {
      set_title("ComboBox example");

      //Create the Tree model:
      //m_refTreeModel = Gtk::TreeStore::create(m_Columns);
      m_refTreeModel = Gtk::ListStore::create(m_Columns);
      m_Combo.set_model(m_refTreeModel);

      //Fill the ComboBox's Tree Model:
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = "1";
      row[m_Columns.m_col_name] = "Billy Bob";
      /*
      Gtk::TreeModel::Row childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 11;
      childrow[m_Columns.m_col_name] = "Billy Bob Junior";

      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 12;
      childrow[m_Columns.m_col_name] = "Sue Bob";
      */

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = "2";
      row[m_Columns.m_col_name] = "Joey Jojo";

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = "3";
      row[m_Columns.m_col_name] = "Rob McRoberts";

      /*
      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 31;
      childrow[m_Columns.m_col_name] = "Xavier McRoberts";
      */

      //Add the model columns to the Combo (which is a kind of view),
      //rendering them in the default way:
      //This is automatically rendered when we use set_entry_text_column().
      //m_Combo.pack_start(m_Columns.m_col_id);
      m_Combo.pack_start(m_Columns.m_col_name);

      m_Combo.set_entry_text_column(m_Columns.m_col_id);

      //Add the ComboBox to the window.
      add(m_Combo);

      //Connect signal handler:
      m_Combo.signal_changed().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_combo_changed) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_combo_changed()
    {
      Gtk::Entry* entry = m_Combo.get_entry();
      //Note: to get changes only when the entry has been completed,
      //instead of on every key press, connect to Entry::signal_changed()
      //instead of ComboBoxEntry::signal_changed.

      if(entry)
      {
        std::cout << " ID=" << entry->get_text() << std::endl;
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Exemple texte simple

Boîte combinée avec saisie de texte

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm/window.h>
    #include <gtkmm/comboboxtext.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_combo_changed();

      //Child widgets:
      Gtk::ComboBoxText m_Combo;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/stock.h>
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_Combo(true /* has_entry */)
    {
      set_title("ComboBoxText example");

      //Fill the combo:
      m_Combo.append("something");
      m_Combo.append("something else");
      m_Combo.append("something or other");

      add(m_Combo);

      //Connect signal handler:
      m_Combo.signal_changed().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_combo_changed) );

      m_Combo.property_has_frame() = false;
      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_combo_changed()
    {
      Glib::ustring text = m_Combo.get_active_text();
      if(!(text.empty()))
        std::cout << "Combo changed: " << text << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

## Élément graphique TextView

L'élément graphique TextView s'utilise pour afficher et modifier de grosses quantités de texte formatté. Comme l'objet TreeView, il y a une correspondance vue/modèle. Dans le cas présent, le modèle est l'objet TextBuffer.

### Le tampon

Gtk::TextBuffer est un modèle contenant les données pour Gtk::TextView, tout comme Gtk::TreeModel utilisé par Gtk::TreeView. Cela permet à deux Gtk::TextView ou plus de partager le même TextBuffer tout en étant affichés de façon légèrement différente. Ou bien encore, vous pouvez disposer de plusieurs Gtk::TextBuffer et choisir d'afficher dans le même élément graphique Gtk::TextView le contenu de l'un ou l'autre d'entre eux selon les circonstances.

L'objet TextView crée par défaut son propre TextBuffer. Vous y accédez avec la fonction membre get_buffer().

Référence

#### Itérateurs

#### Balisages et formats

##### Balisages

Pour indiquer que du texte dans le tampon doit bénéficier de tel ou tel format, vous devez définir une balise précisant cette information de format, puis appliquer ce balisage à une zone de texte. Ainsi, pour définir le balisage et ses propriétés :

    Glib::RefPtr<Gtk::TextBuffer::Tag> refTagMatch =
        Gtk::TextBuffer::Tag::create();
    refTagMatch->property_background() = "orange";

Vous pouvez définir un nom pour l'objet Tag quand vous appelez la fonction membre create(), mais ce n'est pas obligatoire.

La classe Tag dispose de nombreuses autres propriétés.

Référence

##### Tableau des balises

Chaque Gtk::TextBuffer utilise un objet Gtk::TextBuffer::TagTable contenant les balises pour ce tampon. Deux objets TextBuffer ou plus peuvent partager le même objet TagTable. Quand vous créez un objet Tag vous devez l'incorporer dans l'objet TagTable. Par exemple :

    Glib::RefPtr<Gtk::TextBuffer::TagTable> refTagTable =
        Gtk::TextBuffer::TagTable::create();
    refTagTable->add(refTagMatch);
    // Avec un peu de chance une future version de gtkmm
    // disposera d'une fonction membre set_tag_table(),
    // à utiliser après la création du tampon.
    Glib::RefPtr<Gtk::TextBuffer> refBuffer =
        Gtk::TextBuffer::create(refTagTable);

Vous pouvez aussi utiliser get_tag_table() pour obtenir, et peut-être modifier, l'objet TagTable par défaut du TextBuffer au lieu d'en créer un explicitement.

Référence

##### Application des balises

Si vous avez créé un Tag et l'avez ajouté à l'objet TagTable, vous pouvez appliquer cette balise sur une partie du texte du TextBuffer et faire ainsi en sorte que ce texte soit affiché avec ce format. Vous définissez le début et la fin de la plage de texte en définissant des marqueurs du type Gtk::TextBuffer::iterator. Par exemple :

    refBuffer->apply_tag(refTagMatch, iterRangeStart, iterRangeStop);

Vous pouvez également définir le balisage dès l'insertion du texte : refBuffer->insert_with_tag(iter, "Un peu de texte", refTagMatch);

Vous pouvez appliquer plus d'un objet Tag au même texte en utilisant plusieurs fois la fonction membre apply_tag() ou en utilisant insert_with_tags(). L'objet Tag peut définir des valeurs différentes pour les mêmes propriétés : dans ce cas là, il faut résoudre les conflits avec la fonction membre Tag::set_priority().

#### Marquages

Les itérateurs du TextBuffer sont généralement invalidés si le texte est modifié ; mais, vous pouvez utiliser un objet Gtk::TextBuffer::Mark pour mémoriser une position dans ces cas-là. Par exemple :

    Glib::RefPtr<Gtk::TextBuffer::Mark> refMark =
        refBuffer->create_mark(iter);

Puis vous utiliserez ultérieurement la fonction membre get_iter() pour créer un itérateur pour la nouvelle position de l'objet Mark.

Il y a deux objets Mark prédéfinis — `insert` et `select_bound`, objets auxquels vous aurez accès grâce aux fonctions membres get_insert() et get_selection_bound() de la classe TextBuffer.

Référence

#### La vue

Comme mentionné plus haut, chaque TextView possède un TextBuffer et un ou plusieurs TextView peuvent partager le même TextBuffer.

Comme pour un TreeView, vous pouvez placer l'objet TextView dans un objet ScrolledWindow pour permettre à l'utilisateur d'explorer la totalité du texte à l'aide de barres de défilement.

Référence

##### Format par défaut

TextView dispose de diverses fonctions membres vous permettant de changer la présentation du contenu du tampon dans cette vue. Certaines peuvent être surdéfinies par les objets Gtk::TextTag dans le tampon, si elles définissent les mêmes choses. Par exemple, set_left_margin(), set_right_margin(), set_indent(), etc.

##### Défilement

Gtk::TextView dispose de diverses fonctions membres scroll_to_*(). Elles vous permettent de vous assurer qu'une zone donnée du texte du tampon est visible. Ainsi, la fonctionnalité Rechercher de votre application pourra utiliser la fonction membre Gtk::TextView::scroll_to_iter() pour afficher le texte trouvé.

### Éléments graphiques et ancres pour enfant

Vous pouvez incorporer des éléments graphiques, comme des Gtk::Button, dans le texte. Chaque élément graphique de ce type a besoin d'un objet ChildAnchor. Les ancrages des (objets) enfants sont associés à des iterators. Ainsi, pour créer un ancrage pour un objet enfant à une position donnée, utilisez Gtk::TextBuffer::create_child_anchor() :

    Glib::RefPtr<Gtk::TextChildAnchor> refAnchor =
        refBuffer->create_child_anchor(iter);

Puis, pour ajouter l'élément graphique à la position indiquée, servez-vous de Gtk::TextView::add_child_at_anchor() :

    m_TextView.add_child_at_anchor(m_Button, refAnchor);

Référence

### Exemples

#### Un exemple simple

Élément graphique TextView

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      void fill_buffers();

      //Signal handlers:
      void on_button_quit();
      void on_button_buffer1();
      void on_button_buffer2();

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TextView m_TextView;

      Glib::RefPtr<Gtk::TextBuffer> m_refTextBuffer1, m_refTextBuffer2;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit, m_Button_Buffer1, m_Button_Buffer2;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit(Gtk::Stock::QUIT),
      m_Button_Buffer1("Use buffer 1"),
      m_Button_Buffer2("Use buffer 2")
    {
      set_title("Gtk::TextView example");
      set_border_width(5);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the TreeView, inside a ScrolledWindow, with the button underneath:
      m_ScrolledWindow.add(m_TextView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);

      //Add buttons:
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Buffer1, Gtk::PACK_SHRINK);
      m_ButtonBox.pack_start(m_Button_Buffer2, Gtk::PACK_SHRINK);
      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(5);
      m_ButtonBox.set_spacing(5);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);

      //Connect signals:
      m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );
      m_Button_Buffer1.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_buffer1) );
      m_Button_Buffer2.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_buffer2) );

      fill_buffers();
      on_button_buffer1();

      show_all_children();
    }

    void ExampleWindow::fill_buffers()
    {
      m_refTextBuffer1 = Gtk::TextBuffer::create();
      m_refTextBuffer1->set_text("This is the text from TextBuffer #1.");

      m_refTextBuffer2 = Gtk::TextBuffer::create();
      m_refTextBuffer2->set_text(
              "This is some alternative text, from TextBuffer #2.");

    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

    void ExampleWindow::on_button_buffer1()
    {
      m_TextView.set_buffer(m_refTextBuffer1);
    }

    void ExampleWindow::on_button_buffer2()
    {
      m_TextView.set_buffer(m_refTextBuffer2);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

## Menus et barres d'outils

Les menus et les barres d'outils ont des API distinctes, mais vous pouvez les manipuler simultanément en utilisant l'UIManager pour définir une Action que vous disposez ensuite à la fois dans le menu et dans la barre d'outils. De la sorte, vous pourrez gérer le déclenchement de l'action d'un coup au lieu d'organiser une réponse séparée aux éléments du menu et à ceux de la barre d'outils. Vous pourrez également activer ou désactiver les éléments de menu et de barre d'outils par l'intermédiaire de l'objet Action.

Cette façon d'opérer implique l'utilisation des classes Gtk::ActionGroup, Gtk::Action et UIManager ; chacune d'entre elles sera instanciée avec la fonction membre create() qui renverra un pointeur RefPtr.

### Actions

Créez tout d'abord un objet Action et ajoutez-le à un ActionGroup avec ActionGroup::add().

Les paramètres de Action::create() définissent le nom de l'action et la manière dont celle-ci apparaîtra dans les menus et barres d'outils. Utilisez des éléments du catalogue si possible ; ainsi, il ne vous sera pas nécessaire de préciser l'étiquette, le raccourci clavier, l'icône et les infobulles ; de plus, vous bénéficierez des traductions existantes.

Vous pouvez également indiquer le gestionnaire de signal lors de l'appel à ActionGroup::add(). Ce gestionnaire de signal sera appelé quand l'action sera activée par l'intermédiaire, soit de l'élément de menu, soit du bouton de la barre d'outils.

Notez que vous devez définir des actions pour les éléments de sous-menus de la même manière que pour les menus.

Par exemple :

    m_refActionGroup = Gtk::ActionGroup::create();

    m_refActionGroup->add( Gtk::Action::create("MenuFile", "_File") );
    m_refActionGroup->add( Gtk::Action::create("New", Gtk::Stock::NEW),
      sigc::mem_fun(*this, &ExampleWindow::on_action_file_new) );
    m_refActionGroup->add( Gtk::Action::create("ExportData", "Export Data"),
      sigc::mem_fun(*this, &ExampleWindow::on_action_file_open) );
    m_refActionGroup->add( Gtk::Action::create("Quit", Gtk::Stock::QUIT),
      sigc::mem_fun(*this, &ExampleWindow::on_action_file_quit) );

Notez que les noms des actions, tels qu'ils seront vus par l'utilisateur dans les menus et les barres d'outils, est précisé ici. En les plaçant dans la macro _(), ces chaînes pourront être traduites. Quand vous utilisez les éléments du catalogue Gtk::Stock, les traductions sont, bien entendu, automatiquement accessibles.

### UIManager

Vous devez ensuite créer un UIManager dans lequel vous ajoutez les objets ActionGroup avec insert_action_group(). Il est judicieux d'indiquer à cet instant à la fenêtre parent de répondre aux raccourcis claviers avec la fonction membre add_accel_group().

Par exemple,

    Glib::RefPtr<Gtk::UIManager> m_refUIManager =
        Gtk::UIManager::create();
    m_refUIManager->insert_action_group(m_refActionGroup);
    add_accel_group(m_refUIManager->get_accel_group());

Puis, vous définissez la disposition réelle de l'affichage des menus et des barres d'outils en insérant l'agencement de l'UI dans l'UIManager. Cette « chaîne ui » utilise un format XML dans lequel vous mentionnez le nom des actions que vous venez de créer. Par exemple :

    Glib::ustring ui_info =
        "<ui>"
        "  <menubar name='MenuBar'>"
        "    <menu action='MenuFile'>"
        "      <menuitem action='New'/>"
        "      <menuitem action='Open'/>"
        "      <separator/>"
        "      <menuitem action='Quit'/>"
        "    </menu>"
        "    <menu action='MenuEdit'>"
        "      <menuitem action='Cut'/>"
        "      <menuitem action='Copy'/>"
        "      <menuitem action='Paste'/>"
        "    </menu>"
        "  </menubar>"
        "  <toolbar  name='ToolBar'>"
        "    <toolitem action='Open'/>"
        "    <toolitem action='Quit'/>"
        "  </toolbar>"
        "</ui>";

    m_refUIManager->add_ui_from_string(ui_info);

Souvenez-vous que ces noms sont uniquement les identifiants utilisés lors de la création des actions. Ce n'est pas le texte que l'utilisateur verra dans les menus et les barres d'outils. Nous avons indiqué les libellés lisibles par l'utilisateur lors de la création des actions.

Pour créer un objet Gtk::MenuBar ou Gtk::Toolbar que vous pouvez vraiment afficher, utilisez la fonction membre UIManager::get_widget() et ajoutez l'élément graphique dans un conteneur. Par exemple :

    Gtk::Widget* pMenubar = m_refUIManager->get_widget("/MenuBar");
    pBox->add(*pMenuBar, Gtk::PACK_SHRINK);

### Menus contextuels

Normalement, les menus sont seulement ajoutés à une fenêtre, mais ils peuvent aussi être temporairement affichés lors d'un clic de souris. Par exemple, un menu contextuel peut s'afficher si l'utilisateur clique sur un élément avec le bouton droit de la souris.

La présentation UI d'un menu contextuel utilise la balise `popup`. Par exemple :

    Glib::ustring ui_info =
        "<ui>"
        "  <popup name='PopupMenu'>"
        "    <menuitem action='ContextEdit'/>"
        "    <menuitem action='ContextProcess'/>"
        "    <menuitem action='ContextRemove'/>"
        "  </popup>"
        "</ui>";

    m_refUIManager->add_ui_from_string(ui_info);

Pour afficher le menu contextuel, utilisez la fonction membre popup() de la classe Gtk::Menu. Vous indiquez l'identifiant du bouton de souris et le délai d'activation tels que fournis par le signal `button_press_event`, signal que vous devez gérer de toutes façons. Par exemple :

    bool ExampleWindow::on_button_press_event(GdkEventButton* event)
    {
      if( (event->type == GDK_BUTTON_PRESS) &&
          (event->button == 3) )
      {
        m_Menu_Popup->popup(event->button, event->time);
        return true; // Il est géré.
      }
      else
        return false;
    }

### Exemples

#### Exemple de menu principal

Menu principal

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_menu_file_new_generic();
      void on_menu_file_quit();
      void on_menu_others();

      void on_menu_choices_one();
      void on_menu_choices_two();

      //Child widgets:
      Gtk::Box m_Box;

      Glib::RefPtr<Gtk::UIManager> m_refUIManager;
      Glib::RefPtr<Gtk::ActionGroup> m_refActionGroup;
      Glib::RefPtr<Gtk::RadioAction> m_refChoiceOne, m_refChoiceTwo;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/stock.h>
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_Box(Gtk::ORIENTATION_VERTICAL)
    {
      set_title("main menu example");
      set_default_size(200, 200);

      add(m_Box); // put a MenuBar at the top of the box and other stuff below it.

      //Create actions for menus and toolbars:
      m_refActionGroup = Gtk::ActionGroup::create();

      //File|New sub menu:
      m_refActionGroup->add(Gtk::Action::create("FileNewStandard",
                  Gtk::Stock::NEW, "_New", "Create a new file"),
              sigc::mem_fun(*this, &ExampleWindow::on_menu_file_new_generic));

      m_refActionGroup->add(Gtk::Action::create("FileNewFoo",
                  Gtk::Stock::NEW, "New Foo", "Create a new foo"),
              sigc::mem_fun(*this, &ExampleWindow::on_menu_file_new_generic));

      m_refActionGroup->add(Gtk::Action::create("FileNewGoo",
                  Gtk::Stock::NEW, "_New Goo", "Create a new goo"),
              sigc::mem_fun(*this, &ExampleWindow::on_menu_file_new_generic));

      //File menu:
      m_refActionGroup->add(Gtk::Action::create("FileMenu", "File"));
      //Sub-menu.
      m_refActionGroup->add(Gtk::Action::create("FileNew", Gtk::Stock::NEW));
      m_refActionGroup->add(Gtk::Action::create("FileQuit", Gtk::Stock::QUIT),
              sigc::mem_fun(*this, &ExampleWindow::on_menu_file_quit));

      //Edit menu:
      m_refActionGroup->add(Gtk::Action::create("EditMenu", "Edit"));
      m_refActionGroup->add(Gtk::Action::create("EditCopy", Gtk::Stock::COPY),
              sigc::mem_fun(*this, &ExampleWindow::on_menu_others));
      m_refActionGroup->add(Gtk::Action::create("EditPaste", Gtk::Stock::PASTE),
              sigc::mem_fun(*this, &ExampleWindow::on_menu_others));
      m_refActionGroup->add(Gtk::Action::create("EditSomething", "Something"),
              Gtk::AccelKey("<control><alt>S"),
              sigc::mem_fun(*this, &ExampleWindow::on_menu_others));

      //Choices menu, to demonstrate Radio items
      m_refActionGroup->add( Gtk::Action::create("ChoicesMenu", "Choices") );
      Gtk::RadioAction::Group group_userlevel;
      m_refChoiceOne = Gtk::RadioAction::create(group_userlevel, "ChoiceOne", "One");
      m_refActionGroup->add(m_refChoiceOne,
              sigc::mem_fun(*this, &ExampleWindow::on_menu_choices_one) );
      m_refChoiceTwo = Gtk::RadioAction::create(group_userlevel, "ChoiceTwo", "Two");
      m_refActionGroup->add(m_refChoiceTwo,
              sigc::mem_fun(*this, &ExampleWindow::on_menu_choices_two) );

      //Help menu:
      m_refActionGroup->add( Gtk::Action::create("HelpMenu", "Help") );
      m_refActionGroup->add( Gtk::Action::create("HelpAbout", Gtk::Stock::HELP),
              sigc::mem_fun(*this, &ExampleWindow::on_menu_others) );

      m_refUIManager = Gtk::UIManager::create();
      m_refUIManager->insert_action_group(m_refActionGroup);

      add_accel_group(m_refUIManager->get_accel_group());

      //Layout the actions in a menubar and toolbar:
      Glib::ustring ui_info =
            "<ui>"
            "  <menubar name='MenuBar'>"
            "    <menu action='FileMenu'>"
            "      <menu action='FileNew'>"
            "        <menuitem action='FileNewStandard'/>"
            "        <menuitem action='FileNewFoo'/>"
            "        <menuitem action='FileNewGoo'/>"
            "      </menu>"
            "      <separator/>"
            "      <menuitem action='FileQuit'/>"
            "    </menu>"
            "    <menu action='EditMenu'>"
            "      <menuitem action='EditCopy'/>"
            "      <menuitem action='EditPaste'/>"
            "      <menuitem action='EditSomething'/>"
            "    </menu>"
            "    <menu action='ChoicesMenu'>"
            "      <menuitem action='ChoiceOne'/>"
            "      <menuitem action='ChoiceTwo'/>"
            "    </menu>"
            "    <menu action='HelpMenu'>"
            "      <menuitem action='HelpAbout'/>"
            "    </menu>"
            "  </menubar>"
            "  <toolbar  name='ToolBar'>"
            "    <toolitem action='FileNewStandard'/>"
            "    <toolitem action='FileQuit'/>"
            "  </toolbar>"
            "</ui>";

      try
      {
        m_refUIManager->add_ui_from_string(ui_info);
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "building menus failed: " <<  ex.what();
      }

      //Get the menubar and toolbar widgets, and add them to a container widget:
      Gtk::Widget* pMenubar = m_refUIManager->get_widget("/MenuBar");
      if(pMenubar)
        m_Box.pack_start(*pMenubar, Gtk::PACK_SHRINK);

      Gtk::Widget* pToolbar = m_refUIManager->get_widget("/ToolBar") ;
      if(pToolbar)
        m_Box.pack_start(*pToolbar, Gtk::PACK_SHRINK);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_menu_file_quit()
    {
      hide(); //Closes the main window to stop the Gtk::Main::run().
    }

    void ExampleWindow::on_menu_file_new_generic()
    {
       std::cout << "A File|New menu item was selected." << std::endl;
    }

    void ExampleWindow::on_menu_others()
    {
      std::cout << "A menu item was selected." << std::endl;
    }

    void ExampleWindow::on_menu_choices_one()
    {
      Glib::ustring message;
      if(m_refChoiceOne->get_active())
        message = "Choice 1 was selected.";
      else
        message = "Choice 1 was deselected";

      std::cout << message << std::endl;
    }

    void ExampleWindow::on_menu_choices_two()
    {
      Glib::ustring message;
      if(m_refChoiceTwo->get_active())
        message = "Choice 2 was selected.";
      else
        message = "Choice 2 was deselected";

      std::cout << message << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Exemple de menu contextuel

Menu contextuel

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      virtual bool on_button_press_event(GdkEventButton* event);
      void on_menu_file_popup_generic();

      //Child widgets:
      Gtk::Box m_Box;
      Gtk::EventBox m_EventBox;
      Gtk::Label m_Label;

      Glib::RefPtr<Gtk::UIManager> m_refUIManager;
      Glib::RefPtr<Gtk::ActionGroup> m_refActionGroup;

      Gtk::Menu* m_pMenuPopup;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/stock.h>
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_Box(Gtk::ORIENTATION_VERTICAL),
      m_Label("Right-click to see the popup menu."),
      m_pMenuPopup(0)
      /* m_Image(Gtk::Stock::DIALOG_QUESTION, Gtk::ICON_SIZE_MENU) */
    {
      set_title("popup example");
      set_default_size(200, 200);

      add(m_Box);

      //Add an event box that can catch button_press events:
      m_Box.pack_start(m_EventBox);
      m_EventBox.signal_button_press_event().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_press_event) );

      m_EventBox.add(m_Label);

      //Create actions:

      //Fill menu:

      m_refActionGroup = Gtk::ActionGroup::create();

      //File|New sub menu:
      //These menu actions would normally already exist for a main menu, because a
      //context menu should not normally contain menu items that are only available
      //via a context menu.
      m_refActionGroup->add(Gtk::Action::create("ContextMenu", "Context Menu"));

      m_refActionGroup->add(Gtk::Action::create("ContextEdit", "Edit"),
              sigc::mem_fun(*this, &ExampleWindow::on_menu_file_popup_generic));

      m_refActionGroup->add(Gtk::Action::create("ContextProcess", "Process"),
              Gtk::AccelKey("<control>P"),
              sigc::mem_fun(*this, &ExampleWindow::on_menu_file_popup_generic));

      m_refActionGroup->add(Gtk::Action::create("ContextRemove", "Remove"),
              sigc::mem_fun(*this, &ExampleWindow::on_menu_file_popup_generic));

      //TODO:
      /*
        //Add a ImageMenuElem:
        menulist.push_back( Gtk::Menu_Helpers::ImageMenuElem("_Something", m_Image,
          sigc::mem_fun(*this, &ExampleWindow::on_menu_file_popup_generic) ) ) ;
      */

      m_refUIManager = Gtk::UIManager::create();
      m_refUIManager->insert_action_group(m_refActionGroup);

      add_accel_group(m_refUIManager->get_accel_group());

      //Layout the actions in a menubar and toolbar:
      Glib::ustring ui_info =
            "<ui>"
            "  <popup name='PopupMenu'>"
            "    <menuitem action='ContextEdit'/>"
            "    <menuitem action='ContextProcess'/>"
            "    <menuitem action='ContextRemove'/>"
            "  </popup>"
            "</ui>";

      try
      {
        m_refUIManager->add_ui_from_string(ui_info);
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "building menus failed: " <<  ex.what();
      }

      //Get the menu:
      m_pMenuPopup = dynamic_cast<Gtk::Menu*>(
              m_refUIManager->get_widget("/PopupMenu"));
      if(!m_pMenuPopup)
        g_warning("menu not found");

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_menu_file_popup_generic()
    {
       std::cout << "A popup menu item was selected." << std::endl;
    }

    bool ExampleWindow::on_button_press_event(GdkEventButton* event)
    {
      if( (event->type == GDK_BUTTON_PRESS) && (event->button == 3) )
      {
        if(m_pMenuPopup)
          m_pMenuPopup->popup(event->button, event->time);

        return true; //It has been handled.
      }
      else
        return false;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

## Palette d'outils

L'objet ToolPalette est semblable à un objet Toolbar, mais il peut comporter un quadrillage d'éléments classés en groupements. L'utilisateur peut masquer ou développer chaque groupement. Comme dans une barre d'outils, les éléments sont affichés sous forme d'icônes uniquement, texte uniquement ou icônes avec texte.

Il est possible de faire glisser, ou simplement activer, les éléments d'un objet ToolPalette. Par exemple, l'utilisateur peut faire glisser des objets sur un canevas pour y créer de nouveaux éléments, ou bien, il peut cliquer sur un élément pour activer une taille de plume donnée dans une application de tracé.

Ajoutez un ToolItemGroup à une palette d'outils par l'intermédiaire de la fonction membre `Gtk::Container::add()` de la classe de base. Comme ceci :

    Gtk::ToolItemGroup* group_brushes =
      Gtk::manage(new Gtk::ToolItemGroup("Brosses"));
    m_ToolPalette.add(*group_brushes);

Les éléments Gtk::ToolItem sont ensuite ajoutés au groupement. Ainsi :

    Gtk::ToolButton* button = Gtk::manage(new Gtk::ToolButton(icon, "Grande"));
    button->set_tooltip_text("Grande brosse);
    group_brushes->insert(*button);

Vous pouvez après cela gérer le signal `clicked` sur l'objet ToolButton. Autre possibilité, vous pouvez autoriser le glisser-déposer de l'élément sur un autre élément graphique avec Gtk::ToolPalette::add_drag_dest(), puis en faisant appel à Gtk::ToolPalette::get_drag_item() dans le gestionnaire du signal `drag_data_received` de l'autre élément graphique.

Référence de ToolPalette

Référence de ToolItemGroup

Référence de ToolItem

### Glisser-déposer

Appelez la fonction membre add_drag_dest() pour permettre le glisser-déposer d'éléments ou de groupes depuis une palette d'outils jusqu'à un élément graphique destination donné. Puis vous pouvez vous servir de get_drag_item() pour savoir quel outil élémentaire ou quel groupe a été glissé. Un `dynamic_cast` vous permet de savoir s'il s'agit d'un élément ou d'un groupe. Ainsi, dans le gestionnaire du signal `drag_data_received` vous utilisez ce forçage de type pour ajouter un élément déposé ou pour afficher une icône adaptée pendant le glissé.

Consultez le chapitre Glisser-déposer pour des considérations générales sur cette fonctionnalité avec gtkmm.

### Exemple de palette d'outils

Dans cet exemple, des objets ToolPalette et DrawingArea sont associés à une fenêtre. L'utilisateur est autorisé à faire un glisser-déposer depuis la palette d'outils sur la surface de tracé. La palette d'outils contient divers groupes d'éléments. Des boîtes combinées permettent à l'utilisateur de changer le style et l'orientation de la palette d'outils.

Palette d'outils

Code source

File: `canvas.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_CANVAS_H
    #define GTKMM_EXAMPLE_CANVAS_H

    #include <gtkmm.h>

    // This little canvas class is only here
    // because gtkmm does not have a canvas class yet.
    // Applications should probably use GooCanvas::Canvas (goocanvasmm) instead.
    class Canvas : public Gtk::DrawingArea
    {
    public:
      Canvas();
      virtual ~Canvas();

    private:

      class CanvasItem
      {
      public:
        CanvasItem(Gtk::Widget* canvas, Gtk::ToolButton* button, double x, double y)
        {
          const Gtk::StockID stock_id(button->get_stock_id());
          this->pixbuf = canvas->render_icon_pixbuf(stock_id, Gtk::ICON_SIZE_DIALOG);
          this->x = x;
          this->y = y;
        }

        Glib::RefPtr<Gdk::Pixbuf> pixbuf;
        double x, y;
      };

      void item_draw(const CanvasItem *item,
        const Cairo::RefPtr<Cairo::Context>& cr,
        bool preview);

      virtual bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr);
      virtual void on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context,
        int x, int y, const Gtk::SelectionData& selection_data, guint info, guint time);
      virtual bool on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time);
      virtual bool on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time);
      virtual void on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint time);

      bool m_drag_data_requested_for_drop; //So we know what to do in on_drag_data_received().
      CanvasItem* m_drop_item;

      typedef std::vector<CanvasItem*> type_vec_items;
      type_vec_items m_canvas_items;
    };

    #endif //GTKMM_EXAMPLE_CANVAS_H

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>
    #include "canvas.h"

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    private:

      void load_stock_items();
      void load_toggle_items();
      void load_special_items();

      //Signal handlers:
      void on_combo_orientation_changed();
      void on_combo_style_changed();

      //Tree model columns:
      class ModelColumnsOrientation : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumnsOrientation()
        { add(m_col_value); add(m_col_name); }

        Gtk::TreeModelColumn<Gtk::Orientation> m_col_value;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
      };

      ModelColumnsOrientation m_ColumnsOrientation;

      //Tree model columns:
      class ModelColumnsStyle : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumnsStyle()
        { add(m_col_value); add(m_col_name); }

        Gtk::TreeModelColumn<int> m_col_value; //We use int to also allow -1
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
      };

      ModelColumnsStyle m_ColumnsStyle;

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Box m_HBox;
      Gtk::ComboBox m_ComboOrientation;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModelOrientation;
      Gtk::ComboBox m_ComboStyle;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModelStyle;
      Gtk::ToolPalette m_ToolPalette;
      Gtk::ScrolledWindow m_ScrolledWindowPalette;
      Gtk::ScrolledWindow m_ScrolledWindowCanvas;
      Canvas m_Canvas;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    static bool sort_predicate(const Gtk::StockID& a, const Gtk::StockID& b)
    {
      return a.get_string() < b.get_string();
    }

    void ExampleWindow::load_stock_items()
    {
      Gtk::ToolItemGroup* group_af =
        Gtk::manage(new Gtk::ToolItemGroup("Stock Icons (A-F)"));
      m_ToolPalette.add(*group_af);
      Gtk::ToolItemGroup* group_gn =
        Gtk::manage(new Gtk::ToolItemGroup("Stock Icons (G-N)"));
      m_ToolPalette.add(*group_gn);
      Gtk::ToolItemGroup* group_or =
        Gtk::manage(new Gtk::ToolItemGroup("Stock Icons (O-R)"));
      m_ToolPalette.add(*group_or);
      Gtk::ToolItemGroup* group_sz =
        Gtk::manage(new Gtk::ToolItemGroup("Stock Icons (S-Z)"));
      m_ToolPalette.add(*group_sz);

      // Obtain the IDs of all stock items:
      typedef std::vector<Gtk::StockID> type_vecIDs;
      type_vecIDs vecIDs = Gtk::Stock::get_ids();

      std::sort(vecIDs.begin(), vecIDs.end(), &sort_predicate);

      Gtk::ToolItemGroup* group = 0;

      // Iterate through them, populating the ListStore as appropriate:
      for(type_vecIDs::const_iterator iterIDs = vecIDs.begin(); iterIDs != vecIDs.end(); ++iterIDs)
      {
        const Gtk::StockID& stockid = *iterIDs;
        const Glib::ustring str = stockid.get_string();
        if(str.size() < 4)
          continue;

        switch(str[4])
        {
          case 'a':
            group = group_af;
            break;
          case 'g':
            group = group_gn;
            break;
          case 'o':
            group = group_or;
            break;
          case 's':
            group = group_sz;
            break;
          default:
            //Use the previous group
            //(They are sorted.)
            break;
        }

        if(!group)
          continue;

        Gtk::ToolButton* button = Gtk::manage(new Gtk::ToolButton(stockid));
        button->set_tooltip_text(str);
        button->set_is_important();
        group->insert(*button);

        Gtk::StockItem stockitem;
        if(!Gtk::StockItem::lookup(stockid, stockitem) ||
          stockitem.get_label().empty())
            button->set_label(str);
      }
    }

    void ExampleWindow::load_toggle_items()
    {
      Gtk::ToolItemGroup* group =
        Gtk::manage(new Gtk::ToolItemGroup("Radio Item"));
      m_ToolPalette.add(*group);

      Gtk::RadioToolButton::Group radio_group;

      for(int i = 1; i <= 10; ++i)
      {
        const Glib::ustring label = Glib::ustring::compose("#%1", i);
        Gtk::RadioToolButton* button = Gtk::manage(new Gtk::RadioToolButton());
        button->set_group(radio_group);
        button->set_label(label);

        group->insert(*button);
      }
    }

    static Gtk::ToolItem* create_entry_item(const Glib::ustring& text)
    {
      Gtk::Entry* entry = Gtk::manage(new Gtk::Entry());
      entry->set_text(text);
      entry->set_width_chars(5);

      Gtk::ToolItem* item = Gtk::manage(new Gtk::ToolItem());
      item->add(*entry);

      return item;
    }

    void ExampleWindow::load_special_items()
    {
      Gtk::ToolItemGroup* group = Gtk::manage(new Gtk::ToolItemGroup());

      Gtk::Button *label_button = Gtk::manage(new Gtk::Button("Advanced Features"));
      label_button->show();
      group->set_label_widget(*label_button);
      m_ToolPalette.add(*group);

      Gtk::ToolItem* item = create_entry_item ("homogeneous=false");
      group->insert(*item);
      //TODO: Add Gtk::Container::set_child_property().
      gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (item->gobj()),
                               "homogeneous", FALSE, NULL);

      item = create_entry_item ("homogeneous=FALSE, expand=TRUE");
      group->insert(*item);
      gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (item->gobj()),
                               "homogeneous", FALSE, "expand", TRUE,
                               NULL);

      item = create_entry_item ("homogeneous=FALSE, expand=TRUE, fill=FALSE");
      group->insert(*item);
      gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (item->gobj()),
                               "homogeneous", FALSE, "expand", TRUE,
                               "fill", FALSE, NULL);

      item = create_entry_item ("homogeneous=FALSE, expand=TRUE, new-row=TRUE");
      group->insert(*item);
      gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (item->gobj()),
                               "homogeneous", FALSE, "expand", TRUE,
                               "new-row", TRUE, NULL);

      item = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::GO_UP));
      item->set_tooltip_text("Show on vertical palettes only");
      group->insert(*item);
      item->set_visible_horizontal(false);

      item = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::GO_FORWARD));
      item->set_tooltip_text("Show on horizontal palettes only");
      group->insert(*item);
      item->set_visible_vertical(false);

      item = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::FULLSCREEN));
      item->set_tooltip_text("Expanded this item");
      group->insert(*item);
      gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (item->gobj()),
                               "homogeneous", FALSE,
                               "expand", TRUE,
                               NULL);

      item = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::HELP));
      item->set_tooltip_text("A regular item");
      group->insert(*item);
    }

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL, 6),
      m_HBox(Gtk::ORIENTATION_HORIZONTAL, 6)
    {
      set_title("Gtk::ToolPalette example");
      set_size_request(600, 600);
      set_border_width(6);

      add(m_VBox);

      //The Orientation ComboBox:
      m_refTreeModelOrientation = Gtk::ListStore::create(m_ColumnsOrientation);
      Gtk::TreeModel::Row row = *(m_refTreeModelOrientation->append());
      row[m_ColumnsOrientation.m_col_value] = Gtk::ORIENTATION_HORIZONTAL;
      row[m_ColumnsOrientation.m_col_name] = "Horizontal";\
      row = *(m_refTreeModelOrientation->append());
      row[m_ColumnsOrientation.m_col_value] = Gtk::ORIENTATION_VERTICAL;
      row[m_ColumnsOrientation.m_col_name] = "Vertical";
      m_ComboOrientation.set_model(m_refTreeModelOrientation);
      m_VBox.pack_start(m_ComboOrientation, Gtk::PACK_SHRINK);
      m_ComboOrientation.pack_start(m_ColumnsOrientation.m_col_name);
      m_ComboOrientation.signal_changed().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_combo_orientation_changed) );
      m_ComboOrientation.set_active(row);

      //The Style ComboBox:
      m_refTreeModelStyle = Gtk::ListStore::create(m_ColumnsStyle);
      row = *(m_refTreeModelStyle->append());
      row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_TEXT;
      row[m_ColumnsStyle.m_col_name] = "Text";\
      row = *(m_refTreeModelStyle->append());
      row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_BOTH;
      row[m_ColumnsStyle.m_col_name] = "Both";
      row = *(m_refTreeModelStyle->append());
      row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_BOTH_HORIZ;
      row[m_ColumnsStyle.m_col_name] = "Both: Horizontal";
      row = *(m_refTreeModelStyle->append());
      row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_ICONS;
      row[m_ColumnsStyle.m_col_name] = "Icons";
      row = *(m_refTreeModelStyle->append());
      row[m_ColumnsStyle.m_col_value] = -1; // A custom meaning for this demo.
      row[m_ColumnsStyle.m_col_name] = "Default";
      m_ComboStyle.set_model(m_refTreeModelStyle);
      m_VBox.pack_start(m_ComboStyle, Gtk::PACK_SHRINK);
      m_ComboStyle.pack_start(m_ColumnsStyle.m_col_name);
      m_ComboStyle.signal_changed().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_combo_style_changed) );
      m_ComboStyle.set_active(row);

      //Add and fill the ToolPalette:
      load_stock_items();
      load_toggle_items();
      load_special_items();

      m_VBox.pack_start(m_HBox, Gtk::PACK_EXPAND_WIDGET);

      m_ScrolledWindowPalette.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
      m_ScrolledWindowPalette.set_border_width(6);
      m_ScrolledWindowPalette.add(m_ToolPalette);
      m_HBox.pack_start(m_ScrolledWindowPalette);

      on_combo_orientation_changed();

      m_ScrolledWindowCanvas.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_ALWAYS);
      m_ScrolledWindowCanvas.set_border_width(6);
      m_ScrolledWindowCanvas.add(m_Canvas);
      m_ScrolledWindowCanvas.set_size_request(200, -1);
      m_HBox.pack_start(m_ScrolledWindowCanvas);

      m_ToolPalette.add_drag_dest(m_Canvas,
        Gtk::DEST_DEFAULT_HIGHLIGHT, Gtk::TOOL_PALETTE_DRAG_ITEMS, Gdk::ACTION_COPY);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_combo_orientation_changed()
    {
      Gtk::TreeModel::iterator iter = m_ComboOrientation.get_active();
      if(!iter)
        return;

      Gtk::TreeModel::Row row = *iter;
      const Gtk::Orientation value = row[m_ColumnsOrientation.m_col_value];

      m_ToolPalette.set_orientation(value);

      if(value == Gtk::ORIENTATION_HORIZONTAL)
        m_ScrolledWindowPalette.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_NEVER);
      else
        m_ScrolledWindowPalette.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
    }

    void ExampleWindow::on_combo_style_changed()
    {
      Gtk::TreeModel::iterator iter = m_ComboStyle.get_active();
      if(!iter)
        return;

      Gtk::TreeModel::Row row = *iter;
      const int value = row[m_ColumnsStyle.m_col_value];

      if(value == -1)
        m_ToolPalette.unset_style();
      else
        m_ToolPalette.set_style((Gtk::ToolbarStyle)value);
    }

File: `canvas.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "canvas.h"
    #include <iostream>

    Canvas::Canvas()
    : m_drag_data_requested_for_drop(false),
      m_drop_item()
    {
      set_app_paintable();
    }

    Canvas::~Canvas()
    {
      while(!m_canvas_items.empty())
      {
        type_vec_items::iterator iter = m_canvas_items.begin();
        CanvasItem* item = *iter;
        delete item;
        m_canvas_items.erase(iter);
      }

      if(m_drop_item)
        delete m_drop_item;
    }

    void Canvas::item_draw(const CanvasItem *item,
      const Cairo::RefPtr<Cairo::Context>& cr,
      bool preview)
    {
      if(!item || !item->pixbuf)
        return;

      const double cx = item->pixbuf->get_width();
      const double cy = item->pixbuf->get_height();

      Gdk::Cairo::set_source_pixbuf(cr,
        item->pixbuf,
        item->x - cx * 0.5, item->y - cy * 0.5);

      if(preview)
        cr->paint_with_alpha(0.6);
      else
        cr->paint();
    }

    bool Canvas::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      cr->set_source_rgb(1.0, 1.0, 1.0);
      const Gtk::Allocation allocation = get_allocation();
      cr->rectangle(0, 0, allocation.get_width(), allocation.get_height());
      cr->fill();

      for(type_vec_items::iterator iter = m_canvas_items.begin();
        iter != m_canvas_items.end(); ++iter )
      {
        item_draw(*iter, cr, false);
      }

      if(m_drop_item)
        item_draw (m_drop_item, cr, true);

      return true;
    }

    bool Canvas::on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context,
      int x, int y, guint time)
    {
      m_drag_data_requested_for_drop = false; //It's for drag-motion instead.

      if(m_drop_item)
      {
        // We already have a drop indicator so just update its position.

        m_drop_item->x = x;
        m_drop_item->y = y;

        queue_draw();
        context->drag_status(Gdk::ACTION_COPY, time);
      }
      else
      {
        // Request DnD data for creating a drop indicator.
        // This will cause on_drag_data_received() to be called.
        const Glib::ustring target = drag_dest_find_target(context);

        if (target.empty())
          return false;

        drag_get_data(context, target, time);
      }

      Gtk::DrawingArea::on_drag_motion(context, x, y, time);
      return true;
    }

    void Canvas::on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const Gtk::SelectionData& selection_data, guint info, guint time)
    {
      // Find the tool button which is the source of this DnD operation.
      Gtk::Widget* widget = drag_get_source_widget(context);

      Gtk::ToolPalette* drag_palette = dynamic_cast<Gtk::ToolPalette*>(widget);
      while(widget && !drag_palette)
      {
        widget = widget->get_parent();
        drag_palette = dynamic_cast<Gtk::ToolPalette*>(widget);
      }

      Gtk::ToolItem* drag_item = 0;
      if(drag_palette)
        drag_item = drag_palette->get_drag_item(selection_data);

      // Create a drop indicator when a tool button was found:
      Gtk::ToolButton* button = dynamic_cast<Gtk::ToolButton*>(drag_item);
      if(!button)
        return;

      if(m_drop_item)
      {
        delete m_drop_item;
        m_drop_item = 0;
      }

      CanvasItem* item = new CanvasItem(this, button, x, y);

      if(m_drag_data_requested_for_drop)
      {
        m_canvas_items.push_back(item);

        // Signal that the item was accepted and then redraw.
        context->drag_finish(true /* success */, false /* del */, time);
      }
      else
      {
        m_drop_item = item;

        // We are getting this data due to a request in drag_motion,
        // rather than due to a request in drag_drop, so we are just
        // supposed to call gdk_drag_status (), not actually paste in
        // the data.
        context->drag_status(Gdk::ACTION_COPY, time);
      }

      queue_draw();

      Gtk::DrawingArea::on_drag_data_received(context, x, y, selection_data, info, time);
    }

    bool Canvas::on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int /* x */, int /* y */, guint time)
    {
      // Request DnD data for creating a dopped item.
      // This will cause on_drag_data_received() to be called.
      const Glib::ustring target = drag_dest_find_target(context);

      if (target.empty())
        return false;

      m_drag_data_requested_for_drop = true;
      drag_get_data(context, target, time);

      return true;
    }

    void Canvas::on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint time)
    {
      //This signal is emitted to clean up the item used for drag-motion,
      //either when the cursor moves out of the widget or when we drop.

      if(!m_drop_item)
        return;

      delete m_drop_item;
      m_drop_item = 0;

      queue_draw();

      Gtk::DrawingArea::on_drag_leave(context, time);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

## Ajustements

gtkmm dispose de nombreux éléments graphiques pouvant être visuellement ajustés avec la souris ou le clavier, tels les éléments graphiques Range (décrits dans le paragraphe Éléments graphiques à plage de réglage). Il existe également un petit nombre d'éléments graphiques qui n'affichent qu'une partie ajustable d'une zone plus grande, comme l'élément graphique Viewport. Tous ces éléments graphiques sont adossés à un objet Gtk::Adjustment pour définir cette part commune du comportement de leur API.

Ainsi pour que les applications puissent réagir à une demande de modification, par exemple quand l'utilisateur déplace le curseur dans la barre de défilement, l'objet Gtk::Adjustment émet le signal `changed`. Vous pourrez alors utiliser la fonction membre get_changed() pour connaître la nouvelle valeur.

### Création d'un objet Adjustment

Le constructeur de Gtk::Adjustment crée la structure suivante :

    Gtk::Adjustment(float value,
                    float lower,
                    float upper,
                    float step_increment = 1,
                    float page_increment = 10,
                    float page_size = 0);

Le paramètre value définit la valeur initiale de l'ajustement ; habituellement, elle correspond à la position la plus haute ou la plus à gauche de l'élément graphique à plage de réglage. Les paramètres lower et upper bornent la plage des valeurs que l'ajustement est autorisé à gérer. step_increment est la plus petite valeur de modification incrémentale de value, page_increment la plus grande. Le paramètre page_size correspond communément à quelque chose comme la partie visible d'un élément graphique panneau. Le paramètre upper représente la coordonnée la plus basse ou la plus à droite pour un enfant d'un élément graphique panneau.

### Facilité d'utilisation des objets Adjustment

Il est possible, grosso modo, de diviser les éléments graphiques à plage de réglage en, d'une part, ceux dont la structure d'ajustement utilise et nécessite des valeurs précises, et ceux, d'autre part, qui considèrent ces valeurs comme des nombres arbitraires.

Le groupe qui traite ces valeurs comme des nombres arbitraires est celui des éléments graphiques Range (les éléments Scrollbars, Scales, Progressbar et SpinButton). Ces éléments graphiques sont typiquement ceux qui sont « ajustés » directement par l'utilisateur avec la souris ou le clavier. Ils considèrent les valeurs de lower et upper comme étant les bornes de la plage des valeurs dans laquelle l'utilisateur peut définir value. Par défaut, l'utilisateur ne peut modifier que la grandeur value de l'ajustement.

L'autre groupe comprend les éléments graphiques Viewport et ScrolledWindow. Tous ceux-ci utilisent des valeurs en pixels dans leur structure `adjustment`. Ils sont, en règle générale, « ajustés » indirectement à l'aide de barres de défilement. Comme tous les éléments graphiques utilisant des ajustements peuvent, soit créer leurs propres structures `adjustement`, soit utiliser celle qui leur est fournie, nous souhaiterons, en règle générale, laisser à cette catégorie particulière d'éléments graphiques le soin de créer elle-même leurs propres structures d'ajustement.

Si vous partagez une structure d'ajustement entre un élément Scrollbar et un élément TextView, la manipulation de la barre de défilement ajustera comme par magie l'élément TextView. Vous pouvez définir cela comme suit :

    // crée ses propres ajustements
    Gtk::TextView textview;
    // utilise également l'ajustement nouvellement créé pour la barre de défilement
    Gtk::VScrollbar vscrollbar (*(textview.get_vadjustment()));

### À l'intérieur des ajustements

Oui, dites-vous, c'est bien beau, mais que faire si je souhaite créer mes propres gestionnaires pour répondre à la modification par l'utilisateur d'un élément graphique Range ou SpinButton. Pour avoir accès à la valeur du paramètre value d'un Gtk::Adjustment, utilisez les fonctions membres get_value() et set_value().

Comme mentionné plus haut, Gtk::Adjustment peut émettre des signaux. C'est pourquoi, bien entendu, les mises à jour se font automatiquement quand vous partagez un objet ajustement entre un Scrollbar et un autre élément graphique ajustable ; tous les éléments graphiques ajustables connectent leurs gestionnaires de signaux au signal `value_changed` de l'ajustement, comme pourrait le faire le programme.

Ainsi, par exemple, avec un élément graphique Scale, si vous voulez modifier la rotation d'une image chaque fois que `value` change, vous créez une fonction de rappel du type :

    void cb_rotate_picture (Gtk::Widget *picture)
    {
      picture->set_rotation (adj->value);
    ...

et la connectez à l'ajustement de l'élément graphique `Scale` ainsi :

    adj.value_changed.connect(sigc::bind<Widget*>(sigc::mem_fun(*this,
        &cb_rotate_picture), picture));

Que se passe-t-il quand un élément graphique reconfigure les champs upper ou lower de son Adjustment, ou bien, quand un utilisateur ajoute du texte dans un élément graphique texte ? Dans ce cas, l'élément graphique émet le signal `changed`.

Les éléments graphiques Range connectent habituellement à ce signal un gestionnaire qui modifie leur apparence pour refléter le changement — par exemple, la taille du curseur dans une barre de défilement va croître ou diminuer en proportion inverse de la différence entre les valeurs lower et upper de son Adjustment.

Vous n'aurez probablement pas besoin d'attacher un gestionnaire à ce signal, sauf si vous écrivez un nouveau type d'élément graphique à plage de réglage.

    adjustment->changed();

## Éléments graphiques sans fenêtre-X

Certains éléments graphiques n'ont pas de fenêtre-X associée ; ils ne sont donc pas capables de recevoir les notifications des événements X. Autrement dit : les signaux décrits au paragraphe Signaux d'événements X ne seront pas émis. Si vous souhaitez capturer des événements pour ces éléments graphiques, vous devez utiliser un conteneur spécial nommé Gtk::EventBox décrit au paragraphe EventBox.

Voici une liste de quelques uns de ces éléments graphiques :

    Gtk::Alignment
    Gtk::Arrow
    Gtk::AspectFrame
    Gtk::Bin
    Gtk::Box
    Gtk::Button
    Gtk::CheckButton
    Gtk::Fixed
    Gtk::Frame
    Gtk::Grid
    Gtk::Image
    Gtk::Label
    Gtk::MenuItem
    Gtk::Notebook
    Gtk::Paned
    Gtk::RadioButton
    Gtk::Range
    Gtk::ScrolledWindow
    Gtk::Separator
    Gtk::Table
    Gtk::Toolbar

Ces éléments graphiques sont essentiellement utilisés pour l'agencement ou la décoration ; la plupart du temps, il ne sera donc pas nécessaire de capturer d'événements sur eux. Ils n'ont pas été pourvus d'une fenêtre-X intentionnellement pour améliorer la performance.

### EventBox

Certains éléments graphiques gtkmm n'ont pas de fenêtre-X associée ; ils sont affichés sur les fenêtres parentes. Pour cette raison, ils ne peuvent pas recevoir d'événements. Ainsi, s'ils ne sont pas correctement dimensionnés, ils ne seront pas rognés : vous observez alors des chevauchements désordonnés, etc. Pour recevoir des événements sur un de ces éléments graphiques, placez-le dans un conteneur EventBox et faites appel ensuite à Gtk::Widget::set_events() sur l'objet EventBox avant de l'afficher.

Même si le nom EventBox met en valeur l'aspect gestion des événements, cet élément graphique peut être utilisé pour la délimitation des contours (ou plus ; voir l'exemple ci-dessous).

Le constructeur d'un objet Gtk::EventBox est :

    Gtk::EventBox();

L'ajout d'un élément graphique enfant à un EventBox s'effectue avec :

    event_box.add(child_widget);

Référence

#### Exemple

L'exemple suivant montre deux utilisations d'un EventBox — création d'une étiquette tronquée dans une petite boîte et configuration pour qu'un clic de souris sur l'étiquette fasse quitter le programme. Le redimensionnement de la fenêtre révèle plus ou moins le contenu de l'étiquette.

EventBox

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      virtual bool on_eventbox_button_press(GdkEventButton* event);

      //Child widgets:
      Gtk::EventBox m_EventBox;
      Gtk::Label m_Label;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_Label("Click here to quit, quit, quit, quit, quit")
    {
      set_title ("EventBox");
      set_border_width(10);

      add(m_EventBox);

      m_EventBox.add(m_Label);

      //Clip the label short:
      m_Label.set_size_request(110, 20);

      //And bind an action to it:
      m_EventBox.set_events(Gdk::BUTTON_PRESS_MASK);
      m_EventBox.signal_button_press_event().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_eventbox_button_press) );

      m_EventBox.set_tooltip_text("Click me!");

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    bool ExampleWindow::on_eventbox_button_press(GdkEventButton*)
    {
      hide();
      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

## Boîtes de dialogue

Les boîtes de dialogue s'utilisent en tant que fenêtres accessoires pour donner des informations particulières ou pour poser des questions. Les fenêtres Gtk::Dialog contiennent des éléments graphiques pré-incorporés pour assurer une certaine cohérence ; elles disposent également d'une fonction membre run() bloquante jusqu'à ce que l'utilisateur ferme la boîte de dialogue.

Il y a plusieurs classes dérivées de Dialog ; vous les trouverez certainement utiles. Gtk::MessageDialog s'utilise pour la plupart des simples notifications. Mais, dans d'autres circonstances, vous aurez besoin de dériver vous-même vos propres classes de boîtes de dialogue pour obtenir des fonctionnalités plus élaborées.

To pack widgets into a custom dialog, you should pack them into the Gtk::Box, available via get_content_area(). To just add a Button to the bottom of the Dialog, you could use the add_button() method.

La fonction membre run() renvoie un entier `int`. C'est une valeur du type `Gtk::ResponseType` si l'utilisateur a fermé la fenêtre en cliquant sur un bouton standard, ou bien la valeur de réponse personnalisée définie lors de l'appel à la fonction membre add_button().

Référence

### Boîte de dialogue Message

MessageDialog est une classe de commodité, utilisée pour créer des boîtes de dialogues destinées à des messages standards simples ; elles comportent un message, une icône et des boutons pour la réponse de l'utilisateur. Vous pouvez définir le type de message et le texte à afficher dans le constructeur, de même que les boutons standards à utiliser par l'intermédiaire de l'énumération `Gtk::ButtonsType`.

Référence

#### Exemple

Boîte de dialogue Message

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_info_clicked();
      void on_button_question_clicked();

      //Child widgets:
      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Info, m_Button_Question;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/messagedialog.h>
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_ButtonBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Info("Show Info MessageDialog"),
      m_Button_Question("Show Question MessageDialog")
    {
      set_title("Gtk::MessageDialog example");

      add(m_ButtonBox);

      m_ButtonBox.pack_start(m_Button_Info);
      m_Button_Info.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_info_clicked) );

      m_ButtonBox.pack_start(m_Button_Question);
      m_Button_Question.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_question_clicked) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_info_clicked()
    {
      Gtk::MessageDialog dialog(*this, "This is an INFO MessageDialog");
      dialog.set_secondary_text(
              "And this is the secondary text that explains things.");

      dialog.run();
    }

    void ExampleWindow::on_button_question_clicked()
    {
      Gtk::MessageDialog dialog(*this, "This is a QUESTION MessageDialog",
              false /* use_markup */, Gtk::MESSAGE_QUESTION,
              Gtk::BUTTONS_OK_CANCEL);
      dialog.set_secondary_text(
              "And this is the secondary text that explains things.");

      int result = dialog.run();

      //Handle the response:
      switch(result)
      {
        case(Gtk::RESPONSE_OK):
        {
          std::cout << "OK clicked." << std::endl;
          break;
        }
        case(Gtk::RESPONSE_CANCEL):
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked." << std::endl;
          break;
        }
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

### Boîte de dialogue Sélection de fichier

La boîte de dialogue de la classe FileChooserDialog convient pour une utilisation avec les éléments de menu « Ouvrir » ou « Enregistrer ».

La plupart des fonctions membres utiles de cette classe sont en fait dans la classe de base Gtk::FileChooser.

Référence

#### Exemple

Boîte de dialogue Sélection de fichier

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_file_clicked();
      void on_button_folder_clicked();

      //Child widgets:
      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_File, m_Button_Folder;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_ButtonBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_File("Choose File"),
      m_Button_Folder("Choose Folder")
    {
      set_title("Gtk::FileSelection example");

      add(m_ButtonBox);

      m_ButtonBox.pack_start(m_Button_File);
      m_Button_File.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_file_clicked) );

      m_ButtonBox.pack_start(m_Button_Folder);
      m_Button_Folder.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_folder_clicked) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_folder_clicked()
    {
      Gtk::FileChooserDialog dialog("Please choose a folder",
              Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
      dialog.set_transient_for(*this);

      //Add response buttons the the dialog:
      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
      dialog.add_button("Select", Gtk::RESPONSE_OK);

      int result = dialog.run();

      //Handle the response:
      switch(result)
      {
        case(Gtk::RESPONSE_OK):
        {
          std::cout << "Select clicked." << std::endl;
          std::cout << "Folder selected: " << dialog.get_filename()
              << std::endl;
          break;
        }
        case(Gtk::RESPONSE_CANCEL):
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked." << std::endl;
          break;
        }
      }
    }

    void ExampleWindow::on_button_file_clicked()
    {
      Gtk::FileChooserDialog dialog("Please choose a file",
              Gtk::FILE_CHOOSER_ACTION_OPEN);
      dialog.set_transient_for(*this);

      //Add response buttons the the dialog:
      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
      dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);

      //Add filters, so that only certain file types can be selected:

      Glib::RefPtr<Gtk::FileFilter> filter_text = Gtk::FileFilter::create();
      filter_text->set_name("Text files");
      filter_text->add_mime_type("text/plain");
      dialog.add_filter(filter_text);

      Glib::RefPtr<Gtk::FileFilter> filter_cpp = Gtk::FileFilter::create();
      filter_cpp->set_name("C/C++ files");
      filter_cpp->add_mime_type("text/x-c");
      filter_cpp->add_mime_type("text/x-c++");
      filter_cpp->add_mime_type("text/x-c-header");
      dialog.add_filter(filter_cpp);

      Glib::RefPtr<Gtk::FileFilter> filter_any = Gtk::FileFilter::create();
      filter_any->set_name("Any files");
      filter_any->add_pattern("*");
      dialog.add_filter(filter_any);

      //Show the dialog and wait for a user response:
      int result = dialog.run();

      //Handle the response:
      switch(result)
      {
        case(Gtk::RESPONSE_OK):
        {
          std::cout << "Open clicked." << std::endl;

          //Notice that this is a std::string, not a Glib::ustring.
          std::string filename = dialog.get_filename();
          std::cout << "File selected: " <<  filename << std::endl;
          break;
        }
        case(Gtk::RESPONSE_CANCEL):
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked." << std::endl;
          break;
        }
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

### Boîte de dialogue Sélection de couleur

The ColorSelectionDialog allows the user to choose a color. The ColorButton opens a color selection dialog when it is clicked.

Référence

#### Exemple

Boîte de dialogue Sélection de couleur

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_color_button_color_set();
      void on_button_dialog_clicked();

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::ColorButton m_ColorButton;
      Gtk::Button m_Button_Dialog;
      Gtk::DrawingArea m_DrawingArea; //To show the color.

      Gdk::RGBA m_Color;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL, 5),
      m_Button_Dialog("Choose Color")
    {
      set_title("Gtk::ColorSelectionDialog example");
      set_default_size(200, 200);

      add(m_VBox);

      m_VBox.pack_start(m_ColorButton, Gtk::PACK_SHRINK);
      m_ColorButton.signal_color_set().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_color_button_color_set) );

      m_VBox.pack_start(m_Button_Dialog, Gtk::PACK_SHRINK);
      m_Button_Dialog.signal_clicked().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_button_dialog_clicked) );

      //Set start color:
      m_Color.set_red(0.0);
      m_Color.set_green(0.0);
      m_Color.set_blue(1.0);
      m_Color.set_alpha(1.0); //opaque
      m_ColorButton.set_rgba(m_Color);

      m_DrawingArea.override_background_color(m_Color);

      m_VBox.pack_start(m_DrawingArea);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_color_button_color_set()
    {
      //Store the chosen color, and show it:
      m_Color = m_ColorButton.get_rgba();
      m_DrawingArea.override_background_color(m_Color);
    }

    void ExampleWindow::on_button_dialog_clicked()
    {
      Gtk::ColorSelectionDialog dialog("Please choose a color");
      dialog.set_transient_for(*this);

      //Get the previously selected color:
      dialog.get_color_selection()->set_current_rgba(m_Color);

      int result = dialog.run();

      //Handle the response:
      switch(result)
      {
        case Gtk::RESPONSE_OK:
        {
          //Store the chosen color, and show it:
          m_Color = dialog.get_color_selection()->get_current_rgba();
          m_ColorButton.set_rgba(m_Color);
          m_DrawingArea.override_background_color(m_Color);
          break;
        }
        case Gtk::RESPONSE_CANCEL:
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked: " << result << std::endl;
          break;
        }
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

### FontChooserDialog

The FontChooserDialog allows the user to choose a font. The FontButton opens a font chooser dialog when it is clicked.

Référence

#### Exemple

FontChooserDialog

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_font_button_font_set();
      void on_button_dialog_clicked();

      //Child widgets:
      Gtk::ButtonBox m_ButtonBox;
      Gtk::FontButton m_FontButton;
      Gtk::Button m_Button_Dialog;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_ButtonBox(Gtk::ORIENTATION_VERTICAL),
      m_FontButton("Sans 10"),
      m_Button_Dialog("Choose Font")
    {
      set_title("Gtk::FontChooserDialog example");

      add(m_ButtonBox);

      m_ButtonBox.pack_start(m_FontButton);
      m_FontButton.set_use_font(true);
      m_FontButton.set_use_size(true);
      m_FontButton.signal_font_set().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_font_button_font_set) );

      m_ButtonBox.pack_start(m_Button_Dialog);
      m_Button_Dialog.signal_clicked().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_button_dialog_clicked) );
      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_font_button_font_set()
    {
      Glib::ustring font_name = m_FontButton.get_font_name();
      std::cout << "Font chosen: " << font_name << std::endl;
    }

    void ExampleWindow::on_button_dialog_clicked()
    {
      Gtk::FontChooserDialog dialog("Please choose a font", *this);

      //Get the previously selected font name from the FontButton:
      dialog.set_font(m_FontButton.get_font_name());

      int result = dialog.run();

      //Handle the response:
      switch(result)
      {
        case Gtk::RESPONSE_OK:
        {
          Glib::ustring font_name = dialog.get_font();
          std::cout << "Font chosen: " << font_name << std::endl;
          m_FontButton.set_font_name(font_name);
          break;
        }
        case Gtk::RESPONSE_CANCEL:
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked: " << result << std::endl;
          break;
        }
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

## L'élément graphique zone de dessin

The DrawingArea widget is a blank window that gives you the freedom to create any graphic you desire. Along with that freedom comes the responsibility to handle draw signals on the widget. When a widget is first shown, or when it is covered and then uncovered again it needs to redraw itself. Most widgets have code to do this, but the DrawingArea does not, allowing you to write your own draw signal handler to determine how the contents of the widget will be drawn. This is most often done by overriding the virtual on_draw() member function.

GTK+ utilise l'API de dessin Cairo. Avec gtkmm, vous pouvez faire usage de l'API C++ pour cairo nommée cairomm.

Avec Cairo, vous pouvez tracer des figures très sophistiquées, mais les fonctions membres pour réaliser cela sont tout à fait simples. Cairo fournit des fonctions membres pour tracer des lignes droites, des lignes courbes et des arcs (y compris des cercles). Ces figures de base peuvent être combinées pour créer des formes complexes et des régions qui peuvent être remplies par des couleurs unies, des dégradés, des motifs et autres choses. En plus, Cairo peut effectuer des transformations complexes, des compositions d'images et effectuer des rendus de texte sans crénelage.

Cairo et Pango

Même si Cairo peut afficher du texte, il n'a pas été conçu pour être un remplaçant de Pango. Pango est un meilleur choix si vous devez exécuter des rendus de texte complexes comme des textes enveloppants ou inscrits dans une ellipse. L'écriture avec Cairo doit être réservée à des textes intégrés dans un graphique.

Dans ce paragraphe du tutoriel, nous voyons le modèle du tracé de base Cairo ; nous décrivons chacun des éléments de tracé de base dans le détail (avec des exemples) et ensuite nous présentons une application simple utilisant Cairo pour dessiner un élément graphique d'horloge analogique.

### Le modèle de tracé Cairo

Le concept de base du tracé dans Cairo consiste à définir des chemins « invisibles », puis à les tracer ou les remplir pour les rendre visibles.

To do any drawing in gtkmm with Cairo, you must first create a Cairo::Context object. This class holds all of the graphics state parameters that describe how drawing is to be done. This includes information such as line width, color, the surface to draw to, and many other things. This allows the actual drawing functions to take fewer arguments to simplify the interface. In gtkmm, a Cairo::Context is created by calling the Gdk::Window::create_cairo_context() function. Since Cairo contexts are reference-counted objects, this function returns a Cairo::RefPtr<Cairo::Context> object.

L'exemple ci-après montre comment définir un contexte Cairo avec une couleur de premier plan rouge et une épaisseur de trait de 2. Toute fonction de tracé se servant de ce contexte utilisera ces réglages.

    Gtk::DrawingArea myArea;
    Cairo::RefPtr<Cairo::Context> myContext = myArea.get_window()->create_cairo_context();
    myContext->set_source_rgb(1.0, 0.0, 0.0);
    myContext->set_line_width(2.0);

Chaque Cairo::Context est associé à une fenêtre Gdk::Window donnée ; ainsi, la première ligne de l'exemple ci-dessus crée un élément graphique Gtk::DrawingArea et la deuxième ligne utilise son objet Gdk::Window associé pour créer un objet Cairo::Context. Les deux dernières lignes modifient les caractéristiques graphiques du contexte.

De nombreuses variables d'état graphique peuvent être définies pour un contexte Cairo. Les attributs les plus courants sont la couleur (avec set_source_rgb() ou set_source_rgba() pour des couleurs transparentes), l'épaisseur du trait (avec set_line_width()), le type de pointillé (avec set_dash()), les bouts de lignes (avec set_line_cap()), les jonctions de lignes (avec set_line_join()) et les styles de polices de caractères (avec set_font_size(), set_font_face() et autres). Il existe beaucoup d'autres réglages : les matrices de transformation, les règles de remplissage, les types d'anti-crénelage, etc. Pour plus d'informations, consultez la documentation de l'API cairomm.

L'état présent d'un Cairo::Context peut être enregistré dans une pile interne de contextes enregistrés et ultérieurement rétablis dans leur état antérieur. Pour réaliser cette opération, utilisez les fonctions membres save() et restore(). Ce processus est utile si vous avez besoin de modifier temporairement l'épaisseur de trait ou la couleur (ou toute autre caractéristique graphique) pour tracer un élément puis revenir aux réglages antérieurs. Dans ce cas, appelez Cairo::Context::save(), modifiez les caractéristiques graphiques, effectuez le tracé, puis appelez Cairo::Context::restore() pour rétablir l'état graphique initial. Des appels multiples à save() et restore() peuvent être imbriqués ; chaque appel à restore() rétablit l'état correspondant à celui qui prévalait lors de l'appel de save().

Il est de bonne pratique de placer toute modification de l'état graphique entre des appels aux fonctions save()/restore(). Par exemple, si vous avez une fonction qui prend en paramètre une référence à un Cairo::Context, vous pouvez l'implémenter comme suit :

    void doSomething(const Cairo::RefPtr<Cairo::Context>& context, int x)
    {
        context->save();
        // change graphics state
        // peform drawing operations
        context->restore();
    }

The virtual on_draw() method provides a Cairo context that you shall use for drawing in the Gtk::DrawingArea widget. It is not necessary to save and restore this Cairo context in on_draw().

### Tracé de droites

Maintenant que nous connaissons les bases de la bibliothèque graphique Cairo, nous voilà prêts pour débuter un tracé. Commençons par le plus simple des éléments de tracé : la droite. Mais d'abord, il est nécessaire d'en savoir un peu plus sur le système de coordonnées de Cairo. L'origine du système de coordonnées de Cairo se situe dans l'angle supérieur gauche de la fenêtre avec les valeurs positives de x vers la droite et de y vers le bas.

Since the Cairo graphics library was written with support for multiple output targets (the X window system, PNG images, OpenGL, etc), there is a distinction between user-space and device-space coordinates. The mapping between these two coordinate systems defaults to one-to-one so that integer values map roughly to pixels on the screen, but this setting can be adjusted if desired. Sometimes it may be useful to scale the coordinates so that the full width and height of a window both range from 0 to 1 (the 'unit square') or some other mapping that works for your application. This can be done with the Cairo::Context::scale() function.

#### Exemple

Dans cet exemple, nous allons écrire un programme gtkmm petit, mais pleinement fonctionnel, et tracer quelques lignes dans la fenêtre. Les lignes sont dessinées en créant un chemin, puis en le traçant. Un tracé est créé avec les fonctions Cairo::Context::move_to() et Cairo::Context::line_to(). La fonction move_to() est semblable à l'action de lever la pointe de votre crayon au dessus du papier et de la placer quelque part ailleurs — aucune ligne n'est tracée entre le point où vous étiez et celui où vous vous êtes déplacé. Pour tracer une ligne entre deux points, utilisez la fonction line_to().

Après avoir terminé la création de votre chemin, vous n'avez encore dessiné rien de visible. Pour rendre le chemin visible, il faut utiliser la fonction stroke() qui dessine le tracé actuel avec une ligne d'épaisseur et de style précisés dans l'objet Cairo::Context. Après le traçage, le chemin actuel est effacé ; vous pouvez donc en débuter un nouveau.

Beaucoup de fonctions de dessin de Cairo disposent d'une variante _preserve(). Normalement, les fonctions de dessin telles que clip(), fill() ou stroke() effacent le chemin actuel. Si vous utilisez la variante _preserve(), le chemin actuel sera préservé de sorte que vous pouvez à nouveau l'utiliser avec une autre fonction de dessin.

Zone de dessin ‑ Lignes

Code source

File: `myarea.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

    protected:
      //Override default signal handler:
      virtual bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr);
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `myarea.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <cairomm/context.h>

    MyArea::MyArea()
    {
    }

    MyArea::~MyArea()
    {
    }

    bool MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      Gtk::Allocation allocation = get_allocation();
      const int width = allocation.get_width();
      const int height = allocation.get_height();

      // coordinates for the center of the window
      int xc, yc;
      xc = width / 2;
      yc = height / 2;

      cr->set_line_width(10.0);

      // draw red lines out from the center of the window
      cr->set_source_rgb(0.8, 0.0, 0.0);
      cr->move_to(0, 0);
      cr->line_to(xc, yc);
      cr->line_to(0, height);
      cr->move_to(xc, yc);
      cr->line_to(width, yc);
      cr->stroke();

      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <gtkmm/main.h>
    #include <gtkmm/window.h>

    int main(int argc, char** argv)
    {
       Gtk::Main kit(argc, argv);

       Gtk::Window win;
       win.set_title("DrawingArea");

       MyArea area;
       win.add(area);
       area.show();

       Gtk::Main::run(win);

       return 0;
    }

This program contains a single class, MyArea, which is a subclass of Gtk::DrawingArea and contains an on_draw() member function. This function is called whenever the image in the drawing area needs to be redrawn. It is passed a Cairo::RefPtr pointer to a Cairo::Context that we use for the drawing. The actual drawing code sets the color we want to use for drawing by using set_source_rgb() which takes arguments defining the Red, Green, and Blue components of the desired color (valid values are between 0 and 1). After setting the color, we created a new path using the functions move_to() and line_to(), and then stroked this path with stroke().

Tracé en coordonnées relatives

Dans l'exemple ci-dessus nous avons tout tracé en utilisant des coordonnées absolues. Nous pouvons également tracer en coordonnées relatives. Pour une droite, on utilise la fonction Cairo::Context::rel_line_to().

#### Styles de trait

En plus du tracé élémentaire de droites, vous pouvez personnaliser un certain nombre de choses dans les tracés de lignes. Nous avons déjà vu des exemples de paramétrage de couleur et d'épaisseur de trait, mais il en existe bien d'autres.

Si vous avez tiré une série de traits formant un chemin, vous pouvez vouloir les raccorder d'une certaine façon. Cairo offre trois façons différentes de raccorder les lignes entre elles : l'onglet, le biseau et l'arrondi. Voyez-les ci-dessous :

Différents types de raccord dans Cairo

Le type de raccord est défini avec la fonction Cairo::Context::set_line_join().

Les fins de ligne peuvent avoir différents styles également. Le style par défaut est de débuter et arrêter la ligne exactement aux points de définition. On nomme cela la coupe droite. Les autres options sont l'arrondi (utilise une terminaison en demi-cercle, le centre du demi-cercle étant au point terminal de la ligne) ou le carré (utilise une terminaison carrée diagonale, le centre du carré étant au point terminal de la ligne). Ce paramétrage est défini avec la fonction Cairo::Context::set_line_cap().

There are other things you can customize as well, including creating dashed lines and other things. For more information, see the Cairo API documentation.

### Tracé de courbes

Outre la possibilité de tracer des droites, Cairo vous permet de tracer facilement des lignes courbes (techniquement une courbe de Bézier d'ordre 3) avec les fonctions Cairo::Context::curve_to() et Cairo::Context::rel_curve_to(). Ces fonctions prennent en paramètres les coordonnées des extrémités ainsi que celles de deux points de « contrôle ». Ce sera plus facile à expliquer sur un exemple, alors lançons-nous.

#### Exemple

Cette simple application trace une courbe avec Cairo et affiche les points de contrôle pour chaque extrémité de la courbe.

Zone de dessin ‑ Lignes

Code source

File: `myarea.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

    protected:
      //Override default signal handler:
      virtual bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr);
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `myarea.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <cairomm/context.h>

    MyArea::MyArea()
    {
    }

    MyArea::~MyArea()
    {
    }

    bool MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      Gtk::Allocation allocation = get_allocation();
      const int width = allocation.get_width();
      const int height = allocation.get_height();

      double x0=0.1, y0=0.5, // start point
             x1=0.4, y1=0.9,  // control point #1
             x2=0.6, y2=0.1,  // control point #2
             x3=0.9, y3=0.5;  // end point

      // scale to unit square (0 to 1 width and height)
      cr->scale(width, height);

      cr->set_line_width(0.05);
      // draw curve
      cr->move_to(x0, y0);
      cr->curve_to(x1, y1, x2, y2, x3, y3);
      cr->stroke();
      // show control points
      cr->set_source_rgba(1, 0.2, 0.2, 0.6);
      cr->move_to(x0, y0);
      cr->line_to (x1, y1);
      cr->move_to(x2, y2);
      cr->line_to (x3, y3);
      cr->stroke();

      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <gtkmm/main.h>
    #include <gtkmm/window.h>

    int main(int argc, char** argv)
    {
       Gtk::Main kit(argc, argv);

       Gtk::Window win;
       win.set_title("DrawingArea");

       MyArea area;
       win.add(area);
       area.show();

       Gtk::Main::run(win);

       return 0;
    }

The only difference between this example and the straight line example is in the on_draw() function, but there are a few new concepts and functions introduced here, so let's examine them briefly.

We make a call to Cairo::Context::scale(), passing in the width and height of the drawing area. This scales the user-space coordinate system such that the width and height of the widget are both equal to 1.0 'units'. There's no particular reason to scale the coordinate system in this case, but sometimes it can make drawing operations easier.

L'appel à Cairo::Context::curve_to() est vraiment explicite en soi. Le premier couple de coordonnées définit le point de contrôle au début de la courbe, le deuxième celui à la fin de la courbe. Le dernier groupe de coordonnées indique les extrémités de la courbe. Pour faire en sorte que le concept des points de contrôle soit plus facile à visualiser, nous avons tracé une droite entre extrémité de la courbe et point de contrôle associé. Notez que ces droites (tangentes aux extrémités de la courbe) sont translucides. Ceci est réalisé à l'aide d'une variante de set_source_rgb() intitulée set_source_rgba(). Cette fonction prend un quatrième argument indiquant le coefficient alpha de la couleur (les valeurs correctes s'échelonnent entre 0 et 1).

### Tracé des arcs et des cercles

With Cairo, the same function is used to draw arcs, circles, or ellipses: Cairo::Context::arc(). This function takes five arguments. The first two are the coordinates of the center point of the arc, the third argument is the radius of the arc, and the final two arguments define the start and end angle of the arc. All angles are defined in radians, so drawing a circle is the same as drawing an arc from 0 to 2 * M_PI radians. An angle of 0 is in the direction of the positive X axis (in user-space). An angle of M_PI/2 radians (90 degrees) is in the direction of the positive Y axis (in user-space). Angles increase in the direction from the positive X axis toward the positive Y axis. So with the default transformation matrix, angles increase in a clockwise direction. (Remember that the positive Y axis points downwards.)

To draw an ellipse, you can scale the current transformation matrix by different amounts in the X and Y directions. For example, to draw an ellipse with center at `x`, `y` and size `width`, `height`:

    context->save();
    context->translate(x, y);
    context->scale(width / 2.0, height / 2.0);
    context->arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI);
    context->restore();

#### Exemple

Voici un exemple de programme simple traçant un arc, un cercle et une ellipse sur une zone de dessin.

Zone de dessin ‑ Arcs

Code source

File: `myarea.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

    protected:
      //Override default signal handler:
      virtual bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr);
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `myarea.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <cairomm/context.h>
    #include <cmath>

    MyArea::MyArea()
    {
    }

    MyArea::~MyArea()
    {
    }

    bool MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      // This is where we draw on the window
      Gtk::Allocation allocation = get_allocation();
      const int width = allocation.get_width();
      const int height = allocation.get_height();
      const int lesser = MIN(width, height);

      // coordinates for the center of the window
      int xc, yc;
      xc = width / 2;
      yc = height / 2;

      cr->set_line_width(lesser * 0.02);  // outline thickness changes
                                          // with window size

      // first draw a simple unclosed arc
      cr->save();
      cr->arc(width / 3.0, height / 4.0, lesser / 4.0, -(M_PI / 5.0), M_PI);
      cr->close_path();   // line back to start point
      cr->set_source_rgb(0.0, 0.8, 0.0);
      cr->fill_preserve();
      cr->restore();  // back to opaque black
      cr->stroke();   // outline it

      // now draw a circle
      cr->save();
      cr->arc(xc, yc, lesser / 4.0, 0.0, 2.0 * M_PI); // full circle
      cr->set_source_rgba(0.0, 0.0, 0.8, 0.6);    // partially translucent
      cr->fill_preserve();
      cr->restore();  // back to opaque black
      cr->stroke();

      // and finally an ellipse
      double ex, ey, ew, eh;
      // center of ellipse
      ex = xc;
      ey = 3.0 * height / 4.0;
      // ellipse dimensions
      ew = 3.0 * width / 4.0;
      eh = height / 3.0;

      cr->save();

      cr->translate(ex, ey);  // make (ex, ey) == (0, 0)
      cr->scale(ew / 2.0, eh / 2.0);  // for width: ew / 2.0 == 1.0
                                      // for height: eh / 2.0 == 1.0

      cr->arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI);  // 'circle' centered at (0, 0)
                                              // with 'radius' of 1.0

      cr->set_source_rgba(0.8, 0.0, 0.0, 0.7);
      cr->fill_preserve();
      cr->restore();  // back to opaque black
      cr->stroke();

      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <gtkmm/main.h>
    #include <gtkmm/window.h>

    int main(int argc, char** argv)
    {
       Gtk::Main kit(argc, argv);

       Gtk::Window win;
       win.set_title("DrawingArea");

       MyArea area;
       win.add(area);
       area.show();

       Gtk::Main::run(win);

       return 0;
    }

There are a couple of things to note about this example code. Again, the only real difference between this example and the previous ones is the on_draw() function, so we'll limit our focus to that function. In addition, the first part of the function is nearly identical to the previous examples, so we'll skip that portion.

Notez que dans ce cas, nous avons pratiquement tout exprimé en termes de hauteur et de largeur de la fenêtre, y compris la largeur des lignes. En raison de cela, quand vous redimensionnez la fenêtre, tous les objets se mettent à l'échelle. Également, il y a trois parties concernant les tracés dans la fonction et chacune est entourée avec une paire save()/restore() pour revenir à un état bien défini après chaque tracé.

La partie concernant le tracé de l'arc comporte une nouvelle fonction : close_path(). Cette fonction a pour effet de provoquer le tracé d'une droite entre le point de fin et de début du tracé. Il y a toutefois une différence significative entre l'appel de close_path() et le tracé à la main d'une ligne jusqu'au point de départ. Si vous utilisez close_path(), les lignes seront proprement jointes. Si vous utilisez line_to() à la place, les lignes se rejoindront, mais Cairo ne fera rien de spécial pour les joindre.

Tracé en sens inverse des aiguilles d'une montre

La fonction Cairo::Context::arc_negative() est identique à Cairo::Context::arc() mais les angles tournent dans le sens opposé.

### Tracé de textes

#### Tracé de texte avec Pango

Text is drawn via Pango Layouts. The easiest way to create a Pango::Layout is to use Gtk::Widget::create_pango_layout(). Once created, the layout can be manipulated in various ways, including changing the text, font, etc. Finally, the layout can be rendered using the Pango::Layout::show_in_cairo_context() method.

The Printing chapter contains an example of drawing text.

### Affichage d'images

There is a method for drawing from a Gdk::Pixbuf to a Cairo::Context. A Gdk::Pixbuf buffer is a useful wrapper around a collection of pixels, which can be read from files, and manipulated in various ways.

La façon la plus courante pour créer un objet Gdk::Pixbuf est d'utiliser la fonction Gdk::Pixbuf::create_from_file(). Elle peut lire un fichier d'image, comme un fichier .png dans un tampon Gdk::Pixbuf prêt à être rendu.

The Gdk::Pixbuf can be rendered by setting it as the source pattern of the Cairo context with Gdk::Cairo::set_source_pixbuf(). Then draw the image with either Cairo::Context::paint() (to draw the whole image), or Cairo::Context::rectangle() and Cairo::Context::fill() (to fill the specified rectangle). set_source_pixbuf() is not a member of Cairo::Context. It takes a Cairo::Context as its first parameter.

Here is a small bit of code to tie it all together: (Note that usually you wouldn't load the image every time in the draw signal handler! It's just shown here to keep it all together.)

    bool MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      Glib::RefPtr<Gdk::Pixbuf> image = Gdk::Pixbuf::create_from_file("myimage.png");
      // Draw the image at 110, 90, except for the outermost 10 pixels.
      Gdk::Cairo::set_source_pixbuf(cr, image, 100, 80);
      cr->rectangle(110, 90, image->get_width()-20, image->get_height()-20);
      cr->fill();
      return true;
    }

#### Exemple

Here is an example of a simple program that draws an image.

Drawing Area - Image

Code source

File: `myarea.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>
    #include <gdkmm/pixbuf.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

    protected:
      //Override default signal handler:
      virtual bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr);

      Glib::RefPtr<Gdk::Pixbuf> m_image;
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `myarea.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <cairomm/context.h>
    #include <gdkmm/general.h> // set_source_pixbuf()
    #include <glibmm/fileutils.h>
    #include <iostream>

    MyArea::MyArea()
    {
      try
      {
        // The fractal image has been created by the XaoS program.
        // http://xaos.sourceforge.net
        m_image = Gdk::Pixbuf::create_from_file("fractal_image.png");
      }
      catch(const Glib::FileError& ex)
      {
        std::cerr << "FileError: " << ex.what() << std::endl;
      }
      catch(const Gdk::PixbufError& ex)
      {
        std::cerr << "PixbufError: " << ex.what() << std::endl;
      }

      // Show at least a quarter of the image.
      if (m_image)
        set_size_request(m_image->get_width()/2, m_image->get_height()/2);
    }

    MyArea::~MyArea()
    {
    }

    bool MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      if (!m_image)
        return false;

      Gtk::Allocation allocation = get_allocation();
      const int width = allocation.get_width();
      const int height = allocation.get_height();

      // Draw the image in the middle of the drawing area, or (if the image is
      // larger than the drawing area) draw the middle part of the image.
      Gdk::Cairo::set_source_pixbuf(cr, m_image,
        (width - m_image->get_width())/2, (height - m_image->get_height())/2);
      cr->paint();

      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <gtkmm/main.h>
    #include <gtkmm/window.h>

    int main(int argc, char** argv)
    {
      Gtk::Main kit(argc, argv);

      Gtk::Window win;
      win.set_title("DrawingArea");
      win.set_default_size(300, 200);

      MyArea area;
      win.add(area);
      area.show();

      Gtk::Main::run(win);

      return 0;
    }

### Exemple d'application : création d'un cadran d'horloge avec Cairo

Maintenant que nous avons vu les fondements du tracé avec Cairo, rassemblons le tout et créons une application simple qui fasse effectivement quelque chose. L'exemple qui suit utilise Cairo pour créer un élément graphique Clock classique. L'horloge dispose d'aiguilles pour les secondes, les minutes et les heures ; elle se met à jour toutes les secondes.

Code source

File: `clock.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_CLOCK_H
    #define GTKMM_EXAMPLE_CLOCK_H

    #include <gtkmm/drawingarea.h>

    class Clock : public Gtk::DrawingArea
    {
    public:
      Clock();
      virtual ~Clock();

    protected:
      //Override default signal handler:
      virtual bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr);

      bool on_timeout();

      double m_radius;
      double m_line_width;

    };

    #endif // GTKMM_EXAMPLE_CLOCK_H

File: `clock.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <ctime>
    #include <cmath>
    #include <cairomm/context.h>
    #include <glibmm/main.h>
    #include "clock.h"

    Clock::Clock()
    : m_radius(0.42), m_line_width(0.05)
    {
      Glib::signal_timeout().connect( sigc::mem_fun(*this, &Clock::on_timeout), 1000 );

      #ifndef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
      //Connect the signal handler if it isn't already a virtual method override:
      signal_draw().connect(sigc::mem_fun(*this, &Clock::on_draw), false);
      #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
    }

    Clock::~Clock()
    {
    }

    bool Clock::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      Gtk::Allocation allocation = get_allocation();
      const int width = allocation.get_width();
      const int height = allocation.get_height();

      // scale to unit square and translate (0, 0) to be (0.5, 0.5), i.e.
      // the center of the window
      cr->scale(width, height);
      cr->translate(0.5, 0.5);
      cr->set_line_width(m_line_width);

      cr->save();
      cr->set_source_rgba(0.337, 0.612, 0.117, 0.9);   // green
      cr->paint();
      cr->restore();
      cr->arc(0, 0, m_radius, 0, 2 * M_PI);
      cr->save();
      cr->set_source_rgba(1.0, 1.0, 1.0, 0.8);
      cr->fill_preserve();
      cr->restore();
      cr->stroke_preserve();
      cr->clip();

      //clock ticks
      for (int i = 0; i < 12; i++)
      {
        double inset = 0.05;

        cr->save();
        cr->set_line_cap(Cairo::LINE_CAP_ROUND);

        if(i % 3 != 0)
        {
          inset *= 0.8;
          cr->set_line_width(0.03);
        }

        cr->move_to(
          (m_radius - inset) * cos (i * M_PI / 6),
          (m_radius - inset) * sin (i * M_PI / 6));
        cr->line_to (
          m_radius * cos (i * M_PI / 6),
          m_radius * sin (i * M_PI / 6));
        cr->stroke();
        cr->restore(); /* stack-pen-size */
      }

      // store the current time
      time_t rawtime;
      time(&rawtime);
      struct tm * timeinfo = localtime (&rawtime);

      // compute the angles of the indicators of our clock
      double minutes = timeinfo->tm_min * M_PI / 30;
      double hours = timeinfo->tm_hour * M_PI / 6;
      double seconds= timeinfo->tm_sec * M_PI / 30;

      cr->save();
      cr->set_line_cap(Cairo::LINE_CAP_ROUND);

      // draw the seconds hand
      cr->save();
      cr->set_line_width(m_line_width / 3);
      cr->set_source_rgba(0.7, 0.7, 0.7, 0.8); // gray
      cr->move_to(0, 0);
      cr->line_to(sin(seconds) * (m_radius * 0.9),
        -cos(seconds) * (m_radius * 0.9));
      cr->stroke();
      cr->restore();

      // draw the minutes hand
      cr->set_source_rgba(0.117, 0.337, 0.612, 0.9);   // blue
      cr->move_to(0, 0);
      cr->line_to(sin(minutes + seconds / 60) * (m_radius * 0.8),
        -cos(minutes + seconds / 60) * (m_radius * 0.8));
      cr->stroke();

      // draw the hours hand
      cr->set_source_rgba(0.337, 0.612, 0.117, 0.9);   // green
      cr->move_to(0, 0);
      cr->line_to(sin(hours + minutes / 12.0) * (m_radius * 0.5),
        -cos(hours + minutes / 12.0) * (m_radius * 0.5));
      cr->stroke();
      cr->restore();

      // draw a little dot in the middle
      cr->arc(0, 0, m_line_width / 3.0, 0, 2 * M_PI);
      cr->fill();

      return true;
    }

    bool Clock::on_timeout()
    {
        // force our program to redraw the entire clock.
        Glib::RefPtr<Gdk::Window> win = get_window();
        if (win)
        {
            Gdk::Rectangle r(0, 0, get_allocation().get_width(),
                    get_allocation().get_height());
            win->invalidate_rect(r, false);
        }
        return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "clock.h"
    #include <gtkmm/main.h>
    #include <gtkmm/window.h>

    int main(int argc, char** argv)
    {
       Gtk::Main kit(argc, argv);

       Gtk::Window win;
       win.set_title("Cairomm Clock");

       Clock c;
       win.add(c);
       c.show();

       Gtk::Main::run(win);

       return 0;
    }

As before, almost all of the interesting stuff is done in the draw signal handler on_draw(). Before we dig into the draw signal handler, notice that the constructor for the Clock widget connects a handler function on_timeout() to a timer with a timeout period of 1000 milliseconds (1 second). This means that on_timeout() will get called once per second. The sole responsibility of this function is to invalidate the window so that gtkmm will be forced to redraw it.

Now let's take a look at the code that performs the actual drawing. The first section of on_draw() should be pretty familiar by now. This example again scales the coordinate system to be a unit square so that it's easier to draw the clock as a percentage of window size so that it will automatically scale when the window size is adjusted. Furthermore, the coordinate system is scaled over and down so that the (0, 0) coordinate is in the very center of the window.

La fonction Cairo::Context::paint() est ici utilisée pour définir la couleur d'arrière-plan de la fenêtre. Cette fonction ne prend aucun paramètre et remplit la surface actuelle (ou la partie tronquée de la surface) avec la couleur source actuellement active. Après avoir défini la couleur de fond, nous traçons un cercle pour délimiter le cadran, le remplissons en blanc et soulignons le pourtour de noir. Notez que ces actions utilisent la variante _preserve pour conserver le chemin en cours, puis ce même chemin est découpé pour s'assurer que nos prochains tracés ne sortiront pas du pourtour du cadran.

Après avoir tracé le pourtour, nous parcourons la circonférence du cadran et traçons des marques pour chaque heure, avec une marque plus importante pour midi, trois, six et neuf heures. Nous sommes maintenant prêts pour implémenter la fonctionnalité horloge de notre cadran : cela consiste à obtenir la valeur actuelle des heures, minutes et secondes et à tracer les aiguilles avec les angles adéquats.

## Glisser-déposer

Gtk::Widget dispose de plusieurs fonctions membres et signaux préfixés par « drag_ » qui sont utilisés pour le glisser-déposer.

### Sources et destinations

Les objets sont glissés à partir de `sources` pour être déposés sur des `destinations`. Chaque source et chaque destination dispose d'informations à propos du format des données qu'elle peut recevoir ou envoyer, informations fournies par les éléments Gtk::TargetEntry. Une destination de dépôt n'accepte un élément glissé que s'ils partagent un élément Gtk::TargetEntry compatible. Les signaux appropriés sont alors émis, indiquant au gestionnaire de signaux le Gtk::TargetEntry qui a été utilisé.

Les objets Gtk::TargetEntry contiennent ces informations :

- cible : un nom, tel que « STRING »

- info : un identifiant envoyé aux signaux pour indiquer quel TargetEntry a été utilisé.

- drapeaux : utilisé seulement pour le glisser-déposer, il indique si les données peuvent être glisser vers d'autres éléments graphiques et applications ou seulement vers les mêmes éléments graphiques.

### Fonctions membres

Les éléments graphiques sont identifiés en tant que sources ou destinations à l'aide des fonctions membres Gtk::Widget suivantes :

    void drag_source_set(const ArrayHandle_TargetEntry& targets,
          GdkModifierType start_button_mask, GdkDragAction actions);

- `targets` est un conteneur pour éléments Gtk::TargetEntry (std::list<Gtk::TargetEntry> ou std::vector<Gtk::TargetEntry>, par exemple).

- `start_button_mask` est une combinaison de valeurs liées avec l'opérateur binaire OR ; ces valeurs définissent quelle touche modificatrice ou quel bouton de souris doit être pressé pour démarrer le glisser.

- `actions` est une combinaison de valeurs liées avec l'opérateur binaire OR ; elle précise les opérations de glisser-déposer possibles à partir de cette source — par exemple, copier, déplacer ou lier. L'utilisateur peut choisir le type d'opérations avec les touches modificatrices ; ainsi, Maj permet de transformer la « `copie` » en « `déplacement` » ; ce changement est indiqué par la modification de la forme du pointeur de souris.

    void drag_dest_set(const ArrayHandle_TargetEntry& targets,
        GtkDestDefaults flags, GdkDragAction actions);

- `flags` est une combinaison de valeurs liées par l'opérateur binaire OR ; cette combinaison indique comment l'élément graphique répond visuellement aux éléments du glisser-déposer.

- `actions` indique les actions de glisser-déposer que cette destination peut accepter — voir la description plus haut.

### Signaux

Quand une destination a accepté un élément glissé, certains signaux vont être émis selon l'action choisie. Par exemple, l'utilisateur peut avoir maintenu enfoncée la touche Maj pour indiquer un `déplacement` plutôt qu'une `copie`. Souvenez-vous que l'utilisateur ne peut sélectionner que les actions définies dans vos appels à drag_dest_set() et drag_source_set().

#### Copie

L'élément graphique source va émettre ces signaux, dans cet ordre :

- `drag_begin` : fournit un objet DragContext.

- `drag_motion` : fournit un objet DragContext et les coordonnées. Vous pouvez appeler la fonction membre drag_status() de l'objet DragContext pour faire savoir les cibles acceptées.

- `drag_get` : fournit un objet `info` concernant le format des données glissées et une structure `GtkSelectionData` dans laquelle vous pouvez mettre les données requises.

- `drag_drop` : fournit un objet DragContext et les coordonnées.

- `drag_end` : fournit un objet DragContext.

L'élément graphique destination émet ce signal après que l'élément source a émis le signal `drag_get` :

- `drag_data_received` : fournit un objet `info` concernant le format des données glissées et une structure `GtkSelectionData` contenant les données déposées. Vous pouvez appeller la fonction membre drag_finish() sur l'objet `DragContext` pour savoir si l'opération a réussi ou non.

#### Déplacement

Pendant un `déplacement`, l'élément graphique source émet également le signal :

- `drag_delete` : offre à la source la possibilité de détruire les données initiales si c'est approprié.

### DragContext

Les signaux de glisser-déposer fournissent un objet DragContext contenant certaines informations à propos de l'opération de glisser-déposer ; ces informations peuvent être utilisées pour influer sur le processus. Par exemple, vous pouvez faire apparaître l'élément graphique source ou modifier l'icône de glisser-déposer avec set_icon(). Plus important, vous pouvez faire appel à la fonction membre drag_finish() dans le gestionnaire du signal `drag_data_received` pour savoir si le dépôt a réussi ou non.

### Exemple

Voici un exemple très simple montrant une opération de glisser-déposer avec `copie` :

Glisser-déposer

Code source

File: `dndwindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_DNDWINDOW_H
    #define GTKMM_EXAMPLE_DNDWINDOW_H

    #include <gtkmm/box.h>
    #include <gtkmm/label.h>
    #include <gtkmm/window.h>
    #include <gtkmm/button.h>

    class DnDWindow : public Gtk::Window
    {

    public:
      DnDWindow();
      virtual ~DnDWindow();

    protected:
      //Signal handlers:
      void on_button_drag_data_get(
              const Glib::RefPtr<Gdk::DragContext>& context,
              Gtk::SelectionData& selection_data, guint info, guint time);
      void on_label_drop_drag_data_received(
              const Glib::RefPtr<Gdk::DragContext>& context, int x, int y,
              const Gtk::SelectionData& selection_data, guint info, guint time);

      //Member widgets:
      Gtk::Box m_HBox;
      Gtk::Button m_Button_Drag;
      Gtk::Label m_Label_Drop;
    };

    #endif // GTKMM_EXAMPLE_DNDWINDOW_H

File: `dndwindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "dndwindow.h"
    #include <iostream>

    DnDWindow::DnDWindow()
    : m_Button_Drag("Drag Here\n"),
      m_Label_Drop("Drop here\n")
    {
      set_title("DnD example");

      add(m_HBox);

      //Targets:
      std::vector<Gtk::TargetEntry> listTargets;
      listTargets.push_back( Gtk::TargetEntry("STRING") );
      listTargets.push_back( Gtk::TargetEntry("text/plain") );

      //Drag site:

      //Make m_Button_Drag a DnD drag source:
      m_Button_Drag.drag_source_set(listTargets);

      //Connect signals:
      m_Button_Drag.signal_drag_data_get().connect(sigc::mem_fun(*this,
                  &DnDWindow::on_button_drag_data_get));

      m_HBox.pack_start(m_Button_Drag);

      //Drop site:

      //Make m_Label_Drop a DnD drop destination:
      m_Label_Drop.drag_dest_set(listTargets);

      //Connect signals:
      m_Label_Drop.signal_drag_data_received().connect(sigc::mem_fun(*this,
                  &DnDWindow::on_label_drop_drag_data_received) );

      m_HBox.pack_start(m_Label_Drop);

      show_all();
    }

    DnDWindow::~DnDWindow()
    {
    }

    void DnDWindow::on_button_drag_data_get(
            const Glib::RefPtr<Gdk::DragContext>&,
            Gtk::SelectionData& selection_data, guint, guint)
    {
      selection_data.set(selection_data.get_target(), 8 /* 8 bits format */,
              (const guchar*)"I'm Data!",
              9 /* the length of I'm Data! in bytes */);
    }

    void DnDWindow::on_label_drop_drag_data_received(
            const Glib::RefPtr<Gdk::DragContext>& context, int, int,
            const Gtk::SelectionData& selection_data, guint, guint time)
    {
      const int length = selection_data.get_length();
      if((length >= 0) && (selection_data.get_format() == 8))
      {
        std::cout << "Received \"" << selection_data.get_data_as_string()
            << "\" in label " << std::endl;
      }

      context->drag_finish(false, false, time);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "dndwindow.h"
    #include <gtkmm/main.h>

    int main (int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      DnDWindow dndWindow;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(dndWindow);

      return 0;
    }

Dans le dossier examples/dnd, vous pouvez trouver un exemple un peu plus élaboré.

## Le presse-papier

La fonctionnalité de copier-coller du texte brut est incorporée par construction pour des éléments graphiques tels que Gtk::Entry et Gtk::TextView, mais vous devez prévoir un code adapté pour faire des échanges dans le cas de vos propres formats de données. Par exemple, un programme de dessin a besoin de code spécialisé pour permettre le copier-coller dans une vue ou entre documents.

L'objet Gtk::Clipboard est un singleton. Vous ne pourrez en obtenir qu'une seule et unique instance avec Gtk::Clipboard::get().

Ainsi votre application n'a pas besoin d'attendre pendant les opérations avec le presse-papier, en particulier, entre le moment où l'utilisateur sélectionne Copier et celui plus tard où il fait Coller ; la plupart des fonctions membres Gtk::Clipboard prennent comme paramètre sigc::slot qui définit les fonctions de rappel. Quand Gtk::Clipboard est prêt, il fait appel à ces fonctions membres, soit pour fournir les données requises, soit pour les demander.

Référence

### Cibles

Diverses applications contiennent divers types de données ; elles peuvent mettre ces données à disposition sous des formats variés. gtkmm appelle ces types de données des « `targets` » (cibles).

Par exemple, gedit peut fournir et recevoir la cible `« UTF8_STRING »` ; vous pouvez donc coller dans gedit des données de toute application fournissant cette cible. Ou bien, deux applications différentes de modification d'images peuvent fournir et recevoir divers formats d'image en tant que cibles. Tant qu'une application peut recevoir une des cibles que l'autre fournit, vous pouvez copier des données de l'une vers l'autre.

Une cible peut se présenter sous des formats binaires divers. Ce chapitre, et ses exemples, supposent que les données sont du texte 8 bits. Cela vous permet d'utiliser un format XML pour les données du presse-papier. Toutefois ce format ne sera certainement pas approprié pour des données binaires comme les images. La classe Gtk::Clipboard autorise des sur-définitions permettant de spécifier le format de façon plus détaillée si nécessaire.

L'API du glisser-déposer utilise les mêmes mécanismes. Vous utiliserez probablement les mêmes formats et cibles de données à la fois pour les opérations avec le presse-papier et pour le glisser-déposer.

### Copie

Quand l'utilisateur demande de copier des données, vous devez indiquer à l'objet Clipboard quelles sont les cibles disponibles et fournir les fonctions de rappel à utiliser pour obtenir les données. À ce stade, vous stockez une copie des données à fournir quand le presse-papier appelle votre fonction de rappel en réponse à un coller.

Par exemple,

    Glib::RefPtr<Gtk::Clipboard> refClipboard = Gtk::Clipboard::get();

    // Cibles :
    std::list<Gtk::TargetEntry> listTargets;
    listTargets.push_back( Gtk::TargetEntry("example_custom_target") );
    listTargets.push_back( Gtk::TargetEntry("UTF8_STRING") );

    refClipboard->set( listTargets,
        sigc::mem_fun(*this, &ExampleWindow::on_clipboard_get),
        sigc::mem_fun(*this, &ExampleWindow::on_clipboard_clear) );

Votre fonction de rappel fournit alors les données enregistrées quand l'utilisateur décide de coller les données. Par exemple :

    void ExampleWindow::on_clipboard_get(
        Gtk::SelectionData& selection_data, guint info)
    {
      const Glib::ustring target = selection_data.get_target();

      if(target == "example_custom_target")
        selection_data.set("example_custom_target", m_ClipboardStore);
    }

L'exemple « `idéal` » ci-après peut fournir plus d'une cible de presse-papier.

La fonction de rappel de nettoyage libère la mémoire utilisée par le stockage de vos données quand le presse-papier remplace ses données par d'autres.

### Coller

Quand l'utilisateur demande à coller des données à partir du Clipboard, vous devez demander un format défini et fournir une fonction de rappel qui est appelée avec les vraies données. Par exemple :

    refClipboard->request_contents("example_custom_target",
        sigc::mem_fun(*this, &ExampleWindow::on_clipboard_received) );

Voici un exemple de fonction de rappel :

    void ExampleWindow::on_clipboard_received(
        const Gtk::SelectionData& selection_data)
    {
      Glib::ustring clipboard_data = selection_data.get_data_as_string();
      // Faire quelque choses avec les données collées.
    }

#### Détermination des cibles admissibles

Pour retrouver quelles sont les cibles actuellement admissibles dans Clipboard pour le collage, appelez la fonction membre request_targets() en indiquant une fonction membre à appeler avec l'information. Par exemple :

    refClipboard->request_targets( sigc::mem_fun(*this,
        &ExampleWindow::on_clipboard_received_targets) );

Dans votre fonction de rappel, comparez la liste des cibles disponibles avec celle des cibles que votre application prend en charge pour le collage. Vous pouvez activer ou désactiver un élément de menu Coller selon que le collage est ou n'est pas actuellement possible. Par exemple :

    void ExampleWindow::on_clipboard_received_targets(
      const Glib::StringArrayHandle& targets_array)
    {
      // Obtenir la liste des cibles disponibles dans le presse-papier :
      std::list<std::string> targets = targets_array;

      const bool bPasteIsPossible =
        std::find(targets.begin(), targets.end(),
          example_target_custom) != targets.end();

      // Activer/désactiver le bouton Coller de manière appropriée :
      m_Button_Paste.set_sensitive(bPasteIsPossible);
    }

### Exemples

#### Simple

Cet exemple permet le copier-coller de données propres à une application, avec une cible texte standard. Il est simple, mais il n'est pas idéal parce qu'il n'identifie pas les données Clipboard comme étant d'un type donné.

Presse-papier - Simple

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_copy();
      void on_button_paste();
      void on_clipboard_text_received(const Glib::ustring& text);

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::Label m_Label;

      Gtk::Table m_Table;
      Gtk::ToggleButton m_ButtonA1, m_ButtonA2, m_ButtonB1, m_ButtonB2;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Copy, m_Button_Paste;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Label("Select cells in the table, click Copy, then open a second "
            "instance of this example to try pasting the copied data."),
      m_Table(2, 2, true),
      m_ButtonA1("A1"), m_ButtonA2("A2"), m_ButtonB1("B1"), m_ButtonB2("B2"),
      m_Button_Copy(Gtk::Stock::COPY), m_Button_Paste(Gtk::Stock::PASTE)
    {
      set_title("Gtk::Clipboard example");
      set_border_width(12);

      add(m_VBox);

      m_VBox.pack_start(m_Label, Gtk::PACK_SHRINK);

      //Fill Table:
      m_VBox.pack_start(m_Table);
      m_Table.attach(m_ButtonA1, 0, 1, 0, 1);
      m_Table.attach(m_ButtonA2, 1, 2, 0, 1);
      m_Table.attach(m_ButtonB1, 0, 1, 1, 2);
      m_Table.attach(m_ButtonB2, 1, 2, 1, 2);

      //Add ButtonBox to bottom:
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);
      m_VBox.set_spacing(6);

      //Fill ButtonBox:
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_ButtonBox.pack_start(m_Button_Copy, Gtk::PACK_SHRINK);
      m_Button_Copy.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_copy) );
      m_ButtonBox.pack_start(m_Button_Paste, Gtk::PACK_SHRINK);
      m_Button_Paste.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_paste) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_copy()
    {
      //Build a string representation of the stuff to be copied:
      //Ideally you would use XML, with an XML parser here:
      Glib::ustring strData;
      strData += m_ButtonA1.get_active() ? "1" : "0";
      strData += m_ButtonA2.get_active() ? "1" : "0";
      strData += m_ButtonB1.get_active() ? "1" : "0";
      strData += m_ButtonB2.get_active() ? "1" : "0";

      Glib::RefPtr<Gtk::Clipboard> refClipboard = Gtk::Clipboard::get();
      refClipboard->set_text(strData);
    }

    void ExampleWindow::on_button_paste()
    {
      //Tell the clipboard to call our method when it is ready:
      Glib::RefPtr<Gtk::Clipboard> refClipboard = Gtk::Clipboard::get();
      refClipboard->request_text(sigc::mem_fun(*this,
                  &ExampleWindow::on_clipboard_text_received) );
    }

    void ExampleWindow::on_clipboard_text_received(const Glib::ustring& text)
    {
      //See comment in on_button_copy() about this silly clipboard format.
      if(text.size() >= 4)
      {
        m_ButtonA1.set_active( text[0] == '1' );
        m_ButtonA2.set_active( text[1] == '1' );
        m_ButtonB1.set_active( text[2] == '1' );
        m_ButtonB2.set_active( text[3] == '1' );
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

#### Idéal

Il est identique à l'exemple simple, mais il

1. définit une cible de presse-papier personnalisée, même si le format de cette cible est toujours du texte,

2. prend en charge le collage de 2 cibles — d'une part la cible personnalisée, d'autre part une cible texte créant un représentation textuelle arbitraire des données personnalisées,

3. utilise request_targets() et le signal `owner_change` et désactive le bouton Coller s'il ne peut pas utiliser les données du presse-papier.

Presse-papier - Idéal

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_copy();
      void on_button_paste();

      void on_clipboard_owner_change(GdkEventOwnerChange* event);
      void on_clipboard_get(Gtk::SelectionData& selection_data, guint info);
      void on_clipboard_clear();

      void on_clipboard_received(const Gtk::SelectionData& selection_data);
      void on_clipboard_received_targets(const Glib::StringArrayHandle& targets_array);

      virtual void update_paste_status(); //Disable the paste button if there is nothing to paste.

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::Label m_Label;

      Gtk::Table m_Table;
      Gtk::ToggleButton m_ButtonA1, m_ButtonA2, m_ButtonB1, m_ButtonB2;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Copy, m_Button_Paste;

      Glib::ustring m_ClipboardStore; //Keep copied stuff here, until it is pasted. This could be a big complex data structure.
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <algorithm>

    namespace
    {

    //These should usually be MIME types.
    const char example_target_custom[] = "gtkmmclipboardexample";
    const char example_target_text[]   = "UTF8_STRING";

    } // anonymous namespace

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Label("Select cells in the table, click Copy, then open a second instance "
              "of this example to try pasting the copied data.\nOr try pasting the "
              "text representation into gedit."),
      m_Table(2, 2, true),
      m_ButtonA1("A1"), m_ButtonA2("A2"), m_ButtonB1("B1"), m_ButtonB2("B2"),
      m_Button_Copy(Gtk::Stock::COPY), m_Button_Paste(Gtk::Stock::PASTE)
    {
      set_title("Gtk::Clipboard example");
      set_border_width(12);

      add(m_VBox);

      m_VBox.pack_start(m_Label, Gtk::PACK_SHRINK);

      //Fill Table:
      m_VBox.pack_start(m_Table);
      m_Table.attach(m_ButtonA1, 0, 1, 0, 1);
      m_Table.attach(m_ButtonA2, 1, 2, 0, 1);
      m_Table.attach(m_ButtonB1, 0, 1, 1, 2);
      m_Table.attach(m_ButtonB2, 1, 2, 1, 2);

      //Add ButtonBox to bottom:
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);
      m_VBox.set_spacing(6);

      //Fill ButtonBox:
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_ButtonBox.pack_start(m_Button_Copy, Gtk::PACK_SHRINK);
      m_Button_Copy.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_copy) );
      m_ButtonBox.pack_start(m_Button_Paste, Gtk::PACK_SHRINK);
      m_Button_Paste.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_paste) );

      //Connect a signal handler that will be called when the contents of
      //the clipboard change.
      Gtk::Clipboard::get()->signal_owner_change().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_clipboard_owner_change) );

      show_all_children();

      update_paste_status();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_copy()
    {
      //Build a string representation of the stuff to be copied:
      //Ideally you would use XML, with an XML parser here:
      Glib::ustring strData;
      strData += m_ButtonA1.get_active() ? "1" : "0";
      strData += m_ButtonA2.get_active() ? "1" : "0";
      strData += m_ButtonB1.get_active() ? "1" : "0";
      strData += m_ButtonB2.get_active() ? "1" : "0";

      Glib::RefPtr<Gtk::Clipboard> refClipboard = Gtk::Clipboard::get();

      //Targets:
      std::vector<Gtk::TargetEntry> listTargets;

      listTargets.push_back( Gtk::TargetEntry(example_target_custom) );
      listTargets.push_back( Gtk::TargetEntry(example_target_text) );

      refClipboard->set(listTargets, sigc::mem_fun(*this,
                  &ExampleWindow::on_clipboard_get), sigc::mem_fun(*this,
                      &ExampleWindow::on_clipboard_clear) );

      //Store the copied data until it is pasted:
      //(Must be done after the call to refClipboard->set, because that call
      //may trigger a call to on_clipboard_clear.)
      m_ClipboardStore = strData;

      update_paste_status();
    }

    void ExampleWindow::on_button_paste()
    {
      //Tell the clipboard to call our method when it is ready:
      Glib::RefPtr<Gtk::Clipboard> refClipboard = Gtk::Clipboard::get();

      refClipboard->request_contents(example_target_custom,
        sigc::mem_fun(*this, &ExampleWindow::on_clipboard_received) );

      update_paste_status();
    }

    void ExampleWindow::on_clipboard_owner_change(GdkEventOwnerChange*)
    {
      update_paste_status();
    }

    void ExampleWindow::on_clipboard_get(Gtk::SelectionData& selection_data, guint)
    {
      //info is meant to indicate the target, but it seems to be always 0,
      //so we use the selection_data's target instead.

      const std::string target = selection_data.get_target();

      if(target == example_target_custom)
      {
        // This set() override uses an 8-bit text format for the data.
        selection_data.set(example_target_custom, m_ClipboardStore);
      }
      else if(target == example_target_text)
      {
        //Build some arbitrary text representation of the data,
        //so that people see something when they paste into a text editor:
        Glib::ustring text_representation;

        text_representation += m_ButtonA1.get_active() ? "A1, " : "";
        text_representation += m_ButtonA2.get_active() ? "A2, " : "";
        text_representation += m_ButtonB1.get_active() ? "B1, " : "";
        text_representation += m_ButtonB2.get_active() ? "B2, " : "";

        selection_data.set_text(text_representation);
      }
      else
      {
        g_warning("ExampleWindow::on_clipboard_get(): "
                "Unexpected clipboard target format.");
      }
    }

    void ExampleWindow::on_clipboard_clear()
    {
      //This isn't really necessary. I guess it might save memory.
      m_ClipboardStore.clear();
    }

    void ExampleWindow::on_clipboard_received(
            const Gtk::SelectionData& selection_data)
    {
      const std::string target = selection_data.get_target();

      //It should always be this, because that' what we asked for when calling
      //request_contents().
      if(target == example_target_custom)
      {
        Glib::ustring clipboard_data = selection_data.get_data_as_string();

        //See comment in on_button_copy() about this silly clipboard format.
        if(clipboard_data.size() >= 4)
        {
          m_ButtonA1.set_active( clipboard_data[0] == '1' );
          m_ButtonA2.set_active( clipboard_data[1] == '1' );
          m_ButtonB1.set_active( clipboard_data[2] == '1' );
          m_ButtonB2.set_active( clipboard_data[3] == '1' );
        }
      }
    }

    void ExampleWindow::update_paste_status()
    {
      //Disable the paste button if there is nothing to paste.

      Glib::RefPtr<Gtk::Clipboard> refClipboard = Gtk::Clipboard::get();

      //Discover what targets are available:
      refClipboard->request_targets(sigc::mem_fun(*this,
                  &ExampleWindow::on_clipboard_received_targets) );
    }

    void ExampleWindow::on_clipboard_received_targets(
      const Glib::StringArrayHandle& targets_array)
    {
      // Get the list of available clipboard targets:
      std::vector<std::string> targets = targets_array;

      const bool bPasteIsPossible =
        std::find(targets.begin(), targets.end(),
          example_target_custom) != targets.end();

      // Enable/Disable the Paste button appropriately:
      m_Button_Paste.set_sensitive(bPasteIsPossible);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

## Impression

Au niveau développement d'une application, l'API impression de gtkmm fournit des boîtes de dialogue cohérentes entre applications et autorise l'API de dessin courant de Cairo avec un moteur de rendu de texte piloté par Pango. Pour l'implémentation courante de cette API, sont utilisés des moteurs de traitement particuliers à la plate-forme et des pilotes d'imprimantes spécifiques au périphérique.

### Objet PrintOperation

L'objet principal est Gtk::PrintOperation, alloué pour chaque opération d'impression. Pour gérer le tracé de la page, il faut se connecter à ses signaux, ou bien créer un objet dérivé et surdéfinir les gestionnaires de signaux virtuels fournis par défaut. PrintOperation gère automatiquement tous les paramètres affectant la boucle d'impression.

#### Signaux

La fonction membre PrintOperation::run() démarre la boucle d'impression au cours de laquelle divers signaux sont émis :

- `begin_print` : vous devez gérer ce signal car c'est à cet instant que vous créez et définissez un objet Pango::Layout en utilisant le Gtk::PrintContext fourni et que vous y divisez la sortie d'impression en plusieurs pages.

- `paginate` : la pagination est en règle générale lente, donc si vous voulez la contrôler, vous pouvez appeler la fonction membre PrintOperation::set_show_progress() et gérer ce signal.

- Pour chaque page devant être imprimée, les signaux suivants sont émis :

  - `request_page_setup` : fournit un objet PrintContext, un numéro de page et un objet Gtk::PageSetup. Gérez ce signal si vous voulez modifier page par page les réglages de la page.

  - `draw_page` : vous devez gérer ce signal qui fournit un objet PrintContext et un numéro de page. L'objet PrintContext sera utilisé pour créer un Cairo::Context dans lequel la page donnée sera dessinée. Pour le rendu du texte, itérez sur le Pango::Layout que vous avez créé dans le gestionnaire du signal `begin_print`.

- `end_print` : un gestionnaire pour ce signal est une place sûre pour libérer les ressources relatives à PrintOperation. Si vous avez une classe personnalisée dérivée de PrintOperation, il est évidemment plus simple de faire cela dans le destructeur.

- `done` : ce signal est émis quand l'impression est terminée, cela signifie que les données de l'impression ont été placées en file d'attente. Notez que la valeur `Gtk::PrintOperationResult` renvoyée peut indiquer qu'une erreur est survenue. Dans tous les cas, vous souhaiterez probablement avertir l'utilisateur du résultat final.

- `status_changed` : ce signal est émis chaque fois que l'état d'une tâche d'impression change jusqu'à ce qu'elle soit terminée. Appelez la fonction membre PrintOperation::set_track_print_status() pour contrôler l'état de la tâche après qu'elle a été placée en file d'attente. Pour afficher l'état, utilisez get_status() ou get_status_string().

Référence

### Mise en page

La classe PrintOperation dispose d'une fonction membre nommée set_default_page_setup() qui choisit par défaut une taille du papier, une orientation et des marges. Pour afficher la boîte de dialogue de mise en page dans l'application, servez-vous de la fonction membre Gtk::run_page_setup_dialog() qui renvoie un objet Gtk::PageSetup avec les réglages choisis. Utilisez cet objet pour mettre à jour un PrintOperation et avoir accès aux variables Gtk::PaperSize, `Gtk::PageOrientation` choisies ainsi qu'aux marges particulières à l'imprimante.

Enregistrez l'objet Gtk::PageSetup avec vos choix, ainsi vous pourrez l'utiliser à nouveau si la boîte de dialogue de mise en page est à nouveau affichée.

Par exemple,

    // Dans une classe dérivée de Gtk::Window
    // avec m_refPageSetup et m_refSettings comme membres...
    Glib::RefPtr<Gtk::PageSetup> new_page_setup = Gtk::run_page_setup_dialog(*this,
                                                          m_refPageSetup, m_refSettings);
    m_refPageSetup = new_page_setup;

Référence

Le système de coordonnées de Cairo, dans le gestionnaire de `draw_page`, est automatiquement tourné selon l'orientation de la page en cours. Il est normalement situé à l'intérieur des marges de l'imprimante, mais vous pouvez modifier ce réglage avec la fonction membre PrintOperation::set_use_full_page(). L'unité de mesure par défaut est le pixel du périphérique. Pour choisir d'autres unités, servez-vous de la fonction membre PrintOperation::set_unit().

### Rendu de texte

Le rendu du texte s'effectue avec Pango. L'objet Pango::Layout pour l'impression est créé en appelant la fonction membre PrintContext::create_pango_layout(). L'objet PrintContext indique également la métrique de la page par l'intermédiaire des fonctions get_width() et get_height(). Le nombre de pages peut être fixé à l'aide de PrintOperation::set_n_pages(). Pour effectuer le rendu effectif du texte Pango dans `on_draw_page`, obtenez un Cairo::Context avec la fonction membre PrintContext::get_cairo_context() et affichez les objets Pango::LayoutLine qui apparaissent dans le nombre de pages demandées.

Pour voir exactement comment réaliser ceci, consultez cet exemple.

### Opérations asynchrones

Par défaut, PrintOperation::run() rend la main quand l'opération d'impression est terminée. Si vous voulez lancer une opération d'impression non-bloquante, appelez PrintOperation::set_allow_async(). Notez que set_allow_async() n'est pas pris en charge sur toutes les plates-formes, bien que le signal `done` soit toujours émis.

Il se peut que la fonction membre run() renvoie `PRINT_OPERATION_RESULT_IN_PROGRESS`. Pour suivre l'état et gérer le résultat ou une erreur, vous devez implémenter des gestionnaires pour les signaux `done` et `status_changed` :

Par exemple,

    // dans la fonction membre de la classe ExampleWindow...
    Glib::RefPtr<PrintOperation> op = PrintOperation::create();
    // ...paramétrer op...
    op->signal_done().connect(sigc::bind(sigc::mem_fun(*this,
                    &ExampleWindow::on_printoperation_done), op));
    // lancer op

Ensuite, vérifiez si une erreur est survenue et connectez le signal `status_changed`. Par exemple :

    void ExampleWindow::on_printoperation_done(Gtk::PrintOperationResult result,
                               const Glib::RefPtr<PrintOperation>& op)
    {
      if (result == Gtk::PRINT_OPERATION_RESULT_ERROR)
        // avertir l'utilisateur
      else if (result == Gtk::PRINT_OPERATION_RESULT_APPLY)
        // mettre à jour PrintSettings avec ceux de cette PrintOperation

      if (! op->is_finished())
        op->signal_status_changed().connect(sigc::bind(sigc::mem_fun(*this,
                  &ExampleWindow::on_printoperation_status_changed), op));
    }

Pour terminer, vérifiez l'état. Par exemple :

    void ExampleWindow::on_printoperation_status_changed(
                const Glib::RefPtr<PrintFormOperation>& op)
    {
      if (op->is_finished())
        // la tâche d'impression est terminée
      else
        // obtenir l'état avec get_status() ou get_status_string()

      // mettre à jour l'UI
    }

### Exportation au format PDF

L'option « Imprimer dans un fichier » est disponible dans la boîte de dialogue d'impression sans qu'il soit nécessaire de réaliser d'autres implémentations. Toutefois, il est quelquefois utile de générer un fichier .pdf directement dans le code. Par exemple,

    Glib::RefPtr<Gtk::PrintOperation> op = Gtk::PrintOperation::create();
    // ...configurer op...
    op->set_export_filename("test.pdf");
    Gtk::PrintOperationResult res = op->run(Gtk::PRINT_OPERATION_ACTION_EXPORT);

### Extension de la boîte de dialogue d'impression

Vous pouvez ajouter un onglet personnalisé à la boîte de dialogue d'impression :

- définissez l'intitulé de l'onglet avec PrintOperation::set_custom_tab_label(), créez un nouvel élément graphique et renvoyez un pointeur sur celui-ci dans le gestionnaire de signal `create_custom_widget`. Vous souhaiterez probablement que ce soit un élément graphique conteneur en empaquetant quelques autres.

- recueillez les données des éléments graphiques dans le gestionnaire de signal `custom_widget_apply`.

Bien que le signal `custom_widget_apply` fournisse un pointeur sur l'élément graphique précédemment créé, pour simplifier les choses, vous pouvez conserver en tant que membres de la classe, les éléments graphiques présumés contenir des entrées utilisateur. Par exemple, disons que nous avons un Gtk::Entry nommé `m_Entry` membre de votre classe CustomPrintOperation :

    Gtk::Widget* CustomPrintOperation::on_create_custom_widget()
    {
      set_custom_tab_label("Onglet personnalisé");

      Gtk::HBox* hbox = new Gtk::HBox(false, 8);
      hbox->set_border_width(6);

      Gtk::Label* label = Gtk::manage(new Gtk::Label("Saisissez du texte : "));
      hbox->pack_start(*label, false, false);
      label->show();

      hbox->pack_start(m_Entry, false, false);
      m_Entry.show();

      return hbox;
    }

    void CustomPrintOperation::on_custom_widget_apply(Gtk::Widget* /* widget */)
    {
      Glib::ustring user_input = m_Entry.get_text();
      //...
    }

L'exemple dans le dossier `examples/book/printing/advanced` démontre cette façon d'opérer.

### Aperçu

La boîte de dialogue d'impression native de GTK+ dispose d'un bouton d'aperçu, mais vous pouvez également lancer l'aperçu directement à partir de l'application :

    // dans une classe qui hérite de Gtk::Window...
    Glib::RefPtr<PrintOperation> op = PrintOperation::create();
    // ...paramétrer op...
    op->run(Gtk::PRINT_OPERATION_ACTION_PREVIEW, *this);

Sous Unix, le gestionnaire d'aperçu par défaut utilise un programme externe de visualisation. Sous Windows, la boîte de dialogue d'aperçu native est affichée. Si nécessaire, vous pouvez surdéfinir ce comportement et fournir une boîte de dialogue d'aperçu personnalisée. Consultez l'exemple dans le dossier `/examples/book/printing/advanced`.

### Exemple

#### Simple

L'exemple suivant montre comment imprimer une saisie à partir d'une interface utilisateur. Il montre comment implémenter `on_begin_print` et `on_draw_page`, de même que suivre l'état de l'impression et mettre à jour les réglages.

Impression - Simple

Code source

File: `printformoperation.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_PRINT_FORM_OPERATION_H
    #define GTKMM_PRINT_FORM_OPERATION_H

    #include <pangomm.h>
    #include <gtkmm.h>
    #include <vector>

    //We derive our own class from PrintOperation,
    //so we can put the actual print implementation here.
    class PrintFormOperation : public Gtk::PrintOperation
    {
     public:
      static Glib::RefPtr<PrintFormOperation> create();
      virtual ~PrintFormOperation();

      void set_name(const Glib::ustring& name) { m_Name = name; }
      void set_comments(const Glib::ustring& comments) { m_Comments = comments; }

     protected:
      PrintFormOperation();

      //PrintOperation default signal handler overrides:
      virtual void on_begin_print(const Glib::RefPtr<Gtk::PrintContext>& context);
      virtual void on_draw_page(const Glib::RefPtr<Gtk::PrintContext>& context, int page_nr);

      Glib::ustring m_Name;
      Glib::ustring m_Comments;
      Glib::RefPtr<Pango::Layout> m_refLayout;
      std::vector<int> m_PageBreaks; // line numbers where a page break occurs
    };

    #endif // GTKMM_PRINT_FORM_OPERATION_H

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <memory>
    #include <vector>

    #include <pangomm.h>
    #include <gtkmm.h>

    class PrintFormOperation;

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      void build_main_menu();

      void print_or_preview(Gtk::PrintOperationAction print_action);

      //PrintOperation signal handlers.
      //We handle these so can get necessary information to update the UI or print settings.
      //Our derived PrintOperation class also overrides some default signal handlers.
      void on_printoperation_status_changed(const Glib::RefPtr<PrintFormOperation>& operation);

      void on_printoperation_done(Gtk::PrintOperationResult result, const Glib::RefPtr<PrintFormOperation>& operation);

      //Action signal handlers:
      void on_menu_file_new();
      void on_menu_file_page_setup();
      void on_menu_file_print_preview();
      void on_menu_file_print();
      void on_menu_file_quit();

      //Printing-related objects:
      Glib::RefPtr<Gtk::PageSetup> m_refPageSetup;
      Glib::RefPtr<Gtk::PrintSettings> m_refSettings;

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Table m_Table;

      Gtk::Label m_NameLabel;
      Gtk::Entry m_NameEntry;

      Gtk::Label m_SurnameLabel;
      Gtk::Entry m_SurnameEntry;

      Gtk::Label m_CommentsLabel;
      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TextView m_TextView;

      Glib::RefPtr<Gtk::TextBuffer> m_refTextBuffer;

      unsigned m_ContextId;
      Gtk::Statusbar m_Statusbar;

      Glib::RefPtr<Gtk::UIManager> m_refUIManager;
      Glib::RefPtr<Gtk::ActionGroup> m_refActionGroup;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `printformoperation.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "printformoperation.h"

    PrintFormOperation::PrintFormOperation()
    {
    }

    PrintFormOperation::~PrintFormOperation()
    {
    }

    Glib::RefPtr<PrintFormOperation> PrintFormOperation::create()
    {
      return Glib::RefPtr<PrintFormOperation>(new PrintFormOperation());
    }

    void PrintFormOperation::on_begin_print(
            const Glib::RefPtr<Gtk::PrintContext>& print_context)
    {
      //Create and set up a Pango layout for PrintData based on the passed
      //PrintContext: We then use this to calculate the number of pages needed, and
      //the lines that are on each page.
      m_refLayout = print_context->create_pango_layout();

      Pango::FontDescription font_desc("sans 12");
      m_refLayout->set_font_description(font_desc);

      const double width = print_context->get_width();
      const double height = print_context->get_height();

      m_refLayout->set_width(static_cast<int>(width * Pango::SCALE));

      //Set and mark up the text to print:
      Glib::ustring marked_up_form_text;
      marked_up_form_text += "<b>Name</b>: " + m_Name + "\n\n";
      marked_up_form_text += "<b>Comments</b>: " + m_Comments;

      m_refLayout->set_markup(marked_up_form_text);

      //Set the number of pages to print by determining the line numbers
      //where page breaks occur:
      const int line_count = m_refLayout->get_line_count();

      Glib::RefPtr<Pango::LayoutLine> layout_line;
      double page_height = 0;

      for (int line = 0; line < line_count; ++line)
      {
        Pango::Rectangle ink_rect, logical_rect;

        layout_line = m_refLayout->get_line(line);
        layout_line->get_extents(ink_rect, logical_rect);

        const double line_height = logical_rect.get_height() / 1024.0;

        if (page_height + line_height > height)
        {
          m_PageBreaks.push_back(line);
          page_height = 0;
        }

        page_height += line_height;
      }

      set_n_pages(m_PageBreaks.size() + 1);
    }

    void PrintFormOperation::on_draw_page(
            const Glib::RefPtr<Gtk::PrintContext>& print_context, int page_nr)
    {
      //Decide which lines we need to print in order to print the specified page:
      int start_page_line = 0;
      int end_page_line = 0;

      if(page_nr == 0)
      {
        start_page_line = 0;
      }
      else
      {
        start_page_line = m_PageBreaks[page_nr - 1];
      }

      if(page_nr < static_cast<int>(m_PageBreaks.size()))
      {
        end_page_line = m_PageBreaks[page_nr];
      }
      else
      {
        end_page_line = m_refLayout->get_line_count();
      }

      //Get a Cairo Context, which is used as a drawing board:
      Cairo::RefPtr<Cairo::Context> cairo_ctx = print_context->get_cairo_context();

      //We'll use black letters:
      cairo_ctx->set_source_rgb(0, 0, 0);

      //Render Pango LayoutLines over the Cairo context:
      Pango::LayoutIter iter = m_refLayout->get_iter();

      double start_pos = 0;
      int line_index = 0;

      do
      {
        if(line_index >= start_page_line)
        {
          Glib::RefPtr<Pango::LayoutLine> layout_line = iter.get_line();
          Pango::Rectangle logical_rect = iter.get_line_logical_extents();
          int baseline = iter.get_baseline();

          if (line_index == start_page_line)
          {
            start_pos = logical_rect.get_y() / 1024.0;
          }

          cairo_ctx->move_to(logical_rect.get_x() / 1024.0,
            baseline / 1024.0 - start_pos);

          layout_line->show_in_cairo_context(cairo_ctx);
        }

        line_index++;
      }
      while(line_index < end_page_line && iter.next_line());
    }

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include "printformoperation.h"

    #include <iostream>

    #include <pangomm.h>

    const Glib::ustring app_title = "gtkmm Printing Example";

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Table(3, 2),
      m_NameLabel("Name"),
      m_SurnameLabel("Surname"),
      m_CommentsLabel("Comments")
    {
      m_refPageSetup = Gtk::PageSetup::create();
      m_refSettings = Gtk::PrintSettings::create();

      m_ContextId = m_Statusbar.get_context_id(app_title);

      set_title(app_title);
      set_default_size(400, 300);

      add(m_VBox);

      build_main_menu();

      m_VBox.pack_start(m_Table);

      //Arrange the widgets inside the table:
      m_Table.attach(m_NameLabel, 0, 1, 0, 1);
      m_Table.attach(m_NameEntry, 1, 2, 0, 1);

      m_Table.attach(m_SurnameLabel, 0, 1, 1, 2, Gtk::SHRINK);
      m_Table.attach(m_SurnameEntry, 1, 2, 1, 2);

      //Add the TreeView, inside a ScrolledWindow:
      m_ScrolledWindow.add(m_TextView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_Table.attach(m_CommentsLabel, 0, 1, 2, 3, Gtk::SHRINK);
      m_Table.attach(m_ScrolledWindow, 1, 2, 2, 3);

      m_refTextBuffer = Gtk::TextBuffer::create();
      m_TextView.set_buffer(m_refTextBuffer);

      m_VBox.pack_start(m_Statusbar);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::build_main_menu()
    {
      //Create actions for menus and toolbars:
      m_refActionGroup = Gtk::ActionGroup::create();

      //File menu:
      m_refActionGroup->add(
        Gtk::Action::create("FileMenu", "_File"));

      m_refActionGroup->add(
        Gtk::Action::create("New", Gtk::Stock::NEW),
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_new));

      m_refActionGroup->add(
        Gtk::Action::create("PageSetup", "Page _Setup"),
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_page_setup));

      m_refActionGroup->add(
        Gtk::Action::create("PrintPreview", "Print Preview"),
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_print_preview));

      m_refActionGroup->add(
        Gtk::Action::create("Print", Gtk::Stock::PRINT),
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_print));

      m_refActionGroup->add(
        Gtk::Action::create("Quit", Gtk::Stock::QUIT),
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_quit));

      m_refUIManager = Gtk::UIManager::create();
      m_refUIManager->insert_action_group(m_refActionGroup);

      add_accel_group(m_refUIManager->get_accel_group());

      //Layout the actions in a menubar and toolbar:

      Glib::ustring ui_info =
            "<ui>"
            "  <menubar name='MenuBar'>"
            "    <menu action='FileMenu'>"
            "      <menuitem action='New'/>"
            "      <menuitem action='PageSetup'/>"
            "      <menuitem action='PrintPreview'/>"
            "      <menuitem action='Print'/>"
            "      <separator/>"
            "      <menuitem action='Quit'/>"
            "    </menu>"
            "  </menubar>"
            "  <toolbar  name='ToolBar'>"
            "    <toolitem action='New'/>"
            "    <toolitem action='Print'/>"
            "      <separator/>"
            "    <toolitem action='Quit'/>"
            "  </toolbar>"
            "</ui>";

      try
      {
        m_refUIManager->add_ui_from_string(ui_info);
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "building menus failed: " << ex.what();
      }

      //Get the menubar and toolbar widgets, and add them to a container widget:
      Gtk::Widget* pMenubar = m_refUIManager->get_widget("/MenuBar");
      if(pMenubar)
        m_VBox.pack_start(*pMenubar, Gtk::PACK_SHRINK);

      Gtk::Widget* pToolbar = m_refUIManager->get_widget("/ToolBar") ;
      if(pToolbar)
        m_VBox.pack_start(*pToolbar, Gtk::PACK_SHRINK);
    }

    void ExampleWindow::on_printoperation_status_changed(
            const Glib::RefPtr<PrintFormOperation>& operation)
    {
      Glib::ustring status_msg;

      if (operation->is_finished())
      {
        status_msg = "Print job completed.";
      }
      else
      {
        //You could also use get_status().
        status_msg = operation->get_status_string();
      }

      m_Statusbar.push(status_msg, m_ContextId);
    }

    void ExampleWindow::on_printoperation_done(Gtk::PrintOperationResult result,
            const Glib::RefPtr<PrintFormOperation>& operation)
    {
      //Printing is "done" when the print data is spooled.

      if (result == Gtk::PRINT_OPERATION_RESULT_ERROR)
      {
        Gtk::MessageDialog err_dialog(*this, "Error printing form", false,
                Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
        err_dialog.run();
      }
      else if (result == Gtk::PRINT_OPERATION_RESULT_APPLY)
      {
        //Update PrintSettings with the ones used in this PrintOperation:
        m_refSettings = operation->get_print_settings();
      }

      if (! operation->is_finished())
      {
        //We will connect to the status-changed signal to track status
        //and update a status bar. In addition, you can, for example,
        //keep a list of active print operations, or provide a progress dialog.
        operation->signal_status_changed().connect(sigc::bind(sigc::mem_fun(*this,
                        &ExampleWindow::on_printoperation_status_changed),
                    operation));
      }
    }

    void ExampleWindow::print_or_preview(Gtk::PrintOperationAction print_action)
    {
      //Create a new PrintOperation with our PageSetup and PrintSettings:
      //(We use our derived PrintOperation class)
      Glib::RefPtr<PrintFormOperation> print = PrintFormOperation::create();

      print->set_name(m_NameEntry.get_text() + " " + m_SurnameEntry.get_text());
      print->set_comments(m_refTextBuffer->get_text(false /*Don't include hidden*/));

      print->set_track_print_status();
      print->set_default_page_setup(m_refPageSetup);
      print->set_print_settings(m_refSettings);

      print->signal_done().connect(sigc::bind(sigc::mem_fun(*this,
                      &ExampleWindow::on_printoperation_done), print));
      try
      {
        print->run(print_action /* print or preview */, *this);
      }
      catch (const Gtk::PrintError& ex)
      {
        //See documentation for exact Gtk::PrintError error codes.
        std::cerr << "An error occurred while trying to run a print operation:"
            << ex.what() << std::endl;
      }
    }

    void ExampleWindow::on_menu_file_new()
    {
      //Clear entries and textview:
      m_NameEntry.set_text("");
      m_SurnameEntry.set_text("");
      m_refTextBuffer->set_text("");
      m_TextView.set_buffer(m_refTextBuffer);
    }

    void ExampleWindow::on_menu_file_page_setup()
    {
      //Show the page setup dialog, asking it to start with the existing settings:
      Glib::RefPtr<Gtk::PageSetup> new_page_setup =
          Gtk::run_page_setup_dialog(*this, m_refPageSetup, m_refSettings);

      //Save the chosen page setup dialog for use when printing, previewing, or
      //showing the page setup dialog again:
      m_refPageSetup = new_page_setup;
    }

    void ExampleWindow::on_menu_file_print_preview()
    {
      print_or_preview(Gtk::PRINT_OPERATION_ACTION_PREVIEW);
    }

    void ExampleWindow::on_menu_file_print()
    {
      print_or_preview(Gtk::PRINT_OPERATION_ACTION_PRINT_DIALOG);
    }

    void ExampleWindow::on_menu_file_quit()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

## Documents récents

gtkmm provides an easy way to manage recently used documents. The classes involved in implementing this functionality are RecentManager, RecentChooserDialog, RecentChooserMenu, RecentChooserWidget, RecentAction, and RecentFilter.

Chaque élément, dans la liste des fichiers récemment utilisés, est identifié par son URI et peut posséder des métadonnées associées. Les métadonnées peuvent être utilisées pour définir la façon dont le fichier doit être affiché, une description du fichier, son type MIME, quelle application l'a enregistré, s'il appartient en propre à l'application qui l'a enregistré et diverses autres informations.

### La classe RecentManager

RecentManager acts as a database of recently used files. You use this class to register new files, remove files from the list, or look up recently used files. There is one list of recently used files per user.

Il est possible de créer une nouvelle classe RecentManager, mais il est plus vraisemblable que vous souhaiterez vous servir de celle par défaut. Vous obtiendrez une référence sur cette dernière avec get_default().

RecentManager is the model of a model-view pattern, where the view is a class that implements the RecentChooser interface.

#### Ajout d'éléments à la liste des fichiers récents

Pour ajouter un nouveau fichier à la liste des documents récents, dans le cas le plus simple, vous n'avez besoin que de fournir l'URI. Par exemple :

    Glib::RefPtr<Gtk::RecentManager> recent_manager = Gtk::RecentManager::get_default();
    recent_manager->add_item(uri);

Si vous voulez enregistrer un fichier avec ses métadonnées, passez un paramètre RecentManager::Data à la fonction membre add_item(). Les métadonnées pouvant être définies sur un élément fichier donné sont :

- `app_exec` : la ligne de commande à utiliser pour atteindre cette ressource. Cette chaîne peut comporter les caractères d'échappement « f » et « u » ; ils seront respectivement développés sous forme du chemin d'accès à la ressource et de l'URI.

- `app_name` : le nom de l'application qui a enregistré la ressource.

- `description` : une courte description de la ressource sous forme d'une chaîne UTF-8.

- `display_name` : le nom de la ressource à utiliser pour l'affichage sous forme d'une chaîne UTF-8.

- `groups` : une liste des groupes associés à cet élément. Les groupes sont essentiellement des dénominations arbitraires associées à des ressources particulières. Ils peuvent être pensés en termes de « catégories » (telles que « courriel », « graphiques ») ou de marqueurs pour la ressource.

- `is_private` : indique si la ressource ne doit être visible que des applications qui l'ont enregistrée ou non.

- `mime_type` : le type MIME de la ressource.

En plus de la possibilité d'intégrer des éléments dans la liste, vous pouvez aussi faire une recherche d'éléments déjà présents dans la liste, les modifier ou les enlever.

#### Examen des éléments de la liste des fichiers récents

To look up recently used files, RecentManager provides several functions. To look up a specific item by its URI, you can use the lookup_item() function, which will return a RecentInfo class. If the specified URI did not exist in the list of recent files, lookup_item() throws a RecentManagerError exception. For example:

    Glib::RefPtr<Gtk::RecentInfo> info;
    try
    {
      info = recent_manager->lookup_item(uri);
    }
    catch(const Gtk::RecentManagerError& ex)
    {
      std::cerr << "RecentManagerError: " << ex.what() << std::endl;
    }
    if (info)
    {
      // item was found
    }

A RecentInfo object is essentially an object containing all of the metadata about a single recently-used file. You can use this object to look up any of the properties listed above.

If you don't want to look for a specific URI, but instead want to get a list of all recently used items, RecentManager provides the get_items() function. The return value of this function is a std::vector of all recently used files. The following code demonstrates how you might get a list of recently used files:

    std::vector< Glib::RefPtr<Gtk::RecentInfo> > info_list = recent_manager->get_items();

The maximum age of items in the recently used files list can be set with Gtk::Settings::property_gtk_recent_files_max_age(). Default value: 30 days.

#### Modification de la liste des fichiers récents

Vous pouvez parfois avoir besoin de modifier la liste des fichiers récents. Par exemple, si un fichier est déplacé ou renommé, vous pouvez mettre à jour l'emplacement ou le nom du fichier dans la liste des fichiers récents pour éviter de pointer vers quelque chose d'incorrect. Vous pouvez mettre à jour l'emplacement d'un élément avec move_item().

In addition to changing a file's URI, you can also remove items from the list, either one at a time or by clearing them all at once. The former is accomplished with remove_item(), the latter with purge_items().

Les fonctions move_item(), remove_item() et purge_items() n'ont aucun effet concret sur les fichiers auxquels les URI se référent ; elles ne font que modifier la liste.

### La classe RecentChooser

RecentChooser is an interface that can be implemented by widgets displaying the list of recently used files. gtkmm provides four built-in implementations for choosing recent files: RecentChooserWidget, RecentChooserDialog, RecentChooserMenu, and RecentAction.

RecentChooserWidget est un simple élément graphique pour un affichage de la liste des fichiers récemment utilisés. RecentChooserWidget est l'élément de base de la classe RecentChooserDialog, mais vous pouvez l'incorporer dans votre interface utilisateur si vous le souhaitez.

RecentChooserMenu and RecentAction allow you to list recently used files as a menu.

#### Simple RecentChooserDialog example

Shown below is a simple example of how to use the RecentChooserDialog and the RecentAction classes in a program. This simple program has a menubar with a Recent Files Dialog menu item. When you select this menu item, a dialog pops up showing the list of recently used files.

À la première utilisation d'un programme se servant de la structure des Fichiers récents, la boîte de dialogue peut initialement être vide. Sinon, elle devrait afficher la liste des documents récemment utilisés enregistrés par d'autres applications.

Après avoir sélectionné l'élément de menu Boîte de dialogue fichiers récents, vous voyez quelque chose de semblable à la fenêtre ci-après.

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_menu_file_recent_files_item();
      void on_menu_file_recent_files_dialog();
      void on_menu_file_quit();
      void on_menu_file_new();

      //Child widgets:
      Gtk::Box m_Box;

      Glib::RefPtr<Gtk::UIManager> m_refUIManager;
      Glib::RefPtr<Gtk::ActionGroup> m_refActionGroup;
      Glib::RefPtr<Gtk::RecentAction> m_refRecentAction;

      Glib::RefPtr<Gtk::RecentManager> m_refRecentManager;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/stock.h>
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_Box(Gtk::ORIENTATION_VERTICAL),
      m_refRecentManager(Gtk::RecentManager::get_default())
    {
      set_title("recent files example");
      set_default_size(200, 200);

      //We can put a MenuBar at the top of the box and other stuff below it.
      add(m_Box);

      //Create actions for menus and toolbars:
      m_refActionGroup = Gtk::ActionGroup::create();

      //File menu:
      m_refActionGroup->add( Gtk::Action::create("FileMenu", "_File") );
      m_refActionGroup->add( Gtk::Action::create("FileNew", Gtk::Stock::NEW),
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_new));

      //A recent-files submenu:
      m_refRecentAction = Gtk::RecentAction::create("FileRecentFiles", "_Recent Files");
      m_refActionGroup->add(m_refRecentAction);
      //Connect to RecentChooser's item_activated signal
      //instead of Action's activate signal:
      m_refRecentAction->signal_item_activated().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_recent_files_item) );

      //A menu item to open the recent-files dialog:
      m_refActionGroup->add( Gtk::Action::create("FileRecentDialog", "Recent Files _Dialog"),
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_recent_files_dialog) );

      m_refActionGroup->add( Gtk::Action::create("FileQuit", Gtk::Stock::QUIT),
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_quit) );

      m_refUIManager = Gtk::UIManager::create();
      m_refUIManager->insert_action_group(m_refActionGroup);

      add_accel_group(m_refUIManager->get_accel_group());

      //Layout the actions in a menubar and toolbar:
      Glib::ustring ui_info =
            "<ui>"
            "  <menubar name='MenuBar'>"
            "    <menu action='FileMenu'>"
            "      <menuitem action='FileNew'/>"
            "      <menuitem action='FileRecentFiles'/>"
            "      <menuitem action='FileRecentDialog'/>"
            "      <separator/>"
            "      <menuitem action='FileQuit'/>"
            "    </menu>"
            "  </menubar>"
            "  <toolbar  name='ToolBar'>"
            "    <toolitem action='FileNew'/>"
            "    <toolitem action='FileQuit'/>"
            "  </toolbar>"
            "</ui>";

      try
      {
        m_refUIManager->add_ui_from_string(ui_info);
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "building menus failed: " <<  ex.what();
      }

      //Get the menubar and toolbar widgets, and add them to a container widget:
      Gtk::Widget* pMenubar = m_refUIManager->get_widget("/MenuBar");
      if(pMenubar)
        m_Box.pack_start(*pMenubar, Gtk::PACK_SHRINK);

      Gtk::Widget* pToolbar = m_refUIManager->get_widget("/ToolBar");
      if(pToolbar)
        m_Box.pack_start(*pToolbar, Gtk::PACK_SHRINK);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_menu_file_new()
    {
      std::cout << " New File" << std::endl;
    }

    void ExampleWindow::on_menu_file_quit()
    {
      hide(); //Closes the main window to stop the Gtk::Main::run().
    }

    void ExampleWindow::on_menu_file_recent_files_item()
    {
      std::cout << "URI selected = " << m_refRecentAction->get_current_uri() << std::endl;
    }

    void ExampleWindow::on_menu_file_recent_files_dialog()
    {
      Gtk::RecentChooserDialog dialog(*this, "Recent Files", m_refRecentManager);
      dialog.add_button("Select File", Gtk::RESPONSE_OK);
      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);

      const int response = dialog.run();
      dialog.hide();
      if(response == Gtk::RESPONSE_OK)
      {
        std::cout << "URI selected = " << dialog.get_current_uri() << std::endl;
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

Le constructeur de ExampleWindow crée le menu en utilisant UIManager (consultez le pour plus d'informations). Ensuite il ajoute le menu et la barre d'outils à la fenêtre.

#### Filtrage des fichiers récents

Pour chacune des classes RecentChooser, si vous ne souhaitez pas afficher tous les éléments de la liste des fichiers récents, vous pouvez filtrer la liste pour ne montrer que ce que vous souhaitez. Vous pouvez filtrer la liste avec l'aide de la classe RecentFilter. Cette classe vous permet de filtrer les fichiers par le nom (add_pattern()), leur type MIME (add_mime_type()), l'application qui les a enregistrés (add_application()) ou par une fonction de filtrage personnalisée (add_custom()). Elle offre aussi la possibilité de filtrer sur la date de dernière modification et sur les groupes dont le fichier fait partie.

Après avoir créé et réglé le filtre pour qu'il corresponde uniquement aux fichiers souhaités, vous pouvez appliquer le filtre à l'élément graphique de sélection avec la fonction RecentChooser::add_filter().

## Greffons et connecteurs

### Aperçu

Parfois, il peut se révéler utile de pouvoir incorporer un élément graphique d'une autre application dans votre propre application. gtkmm permet cela grâce aux classes Gtk::Socket et Gtk::Plug. Il est peu vraisemblable que beaucoup d'applications aient besoin de cette fonctionnalité, mais dans les rares cas où vous auriez besoin d'afficher un élément graphique fonctionnant dans un processus tout à fait différent, ces classes peuvent être d'une grande aide.

La communication entre un objet Socket et un objet Plug s'effectue suivant le protocole XEmbed. Ce protocole a aussi été implémenté dans d'autres boîtes à outils (par exemple, Qt) ; cela permet un niveau d'intégration identique lorsqu'on incorpore un élément graphique Qt dans GTK+ ou vice versa.

Les Sockets et Plugs collaborent par l'intermédiaire des identifiants de leurs fenêtres. Un objet Socket et un objet Plug ont tous deux des ID que l'on peut retrouver avec leurs fonctions membres get_id(). L'utilisation de ces ID sera explicitée plus bas dans la .

#### Connecteurs

Un objet Socket est une sorte d'élément graphique conteneur spécial qui autorise la possibilité d'incorporer des éléments graphiques d'un processus dans un autre de manière totalement transparente pour l'utilisateur.

#### Greffons

Un objet Plug est une variété de fenêtre particulière qu'il est possible de greffer dans un objet Socket. Outre les propriétés et les fonctions membres habituelles de la classe Gtk::Window, l'objet Plug fournit un constructeur qui prend comme paramètre l'ID d'un objet Socket ; l'objet Plug va automatiquement s'incorporer dans l'objet Socket qui a l'ID correspondant.

Comme un objet Plug n'est qu'un type spécial de classe Gtk::Window, vous pouvez lui ajouter des conteneurs ou des éléments graphiques exactement comme vous auriez fait pour une autre fenêtre.

#### Branchement des greffons et des connecteurs

Après la création d'objets Socket ou Plug, vous pouvez obtenir leur ID avec la fonction get_id(). Cet ID peut ensuite être partagé avec d'autres processus afin que ces processus sachent comment se connecter les uns aux autres.

Il y a deux stratégies de base utilisables :

- créer un objet Socket dans un processus et passer l'ID de ce Socket à un autre processus pour qu'il puisse créer un objet Plug en précisant ledit ID du Socket dans son constructeur. Il n'est pas possible d'attribuer un Plug à un Socket après sa création, il faut donc transmettre l'ID du Socket au constructeur du Plug.

- créer un objet Plug de manière indépendante de tout Socket particulier et passer l'ID du Plug aux processus qui souhaitent l'utiliser. L'ID de l'objet Plug peut être associé à un objet Socket donné avec la fonction Socket::add_id(). C'est l'approche utilisée dans l'exemple qui suit.

### Exemple greffons et connecteurs

L'exemple suivant est une utilisation simple de greffons et connecteurs. La fonction membre de communication entre processus est volontairement sommaire : l'objet Plug écrit son ID dans un fichier texte nommé `plug.id` et le processus avec le connecteur lit cet ID à partir de ce fichier. Dans un « vrai » programme, vous utiliseriez certainement des fonctions membres de communication entre processus plus perfectionnées.

Code source

File: `socket.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include <fstream>
    #include <gtkmm.h>
    #include <gtkmm/socket.h>

    using namespace std;

    const char* id_filename = "plug.id";

    void plug_added()
    {
      cout << "A plug was added" << endl;
    }

    bool plug_removed()
    {
      cout << "A Plug was removed" << endl;
      return true;
    }

    class MySocketWindow : public Gtk::Window
    {
      public:
        MySocketWindow()
        {
          ifstream infile(id_filename);
          if (infile)
          {
            Gtk::Socket* socket = Gtk::manage(new Gtk::Socket());
            add(*socket);
            socket->signal_plug_added().connect(sigc::ptr_fun(plug_added));
            socket->signal_plug_removed().connect(sigc::ptr_fun(plug_removed));
            ::Window plug_id = 0;
            infile >> plug_id;
            infile.close();
            socket->add_id(plug_id);
          }
          else
          {
            Gtk::Label* label = Gtk::manage(
                new Gtk::Label(
                  "Plug id file not found.\n Make sure plug is running."));
            add(*label);
            set_size_request(150, 50);
          }
          show_all();
        }
    };

    int main(int argc, char** argv)
    {
      Gtk::Main app(argc, argv);
      MySocketWindow win;
      app.run(win);
      return 0;
    }

File: `plug.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include <fstream>
    #include <gtkmm.h>
    #include <gtkmm/plug.h>
    #include <glib/gstdio.h>

    using namespace std;

    const char* id_filename = "plug.id";

    void on_embed()
    {
      cout << "I've been embedded." << endl;
    }

    class MyPlug : public Gtk::Plug
    {
      public:
        MyPlug() :
          m_label("I am the plug")
      {
        set_size_request(150, 100);
        add(m_label);
        signal_embedded().connect(sigc::ptr_fun(on_embed));
        show_all();
      }

      private:
        Gtk::Label m_label;
    };

    int main(int argc, char** argv)
    {
      Gtk::Main app(argc, argv);
      MyPlug plug;

      ofstream out(id_filename);
      out << plug.get_id();
      out.close();
      cout << "The window ID is: " << plug.get_id() << endl;

      app.run(plug);

      // remove the ID file when the program exits
      g_remove(id_filename);
      return 0;
    }

Cet exemple crée deux exécutables : `socket` et `plug`. L'idée est que `socket` ait une fenêtre d'application qui accueille un élément graphique issu du programme `plug`. Compte tenu de la manière dont cet exemple est conçu, `plug` doit être lancé avant que `socket` ne démarre. Pour voir cet exemple en action, exécutez les commandes suivantes dans l'ordre indiqué à partir du répertoire de l'exemple :

Lancez le programme `plug` et envoyez-le en arrière-plan (ou simplement utilisez un terminal différent) :

    $ ./plug &

Après cette action, vous devriez voir s'afficher :

    The window ID is: 69206019

puis lancez le programme `socket` :

    $ ./socket

Après avoir lancé `socket`, vous devriez voir les sorties suivantes sur le terminal :

    I've been embedded.
    A plug was added

La première ligne correspond à la sortie du programme `plug`, après qu'il a reçu notification qu'il a été incorporé dans l'objet Socket. La deuxième ligne a été émise par l'objet `socket` en réponse au signal plug_added. Si tout a été effectuée comme indiqué ci-dessus, la fenêtre `socket` doit ressembler grosso modo à quelque chose comme :

Si, pour une quelconque raison, l'objet Socket ne peut pas recevoir l'objet Plug, la fenêtre ressemblera à :

## Keyboard Events

X events differ in some ways from other signals. These differences are described in the X Event signals section in the appendix. Here we will use keyboard events to show how X events can be used in a program.

### Aperçu

Whenever you press or release a key, an event is emitted. You can connect a signal handler to handle such events.

To receive the keyboard events, you must first call the Gtk::Widget::add_events() function with a bit mask of the events you're interested in. The event signal handler will receive an argument that depends on the type of event. For keyboard events it's a GdkEventKey*. As discribed in the appendix, the event signal handler returns a bool value, to indicate that the signal is fully handled (`true`) or allow event propagation (`false`).

To determine which key was pressed or released, you read the value of `GdkEventKey::keyval` and compare it with a constant in the `<gdk/gdkkeysyms.h>` header file. The states of modifier keys (shift, ctrl, etc.) are available as bit-flags in `GdkEventKey::state`.

Voici un exemple simple :

    bool on_key_press_or_release_event(GdkEventKey* event)
    {
      if (event->type == GDK_KEY_PRESS &&
        event->keyval == GDK_KEY_1 &&
        (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK)) == GDK_MOD1_MASK)
      {
        handle_alt_1_press(); // GDK_MOD1_MASK is normally the Alt key
        return true;
      }
      return false;
    }

    Gtk::Entry m_entry; // in a class definition

    // in the class constructor
    m_entry.signal_key_press_event().connect( sigc::ptr_fun(&on_key_press_or_release_event) );
    m_entry.signal_key_release_event().connect( sigc::ptr_fun(&on_key_press_or_release_event) );
    m_entry.add_events(Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK);

#### Exemple

In this example there are three keyboard shortcuts: Alt+1 selects the first radio button, Alt+2 selects the second one, and the Esc key hides (closes) the window.

Keyboard Events - Simple

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:

      ExampleWindow();
      virtual ~ExampleWindow();

    private:
      bool on_key_press_event(GdkEventKey *event);

      Gtk::Grid m_container;
      Gtk::RadioButton m_first;
      Gtk::RadioButton m_second;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    {
      set_title("Keyboard Events");
      set_border_width(10);
      add(m_container);

      // Radio buttons:
      m_first.set_label("First");
      m_second.set_label("Second");

      Gtk::RadioButton::Group group = m_first.get_group();
      m_second.set_group(group);
      m_first.set_active();

      // Main Container:
      m_container.add(m_first);
      m_container.add(m_second);

      // Events
      add_events(Gdk::KEY_PRESS_MASK);
      signal_key_press_event().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_key_press_event));

      show_all_children();
    }

    bool ExampleWindow::on_key_press_event(GdkEventKey *event)
    {
      //GDK_MOD1_MASK -> the 'alt' key(mask)
      //GDK_KEY_1 -> the '1' key
      //GDK_KEY_2 -> the '2' key

      //select the first radio button, when we press alt + 1
      if((event->keyval == GDK_KEY_1) &&
        (event->state &(GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK)) == GDK_MOD1_MASK)
      {
        m_first.set_active();
      }
      else if((event->keyval == GDK_KEY_2) &&
        (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK)) == GDK_MOD1_MASK)
      {
        //and the second radio button, when we press alt + 2
        m_second.set_active();
      }
      else if(event->keyval == GDK_KEY_Escape)
      {
        //close the window, when the 'esc' key is pressed
        hide();
      }

      //returning true, cancels the propagation of the event
      return true;
    }

    ExampleWindow::~ExampleWindow()
    {
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

### Event Propagation

Event propagation means that, when an event is emitted on a particular widget, it can be passed to its parent widget (and that widget can pass it to its parent, and so on) and, if the parent has an event handler, that handler will be called.

The event will propagate until it reaches the top-level widget, or until you stop the propagation by returning `true` from an event handler.

Notice, that after canceling an event, no other function will be called (even if it is from the same widget).

#### Exemple

In this example there are three event handlers, one in the Gtk::Entry, one in the Gtk::Grid and one in the Gtk::Window.

When you write in the entry, a key release event will be emitted first in the Entry and, depending on whether we let it propagate, it can reach the Grid's and the Window's event handlers. If it propagates, the text you're writing will appear in the Label above the Entry.

Keyboard Events - Event Propagation

Code source

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EVENT_PROPAGATION_H
    #define GTKMM_EVENT_PROPAGATION_H

    #include <gtkmm.h>
    #include <iostream>

    class ExampleWindow : public Gtk::Window
    {
    public:

      ExampleWindow();
      virtual ~ExampleWindow();

    private:

      bool entryKeyRelease(GdkEventKey *event);
      bool gridKeyRelease(GdkEventKey *event);
      bool windowKeyRelease(GdkEventKey *event);

      Gtk::Grid m_container;

      Gtk::Label m_label;
      Gtk::Entry m_entry;
      Gtk::CheckButton m_checkbutton_can_propagate;
    };

    #endif //GTKMM_EVENT_PROPAGATION_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    {
      add(m_container);
      set_title("Event Propagation");
      set_border_width(10);

      m_label.set_label("A label");
      m_checkbutton_can_propagate.set_label("Can Propagate");
      m_checkbutton_can_propagate.set_active();

      // Main Container
      m_container.set_orientation(Gtk::ORIENTATION_VERTICAL);
      m_container.add(m_label);
      m_container.add(m_entry);
      m_container.add(m_checkbutton_can_propagate);

      // Events
      add_events(Gdk::KEY_RELEASE_MASK);

      m_entry.signal_key_release_event().connect(
        sigc::mem_fun(*this, &ExampleWindow::entryKeyRelease));

      m_container.signal_key_release_event().connect(
        sigc::mem_fun(*this, &ExampleWindow::gridKeyRelease));

      signal_key_release_event().connect(
        sigc::mem_fun(*this, &ExampleWindow::windowKeyRelease));

      show_all_children();
    }

    //By changing the return value we allow, or don't allow, the event to propagate to other elements.
    bool ExampleWindow::entryKeyRelease(GdkEventKey* /* event */ )
    {
      std::cout << "Entry" << std::endl;

      if(m_checkbutton_can_propagate.get_active())
      {
        return false;
      }

      return true;
    }

    bool ExampleWindow::gridKeyRelease(GdkEventKey* /* event */ )
    {
      std::cout << "Grid" << std::endl;

      //Let it propagate:
      return false;
    }

    // This will set the entry's text in the label, every time a key is pressed.
    bool ExampleWindow::windowKeyRelease(GdkEventKey* /* event */ )
    {
      std::cout << "Window" << std::endl;

      //checking if the entry is on focus, otherwise the label would get changed by pressing keys
      //on the window (when the entry is not on focus), even if canPropagate wasn't active
      if(m_entry.has_focus())
      {
        m_label.set_text(m_entry.get_text());
      }

      return true;
    }

    ExampleWindow::~ExampleWindow()
    {
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

## Fonctions à délai échu, d'entrées/sorties et de temporisation

### Fonctions à délai échu

Peut-être vous demandez-vous comment faire en sorte que gtkmm fasse un travail utile pendant sa période d'inactivité (disons, de sommeil en fait) dans la boucle Gtk::Main::run(). Il y a heureusement plusieurs possibilités pour cela. En utilisant les fonctions membres suivantes, vous pouvez créer une fonction à délai échu ; elle sera régulièrement appelée avec une périodicité de quelques millisecondes.

    sigc::connection Glib::SignalTimeout::connect(
                             const sigc::slot<bool>& slot,
                             unsigned int interval,
                             int priority = Glib::PRIORITY_DEFAULT);

Le premier paramètre est un objet slot appelé quand le délai est échu. Le deuxième argument est le nombre de millisecondes entre chaque appel de la fonction. Vous recevez en retour un objet sigc::connection qu'il est possible d'utiliser pour désactiver la connexion à l'aide de sa fonction membre disconnect() :

    my_connection.disconnect();

L'autre façon d'interrompre la connexion est fournie par le gestionnaire de signal qui doit être du type sigc::slot<bool>.Comme vous le voyez dans la définition, le gestionnaire de signal doit renvoyer une valeur du type `bool`. Une définition d'une fonction exemple pourrait ressembler à quelque chose comme :

    bool MyCallback() { std::cout << "Hello World!\n" << std::endl; return true; }

Vous pouvez arrêter l'appel périodique de la fonction en renvoyant `false` à partir du gestionnaire de signal. Mais si vous voulez que la fonction soit réitérée, il faut qu'elle renvoie `true`.

Voici un exemple de cette technique :

Code source

File: `timerexample.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_TIMEREXAMPLE_H
    #define GTKMM_EXAMPLE_TIMEREXAMPLE_H

    #include <gtkmm.h>
    #include <iostream>
    #include <map>

    class TimerExample : public Gtk::Window
    {
    public:
      TimerExample();

    protected:
      // signal handlers
      void on_button_add_timer();
      void on_button_delete_timer();
      void on_button_quit();

      // This is the callback function the timeout will call
      bool on_timeout(int timer_number);

      // Member data:

      Gtk::Box m_Box;
      Gtk::Button m_ButtonAddTimer, m_ButtonDeleteTimer, m_ButtonQuit;

      // Keep track of the timers being added:
      int m_timer_number;

      // These two constants are initialized in the constructor's member initializer:
      const int count_value;
      const int timeout_value;

      // STL map for storing our connections
      std::map<int, sigc::connection> m_timers;

      // STL map for storing our timer values.
      // Each timer counts back from COUNT_VALUE to 0 and is removed when it reaches 0
      std::map<int, int> m_counters;
    };

    #endif // GTKMM_EXAMPLE_TIMEREXAMPLE_H

File: `timerexample.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "timerexample.h"

    TimerExample::TimerExample() :
      m_Box(Gtk::ORIENTATION_HORIZONTAL, 10),
        // use Gtk::Stock wherever possible for buttons, etc.
      m_ButtonAddTimer(Gtk::Stock::ADD),
      m_ButtonDeleteTimer(Gtk::Stock::REMOVE),
      m_ButtonQuit(Gtk::Stock::QUIT),
      m_timer_number(0), // start numbering the timers at 0
      count_value(5), // each timer will count down 5 times before disconnecting
      timeout_value(1500) // 1500 ms = 1.5 seconds
    {
      set_border_width(10);

      add(m_Box);
      m_Box.pack_start(m_ButtonAddTimer);
      m_Box.pack_start(m_ButtonDeleteTimer);
      m_Box.pack_start(m_ButtonQuit);

      // Connect the three buttons:
      m_ButtonQuit.signal_clicked().connect(sigc::mem_fun(*this,
                  &TimerExample::on_button_quit));
      m_ButtonAddTimer.signal_clicked().connect(sigc::mem_fun(*this,
                  &TimerExample::on_button_add_timer));
      m_ButtonDeleteTimer.signal_clicked().connect(sigc::mem_fun(*this,
                  &TimerExample::on_button_delete_timer));

      show_all_children();
    }

    void TimerExample::on_button_quit()
    {
      hide();
    }

    void TimerExample::on_button_add_timer()
    {
      // Creation of a new object prevents long lines and shows us a little
      // how slots work.  We have 0 parameters and bool as a return value
      // after calling sigc::bind.
      sigc::slot<bool> my_slot = sigc::bind(sigc::mem_fun(*this,
                  &TimerExample::on_timeout), m_timer_number);

      // This is where we connect the slot to the Glib::signal_timeout()
      sigc::connection conn = Glib::signal_timeout().connect(my_slot,
              timeout_value);

      // Remember the connection:
      m_timers[m_timer_number] = conn;

      // Initialize timer count:
      m_counters[m_timer_number] = count_value + 1;

      // Print some info to the console for the user:
      std::cout << "added timeout " << m_timer_number++ << std::endl;
    }

    void TimerExample::on_button_delete_timer()
    {
      // any timers?
      if(m_timers.empty())
      {
        // no timers left
        std::cout << "Sorry, there are no timers left." << std::endl;
      }
      else
      {
        // get the number of the first timer
        int timer_number = m_timers.begin()->first;

        // Give some info to the user:
        std::cout << "manually disconnecting timer " << timer_number
            << std::endl;

        // Remove the entry in the counter values
        m_counters.erase(timer_number);

        // Diconnect the signal handler:
        m_timers[timer_number].disconnect();

        // Forget the connection:
        m_timers.erase(timer_number);
      }
    }

    bool TimerExample::on_timeout(int timer_number)
    {
      // Print the timer:
      std::cout << "This is timer " << timer_number;

      // decrement and check counter value
      if (--m_counters[timer_number] == 0)
      {
        std::cout << " being disconnected" <<  std::endl;

        // delete the counter entry in the STL MAP
        m_counters.erase(timer_number);

        // delete the connection entry in the STL MAP
        m_timers.erase(timer_number);

        // Note that we do not have to explicitly call disconnect() on the
        // connection since Gtk::Main does this for us when we return false.
        return false;
      }

      // Print the timer value
      std::cout << " - " << m_counters[timer_number] << "/"
          << count_value << std::endl;

     // Keep going (do not disconnect yet):
      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "timerexample.h"
    #include <gtkmm/main.h>

    int main (int argc, char *argv[])
    {
      Gtk::Main app(argc, argv);

      TimerExample example;
      Gtk::Main::run(example);

      return 0;
    }

### Fonctions de contrôle des entrées/sorties

Une des caractéristiques intéressantes de GLib (une des bibliothèques sous-jacentes à gtkmm) est la possibilité de demander la vérification des données d'un descripteur de fichier à votre intention. La chose est particulièrement utile pour les applications réseau. Pour cette vérification, vous utilisez la fonction membre :

    sigc::connection Glib::SignalInput::connect(
                 const sigc::slot<bool,Glib::IOCondition>& slot,
                 int fd,
                 Glib::IOCondition condition,
                 int priority = Glib::PRIORITY_DEFAULT);

Le premier paramètre est un connecteur qui est sollicité quand survient, sur le descripteur de fichier précisé en second paramètre, l'événement indiqué en troisième paramètre. Ce dernier définit une valeur ou plusieurs (liées avec `|`) parmi les suivantes :

- Glib::IO_IN - appelle la fonction membre quand il y a des données prêtes en lecture dans le descripteur de fichier.

- Glib::IO_OUT - appelle la fonction membre quand le descripteur de fichier est prêt pour l'écriture.

- Glib::IO_PRI - appelle la fonction membre quand le descripteur de fichier a des données à lire d'urgence.

- Glib::IO_ERR - appelle la fonction membre quand une erreur est arrivée sur le descripteur de fichier.

- Glib::IO_HUP - appelle la fonction membre quand il y a une interruption (la connexion a été interrompue généralement pour les tubes et les connecteurs).

La valeur de retour qui est du type sigc::connection peut être utilisée pour arrêter le contrôle sur ce descripteur de fichier avec la fonction membre disconnect(). Le gestionnaire de signal de slot doit être déclaré comme suit :

    bool input_callback(Glib::IOCondition condition);

où le paramètre condition est tel que précisé ci-dessus. Comme d'habitude, le connecteur est créé avec `sigc::mem_fun()` (pour une fonction membre d'un objet) ou `sigc::ptr_fun()` (pour une fonction).

Un petit exemple suit. Pour vous servir de cet exemple, lancez-le à partir d'un terminal ; il ne crée pas de fenêtre. Il va créer un tube nommé `testfifo` dans le répertoire actuel. Puis, lancez un autre instance de terminal et saisissez `echo "Hello" > testfifo`. Le terminal de l'exemple affiche chaque ligne saisie dans l'autre instance jusqu'à ce que vous saisissiez `echo "Q" > testfifo`.

Code source

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <build/config.h>
    #include <gtkmm/main.h>
    #include <glibmm/main.h>
    #include <glibmm/iochannel.h>
    #include <fcntl.h>
    #include <iostream>

    #include <unistd.h> //The SUN Forte compiler puts F_OK here.

    //The SUN Forte compiler needs these for mkfifo:
    #include <sys/types.h>
    #include <sys/stat.h>

    int read_fd;
    Glib::RefPtr<Glib::IOChannel> iochannel;

    /*
      send to the fifo with:
      echo "Hello" > testfifo

      quit the program with:
      echo "Q" > testfifo
    */

    // this will be our signal handler for read operations
    // it will print out the message sent to the fifo
    // and quit the program if the message was 'Q'.
    bool MyCallback(Glib::IOCondition io_condition)
    {

      if ((io_condition & Glib::IO_IN) == 0) {
        std::cerr << "Invalid fifo response" << std::endl;
      }
      else {
       Glib::ustring buf;

       iochannel->read_line(buf);
       std::cout << buf;
       if (buf == "Q\n")
           Gtk::Main::quit ();

      }
      return true;
    }

    int main(int argc, char *argv[])
    {
      // the usual Gtk::Main object
      Gtk::Main app(argc, argv);

      if (access("testfifo", F_OK) == -1) {
        // fifo doesn't exit - create it
        #ifdef HAVE_MKFIFO
        if (mkfifo("testfifo", 0666) != 0) {
          std::cerr << "error creating fifo" << std::endl;
          return -1;
        }
        #else
          std::cerr << "error creating fifo: This platform does not have mkfifo()"
              << std::endl;
        #endif //HAVE_MKFIFO
      }

      read_fd = open("testfifo", O_RDONLY);
      if (read_fd == -1)
      {
        std::cerr << "error opening fifo" << std::endl;
        return -1;
      }

      // connect the signal handler
      Glib::signal_io().connect(sigc::ptr_fun(MyCallback), read_fd, Glib::IO_IN);

      // Creates a iochannel from the file descriptor
      iochannel = Glib::IOChannel::create_from_fd(read_fd);

      // and last but not least - run the application main loop
      app.run();

      // now remove the temporary fifo
      if(unlink("testfifo"))
        std::cerr << "error removing fifo" << std::endl;

      return 0;
    }

### Fonctions de temporisation

Si vous voulez définir une fonction membre appelée quand il n'y aucune autre activité en cours, utilisez :

    sigc::connection  Glib::SignalIdle::connect(
                          const sigc::slot<bool>& slot,
                          int priority = Glib::PRIORITY_DEFAULT_IDLE);

Cela demande à gtkmm d'appeler la fonction membre indiquée chaque fois qu'il ne se passe rien d'autre. Vous pouvez définir une priorité (les plus petits nombres correspondent aux priorités les plus élevées). Il y a deux manières de déconnecter le gestionnaire de signal : par l'appel de la fonction membre disconnect() sur l'objet sigc::connection ou en renvoyant `false` dans le gestionnaire du signal, qui doit être déclaré ainsi :

    bool idleFunc();

Comme ceci est tout à fait semblable aux fonctions membres des paragraphes précédents, cette explication doit être suffisante pour comprendre comment cela se passe. Toutefois, voici un petit exemple :

Code source

File: `idleexample.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_IDLEEXAMPLE_H
    #define GTKMM_EXAMPLE_IDLEEXAMPLE_H

    #include <gtkmm.h>
    #include <iostream>

    class IdleExample : public Gtk::Window
    {
    public:
      IdleExample();

    protected:
      // Signal Handlers:
      bool on_timer();
      bool on_idle();
      void on_button_clicked();

      // Member data:
      Gtk::Box m_Box;
      Gtk::Button m_ButtonQuit;
      Gtk::ProgressBar m_ProgressBar_c;
      Gtk::ProgressBar m_ProgressBar_d;
    };

    #endif // GTKMM_EXAMPLE_IDLEEXAMPLE_H

File: `idleexample.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "idleexample.h"

    IdleExample::IdleExample() :
      m_Box(Gtk::ORIENTATION_VERTICAL, 5),
      m_ButtonQuit(Gtk::Stock::QUIT)
    {
      set_border_width(5);

      // Put buttons into container

      // Adding a few widgets:
      add(m_Box);
      m_Box.pack_start( *Gtk::manage(new Gtk::Label("Formatting Windows drive C:")));
      m_Box.pack_start( *Gtk::manage(new Gtk::Label("100 MB")) );
      m_Box.pack_start(m_ProgressBar_c);

      m_Box.pack_start( *Gtk::manage(new Gtk::Label("")) );

      m_Box.pack_start( *Gtk::manage(new Gtk::Label("Formatting Windows drive D:")));
      m_Box.pack_start( *Gtk::manage(new Gtk::Label("5000 MB")) );
      m_Box.pack_start(m_ProgressBar_d);

      Gtk::Box* hbox = Gtk::manage( new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL,10));
      m_Box.pack_start(*hbox);
      hbox->pack_start(m_ButtonQuit, Gtk::PACK_EXPAND_PADDING);

      // Connect the signal handlers:
      m_ButtonQuit.signal_clicked().connect( sigc::mem_fun(*this,
                  &IdleExample::on_button_clicked) );

      // formatting drive c in timeout signal handler - called once every 50ms
      Glib::signal_timeout().connect( sigc::mem_fun(*this, &IdleExample::on_timer),
              50 );

      // formatting drive d in idle signal handler - called as quickly as possible
      Glib::signal_idle().connect( sigc::mem_fun(*this, &IdleExample::on_idle) );

      show_all_children();
    }

    void IdleExample::on_button_clicked()
    {
      hide();
    }

    // this timer callback function is executed once every 50ms (set in connection
    // above).  Use timeouts when speed is not critical. (ie periodically updating
    // something).
    bool IdleExample::on_timer()
    {
      double value = m_ProgressBar_c.get_fraction();

      // Update progressbar 1/500th each time:
      m_ProgressBar_c.set_fraction(value + 0.002);

      return value < 0.99;  // return false when done
    }

    // This idle callback function is executed as often as possible, hence it is
    // ideal for processing intensive tasks.
    bool IdleExample::on_idle()
    {
      double value = m_ProgressBar_d.get_fraction();

      // Update progressbar 1/5000th each time:
      m_ProgressBar_d.set_fraction(value + 0.0002);

      return value < 0.99;  // return false when done
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "idleexample.h"
    #include <gtkmm/main.h>

    int main (int argc, char *argv[])
    {
      Gtk::Main app(argc, argv);

      IdleExample example;
      Gtk::Main::run(example);

      return 0;
    }

Cet exemple souligne la différence entre fonctions membres de temporisation et fonctions membres à délai échu. Si vous avez besoin de fonctions appelées périodiquement et que la rapidité n'a pas grosse importance, alors servez-vous des fonctions membres à délai échu. Si vous voulez des fonctions membres appelées aussi souvent que possible (comme des fonctions membres de calcul de fractales en arrière-plan), alors utilisez les fonctions membres de temporisation.

Essayez d'exécuter l'exemple tout en augmentant la charge de votre système. La barre de progression supérieure doit avancer régulièrement ; l'inférieure devrait ralentir.

## Gestion de la mémoire

### Éléments graphiques

#### Gestion classique de la mémoire en C++

gtkmm autorise le programmeur à contrôler la durée de vie (c'est-à-dire, la construction et la destruction) de tout élément graphique de la même manière que celle de n'importe quel objet C++. Cette polyvalence autorise, soit l'utilisation des opérateurs `new` et `delete` pour créer et détruire les objets de manière dynamique, soit l'utilisation de données membres de classes régulières (qui sont détruites automatiquement quand la classe est détruite), soit l'utilisation d'instances locales (qui sont détruites dès que l'instance est hors de portée). Certaines boîtes à outils GUI C++ n'offrent pas cette souplesse : elles restreignent le programmeur à un sous-ensemble des fonctionnalités de gestion mémoire du C++.

Voici quelques exemples de gestion traditionnelle de la mémoire en C++ :

##### Éléments graphiques à portée de classe

Si un programmeur n'a pas besoin d'allocation dynamique de mémoire, il peut se servir d'éléments graphiques automatiques à portée de classe. Un des avantages des éléments graphiques automatiques à portée de classe est que la gestion de la mémoire est regroupée en un seul endroit. Le programmeur ne risque pas de fuites de mémoire en oubliant un `delete` sur un élément graphique.

Les principaux inconvénients proviennent du fait que l'utilisation d'éléments graphiques à portée de classe sont en rapport avec l'implémentation de la classe plus que de son interfaçage dans l'en-tête de classe. Les éléments graphiques à portée de classe sont créés automatiquement et souffrent des mêmes inconvénients que n'importe quelle autre variable automatique à portée de classe.

    #include <gtkmm/button.h>
    class Foo
    {
    private:
      Gtk::Button theButton;
      // sera détruit en même temps que l'objet Foo
    };

##### Éléments graphiques à portée de fonction

Si un programmeur ne souhaite pas utiliser d'élément graphique à portée de classe, il peut aussi se servir d'éléments graphiques à portée de fonction. Les avantages de la portée de fonction par rapport à la portée de classe sont un masquage accru des données et une réduction des dépendances.

    {
      Gtk::Button aButton;
      aButton.show();
      ...
      kit.run();
    }

##### Allocation dynamique avec new et delete

Même si, dans la plupart des cas, le programmeur préfére allouer des conteneurs pour détruire automatiquement leur contenu avec la fonction `manage()` (voir ci-dessous), l'utilisation de cette fonction n'est pas obligatoire. Les opérateurs traditionnels `new` et `delete` peuvent également être utilisés.

    Gtk::Button* pButton = new Gtk::Button("Test");

    // faire quelque chose d'utile avec pButton

    delete pButton;

Ici, le programmeur détruit pButton pour prévenir une fuite de mémoire.

#### Éléments graphiques gérés

Sinon, vous pouvez confier au conteneur d'élément graphique le contrôle du moment où il sera détruit. Dans la plupart des cas, vous voulez qu'un élément graphique dure aussi longtemps que son conteneur. Pour déléguer la gestion de la durée de vie d'un élément graphique à son conteneur, créez-le avec `manage()` et empaquetez-le dans son conteneur avec add(). Ainsi, l'élément graphique sera détruit au moment où son conteneur sera détruit.

##### Allocation dynamique avec manage() et add()

gtkmm met à votre disposition les fonctions `manage()` et add() pour créer et détruire les éléments graphiques. Tout élément graphique, excepté la fenêtre principale, doit être ajouté ou empaqueté dans un conteneur pour être affiché. La fonction `manage()` marque l'élément graphique empaqueté de sorte que, lorsqu'il est ajouté dans un conteneur, ce conteneur devient responsable de sa destruction.

    MyWidget::MyWidget()
    {
      Gtk::Button* pButton = manage(new Gtk::Button("Test"));
      add(*pButton); //ajoute aButton à MyWidget
    }

Ainsi, quand des objets du type MyWidget sont détruits, le bouton est également détruit. Il n'est plus nécessaire à l'avenir de détruire pButton pour libérer la mémoire occupée par le bouton ; cette opération a été déléguée à l'objet MyWidget.

gtkmm fournit également la fonction membre set_manage() pour tous les éléments graphiques. Il est possible de l'utiliser pour obtenir le même résultat qu'avec `manage()`, mais c'est plus délicat :

foo.add( (w=new Gtk::Label("Hello"), w->set_manage(), &w) );

est équivalent à

foo.add( manage(new Gtk::Label("Hello")) );

Bien entendu, le conteneur de haut niveau n'est pas intégré dans un autre conteneur. Le programmeur est responsable de la destruction du conteneur de haut niveau en utilisant les techniques habituelles du C++. Ainsi, votre fenêtre principale ne peut être qu'une instance dans votre fonction `main()`.

### Ressources partagées

Some objects, such as Gdk::Pixbufs and Pango::Fonts, are obtained from a shared store. Therefore you cannot instantiate your own instances. These classes typically inherit from Glib::Object. Rather than requiring you to reference and unreference these objects, gtkmm uses the Glib::RefPtr<> smartpointer. Cairomm has its own smartpointer, Cairo::RefPtr<>.

Objects such as Gdk::Pixbuf can only be instantiated with a create() function. For instance,

    Glib::RefPtr<Gdk::Pixbuf> pixbuf = Gdk::Pixbuf::create_from_file(filename);

You have no way of getting a bare Gdk::Pixbuf. In the example, `pixbuf` is a smart pointer, so you can do this, much like a normal pointer:

    int width = 0;
    if(pixbuf)
    {
      width = pixbuf->get_width();
    }

When `pixbuf` goes out of scope an unref() will happen in the background and you don't need to worry about it anymore. There's no `new` so there's no `delete`.

Si vous copiez un RefPtr, par exemple

    Glib::RefPtr<Gdk::Pixbuf> pixbuf2 = pixbuf;

ou si vous le passez en tant que paramètre de fonction ou en tant que type de retour, alors le pointeur RefPtr fera tout référencement nécessaire pour assurer que cette instance ne soit pas détruite avant que le RefPtr ne soit pas hors de portée.

Consultez cette annexe pour une information détaillée concernant les RefPtr.

Si vous voulez en savoir plus à propos des pointeurs intelligents, vous pouvez consulter les ouvrages suivants :

- Bjarne Stroustrup, « The C++ Programming Language » - chapitre 14.4.2

- Nicolai M. Josuttis, « The C++ Standard Library » - chapitre 4.2

## Glade et Gtk::Builder

Même si vous pouvez utiliser du code C++ pour instancier et disposer les éléments graphiques, cela devient vite répétitif et fastidieux. De plus, il est nécessaire de compiler à nouveau pour voir les modifications. L'application Glade vous permet de disposer les éléments graphiques à l'écran et d'enregistrer une description XML de l'arrangement. Votre application peut alors utiliser l'API Gtk::Builder pour charger ce fichier XML au lancement de l'application et obtenir un pointeur sur les instances de l'élément graphique précisément désigné.

Cette fonction membre présente les avantages suivants :

1. elle requiert moins de code C++,

2. les modifications apportées à l'UI sont visibles plus rapidement, donc plus facilement améliorables,

3. des concepteurs sans capacité particulière de programmation peuvent créer et modifier des UI.

Vous aurez encore besoin de code C++ pour gérer les transactions sur l'interface déclenchées par les actions de l'utilisateur, mais l'utilisation de Gtk::Builder pour la disposition des éléments graphiques vous permet de vous concentrer sur l'implémentation des fonctionnalités.

### Chargement du fichier .glade

Gtk::Builder doit être utilisé avec un pointeur Glib::RefPtr. Comme toutes les classes de ce type, vous aurez besoin de faire appel à la fonction membre create() pour en créer un exemplaire. Par exemple,

    Glib::RefPtr<Gtk::Builder> builder =
                    Gtk::Builder::create_from_file("basic.glade");

Ceci va initialiser la fenêtre définie dans le fichier .glade, même si elle n'est pas immédiatement affichée à moins que vous ayez défini cette action par l'intermédiaire de la fenêtre Propriétés dans Glade.

Pour créer juste un exemplaire d'une fenêtre ou d'un élément graphique enfant, vous pouvez indiquer le nom d'un élément graphique en tant que deuxième paramètre. Par exemple,

    Glib::RefPtr<Gtk::Builder> builder =
                    Gtk::Builder::create_from_file(
                                  "basic.glade",
                                  "treeview_products");

### Accès aux éléments graphiques

Pour accéder à un élément graphique, par exemple pour appeler la fonction show() sur une boîte de dialogue, utilisez la fonction membre get_widget() en fournissant le nom de l'élément graphique en paramètre. Ce nom doit avoir été indiqué dans la fenêtre Propriétés de Glade. Si l'élément graphique est introuvable, ou n'est pas d'un type correct, le pointeur sera initialisé à 0.

    Gtk::Dialog* pDialog = 0;
    builder->get_widget("DialogBasic", pDialog);

Gtk::Builder vérifie qu'il ne s'agit pas d'un pointeur NULL et que l'élément graphique est du type attendu ; il affiche des avertissements sur la ligne de commande s'il y a de telles anomalies.

Souvenez-vous que get_widget() ne crée pas un nouvel exemplaire d'élément graphique ; avec cette fonction, vous obtenez simplement un pointeur sur un élément graphique qui existe déjà. Vous obtenez toujours un pointeur sur le même élément graphique quand vous appelez get_widget() sur le même Gtk::Builder, avec le même nom d'élément graphique. Les éléments graphiques sont créés pendant l'appel à Gtk::Builder::create_from_file().

get_widget() renvoie des éléments graphiques enfants marqués (voir le chapitre sur la Gestion de la mémoire) par la fonction `manage()` ; ils seront donc détruits quand leur conteneur parent sera détruit. Donc, si vous n'obtenez qu'un seul élément graphique de Gtk::Builder, au lieu de la totalité de la fenêtre, alors vous devez, soit le placer dans un objet Container, soit le détruire. Les objets Windows (tout comme les objets Dialogs) ne peuvent pas être gérés étant donné qu'ils n'ont pas de conteneur parent ; vous devez donc les détruire à un moment donné.

#### Exemple

Cet exemple simple montre comment charger un fichier Glade au cours de l'exécution et accéder aux éléments graphiques avec Gtk::Builder.

Code source

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <gtkmm.h>
    #include <iostream>

    Gtk::Dialog* pDialog = 0;

    static
    void on_button_clicked()
    {
      if(pDialog)
        pDialog->hide(); //hide() will cause main::run() to end.
    }

    int main (int argc, char **argv)
    {
      Gtk::Main kit(argc, argv);

      //Load the GtkBuilder file and instantiate its widgets:
      Glib::RefPtr<Gtk::Builder> refBuilder = Gtk::Builder::create();
      try
      {
        refBuilder->add_from_file("basic.glade");
      }
      catch(const Glib::FileError& ex)
      {
        std::cerr << "FileError: " << ex.what() << std::endl;
        return 1;
      }
      catch(const Glib::MarkupError& ex)
      {
        std::cerr << "MarkupError: " << ex.what() << std::endl;
        return 1;
      }
      catch(const Gtk::BuilderError& ex)
      {
        std::cerr << "BuilderError: " << ex.what() << std::endl;
        return 1;
      }

      //Get the GtkBuilder-instantiated Dialog:
      refBuilder->get_widget("DialogBasic", pDialog);
      if(pDialog)
      {
        //Get the GtkBuilder-instantiated Button, and connect a signal handler:
        Gtk::Button* pButton = 0;
        refBuilder->get_widget("quit_button", pButton);
        if(pButton)
        {
          pButton->signal_clicked().connect( sigc::ptr_fun(on_button_clicked) );
        }

        kit.run(*pDialog);
      }

      delete pDialog;

      return 0;
    }

### Utilisation d'éléments graphiques dérivés

Vous pouvez utilisez Glade pour placer vos propres éléments graphiques personnalisés, dérivés à partir d'une classe d'élément graphique gtkmm. Vous pouvez ainsi conserver votre code organisé et encapsulé. Bien entendu, vous ne voyez pas l'aspect exact et les propriétés de l'élément graphique dérivé dans Glade, mais vous pouvez indiquer son emplacement, ses éléments graphiques enfants et les propriétés de la classe gtkmm de base.

Utilisez Gtk::Builder::get_widget_derived() ainsi :

    DerivedDialog* pDialog = 0;
    builder->get_widget_derived("DialogBasic", pDialog);

Votre classe dérivée doit avoir un constructeur prenant comme paramètre un pointeur sur le type C sous-jacent et l'instance de Gtk::Builder. Toutes les classes gtkmm en rapport définissent leurs types C sous-jacents en tant qu'objets BaseObjectType (par exemple Gtk::Dialog défini son type BaseObjectType comme `GtkDialog`).

Vous devez faire appel au constructeur de la classe de base dans la liste d'initialisation, en fournissant le pointeur C. Par exemple,

    DerivedDialog::DerivedDialog(BaseObjectType* cobject,
                                 const Glib::RefPtr<Gtk::Builder>& builder)
    : Gtk::Dialog(cobject)
    {
    }

Vous pouvez ensuite encapsuler les manipulations des éléments graphiques enfants dans le constructeur de la classe dérivée, avec peut-être get_widget() ou get_widget_derived() à nouveau. Par exemple,

    DerivedDialog::DerivedDialog(BaseObjectType* cobject,
                                 const Glib::RefPtr<Gtk::Builder>& builder)
    : Gtk::Dialog(cobject),
      m_builder(builder),
      m_pButton(0)
    {
      // Obtenir le bouton instancié par Glade
      // et le connecter au gestionnaire de signal :
      m_builder->get_widget("quit_button", m_pButton);
      if(m_pButton)
      {
        m_pButton->signal_clicked().connect( sigc::mem_fun(*this,
                                       &DerivedDialog::on_button_quit) );
      }
    }

#### Exemple

Cet exemple montre comment charger un fichier Glade au lancement et accéder aux éléments graphiques par l'intermédiaire d'une classe dérivée.

Code source

File: `deriveddialog.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_DERIVED_DIALOG_H
    #define GTKMM_EXAMPLE_DERIVED_DIALOG_H

    #include <gtkmm.h>

    class DerivedDialog : public Gtk::Dialog
    {
    public:
      DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& refGlade);
      virtual ~DerivedDialog();

    protected:
      //Signal handlers:
      void on_button_quit();

      Glib::RefPtr<Gtk::Builder> m_refGlade;
      Gtk::Button* m_pButton;
    };

    #endif //GTKMM_EXAMPLE_DERIVED_WINDOW_H

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "deriveddialog.h"
    #include <iostream>

    int main (int argc, char **argv)
    {
      Gtk::Main kit(argc, argv);

      //Load the Glade file and instiate its widgets:
      Glib::RefPtr<Gtk::Builder> refBuilder = Gtk::Builder::create();
      try
      {
        refBuilder->add_from_file("derived.glade");
      }
      catch(const Glib::FileError& ex)
      {
        std::cerr << "FileError: " << ex.what() << std::endl;
        return 1;
      }
      catch(const Glib::MarkupError& ex)
      {
        std::cerr << "MarkupError: " << ex.what() << std::endl;
        return 1;
      }
      catch(const Gtk::BuilderError& ex)
      {
        std::cerr << "BuilderError: " << ex.what() << std::endl;
        return 1;
      }

      //Get the GtkBuilder-instantiated dialog::
      DerivedDialog* pDialog = 0;
      refBuilder->get_widget_derived("DialogDerived", pDialog);
      if(pDialog)
      {
        //Start:
        kit.run(*pDialog);
      }

      delete pDialog;

      return 0;
    }

File: `deriveddialog.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "deriveddialog.h"

    DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& refGlade)
    : Gtk::Dialog(cobject),
      m_refGlade(refGlade),
      m_pButton(0)
    {
      //Get the Glade-instantiated Button, and connect a signal handler:
      m_refGlade->get_widget("quit_button", m_pButton);
      if(m_pButton)
      {
        m_pButton->signal_clicked().connect( sigc::mem_fun(*this, &DerivedDialog::on_button_quit) );
      }
    }

    DerivedDialog::~DerivedDialog()
    {
    }

    void DerivedDialog::on_button_quit()
    {
      hide(); //hide() will cause main::run() to end.
    }

## Internationalisation et adaptation locale

Les applications gtkmm prennent facilement en charge plusieurs langues, y compris les langues non-européennes telles que le chinois et les langues s'écrivant de droite à gauche comme l'arabe. Une application gtkmm écrite et traduite de manière appropriée, utilise lors de son exécution la langue définie par l'environnement utilisateur.

Vous ne devez pas anticiper le besoin de prendre en charge telles ou telles autres langues, mais vous ne devez jamais en exclure l'utilisation. De plus, il est plus facile de développer une application correctement dès le début que de l'améliorer après coup.

Le processus consistant à écrire un code source autorisant la traduction s'appelle l'`internationalisation`, souvent abrégé en `i18n`. Le processus d'`adaptation locale` (localisation) quelquefois abrégé en `l10n`, met à disposition du texte, fondé sur ce code source, traduit dans d'autres langues.

Le gros du travail dans le processus d'internationalisation est de rechercher les chaînes visibles par l'utilisateur et de les marquer comme traduisibles. Ce travail n'a pas besoin d'être réalisé en une seule fois - si vous réglez l'infrastructure du projet correctement, votre application fonctionnera normalement quel que soit le nombre de chaînes traîtées.

Les chaînes littérales doivent être saisies en anglais dans le code source, mais englobées dans une macro. L'utilitaire gettext (ou intltool) extrait les chaînes marquées pour traduction et substitue le texte traduit lors de l'exécution.

### Préparation du projet

Dans les directives ci-dessous, nous supposons que vous n'utilisez pas gettext directement, mais intltool qui a été spécialement écrit pour `GNOME`. intltool utilise `gettext()` pour extraire les chaînes du code source, mais intltool peut aussi combiner, dans les fichiers standards `.pot/.po` de gettext, les chaînes provenant d'autres fichiers : par exemple, des détails de menu du bureau ou de ressources d'interface utilisateur comme les fichiers Glade.

Nous supposons également que vous utilisez autotools (c'est-à-dire, automake et autoconf) pour construire le projet et que vous vous servez de `./autogen.sh` de gnome-common, qui, entre autres choses, effectue certaines initialisations pour intltool.

Créez un sous-répertoire nommé `po` dans le répertoire racine de votre projet. Ce répertoire contiendra en phase finale toutes les traductions. Dans celui-ci, créez un fichier nommé `LINGUAS` et un fichier nommé `POTFILES.in`. Il est aussi de pratique courante de créer un fichier `ChangeLog` dans le répertoire `po` pour que les traducteurs puissent garder trace des modifications de traduction.

`LINGUAS` contient une liste triée alphabétiquement des codes identifiant toutes les langues dans lesquelles votre programme est traduit (les lignes de commentaires débutant par `#` sont ignorées). Chaque code de langue listé dans `LINGUAS` doit avoir un fichier `.po` correspondant. Ainsi, si votre programme a des traductions en allemand et en japonais, le fichier `LINGUAS` ressemblera à :

    # keep this file sorted alphabetically, one language code per line
    de
    ja

(en outre, vous devez avoir dans le dossier `po` des fichiers `ja.po` et `de.po` contenant respectivement la traduction japonaise et allemande).

`POTFILES.in` est une liste des chemins vers tous les fichiers contenant des chaînes marquées pour la traduction, à partir du répertoire racine du projet. Ainsi, par exemple, si les sources du projet sont situées dans un sous-répertoire nommé `src` et si vous avez deux fichiers contenant des chaînes à traduire, votre fichier `POTFILES.in` ressemble à quelque chose comme :

    src/main.cc
    src/other.cc

Si vous utilisez gettext directement, vous ne pouvez marquer pour traduction que les chaînes situées dans les fichiers de code source. Mais, si vous vous servez de intltool, vous pouvez marquer des chaînes pour traduction dans divers autres formats de fichier, y compris les fichiers d'interface utilisateur Glade, xml, .desktop et de nombreux autres. Donc si vous avez conçu une partie des interfaces utilisateur du projet à l'aide de Glade, ajoutez également vos fichiers `.glade` dans la liste du fichier `POTFILES.in`.

Maintenant que vous disposez d'un endroit où mettre vos traductions, il est nécessaire d'initialiser intltool et gettext. Ajoutez le code ci-après dans votre fichier `configure.ac`, en mettant le nom de votre programme à la place de « nom_programme » :

    IT_PROG_INTLTOOL([0.35.0])

    GETTEXT_PACKAGE=nom_programme
    AC_SUBST(GETTEXT_PACKAGE)
    AC_DEFINE_UNQUOTED([GETTEXT_PACKAGE], ["$GETTEXT_PACKAGE"],
                       [Domaine de portée de gettext])
    AM_GLIB_GNU_GETTEXT

    PROGRAMNAME_LOCALEDIR=[${datadir}/locale]
    AC_SUBST(PROGRAMNAME_LOCALEDIR)

La variable `PROGRAMNAME_LOCALEDIR` sera utilisée plus tard dans le fichier `Makefile.am` pour définir une macro utilisée quand vous initialisez gettext dans votre code source.

Dans le fichier Makefile.am principal :

- ajoutez `po` à la variable `SUBDIRS`. Sans cela, vos traductions ne seraient pas construites et installées lors de la construction du programme.

- définissez `INTLTOOL_FILES` égal à :

      INTLTOOL_FILES = intltool-extract.in \
                       intltool-merge.in \
                       intltool-update.in

- ajoutez `INTLTOOL_FILES` à la liste `EXTRA_DIST` de fichiers. Ceci assure que ces commandes seront incluses dans l'archive source quand vous effectuerez `make dist`.

- mettez à jour vos `DISTCLEANFILES` :

      DISTCLEANFILES = ... intltool-extract \
                       intltool-merge \
                       intltool-update \
                       po/.intltool-merge-cache

Dans votre `src/Makefile.am`, mettez à jour votre variable `AM_CPPFLAGS` en ajoutant la définition de macro préprocesseur suivante :

    AM_CPPFLAGS = ... -DPROGRAMNAME_LOCALEDIR=\"${PROGRAMNAME_LOCALEDIR}\"

Cette macro sert quand vous initialisez `gettext` dans votre code source.

### Marquage des chaînes à traduire

Les chaînes littérales doivent être saisies dans le code source en anglais, mais elles doivent être incorporées dans un appel à la fonction `gettext()`. Ces chaînes seront extraites pour traduction et les traductions utilisées lors de l'exécution au lieu des chaînes originelles en anglais.

Le paquetage GNU gettext vous permet de marquer des chaînes dans le code source, de les extraire pour traduction et d'utiliser les chaînes traduites dans votre application.

Toutefois, Glib définit des macros de prise en charge de `gettext()` qui sont des enveloppes plus brèves et de forme plus commode à utiliser. Pour utiliser ces macros, incluez `<glibmm/i18n.h>`, puis, par exemple, remplacez :

    display_message("Getting ready for i18n.");

par :

    display_message(_("Getting ready for i18n."));

À titre de référence, il est possible de générer un fichier qui contienne toutes les chaînes apparaissant dans votre code, même si elles ne sont pas marquées pour la traduction, avec le nom du fichier et le numéro de la ligne où elles se situent. Pour générer ce fichier que nous appelons `my-strings`, exécutez la commande suivante dans le répertoire du code source :

    xgettext -a -o my-strings --omit-header *.cc *.h

Pour terminer, pour permettre à votre programme d'utiliser la traduction pour l'adaptation locale en cours, ajoutez ce code au début de votre fichier `main.cc` pour initialiser gettext :

    bindtextdomain(GETTEXT_PACKAGE, PROGRAMNAME_LOCALEDIR);
    bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
    textdomain(GETTEXT_PACKAGE);

#### Comment fonctionne gettext

Le script intltool / xgettext extrait les chaînes et les place dans un fichier `mon_paquet.pot`. Les traducteurs de votre application créent leur traduction en faisant d'abord une copie du fichier `.pot` dans un fichier `nom_de_locale.po`. Une « locale » identifie une langue et un codage pour cette langue, y compris les formats numériques et de date. Ultérieurement, si le texte de votre code source a été modifié, le script `msmerge` sera utilisé pour mettre à jour les fichiers `nom_de_locale.po` à partir d'une nouvelle génération du fichier `.pot`.

Au moment de l'installation, les fichiers `.po` sont convertis dans un format binaire (avec l'extension `.mo`) et placés dans un répertoire système pour les fichiers d'environnement linguistique, par exemple `/usr/share/locale/`.

Quand l'application est lancée, la bibliothèque gettext vérifie dans le répertoire système s'il y a un fichier `.mo` pour l'environnement linguistique de l'utilisateur (environnement que vous pouvez définir avec, par exemple, « export LANG=de_DE.UTF-8 » à partir d'un terminal). Puis, quand le programme atteint un appel `gettext`, il examine s'il existe une traduction pour la chaîne donnée. Si aucune n'est trouvée, la chaîne d'origine est utilisée.

#### Vérification et ajout de traductions

Pour vérifier que vous avez bien opéré, peut-être voudrez-vous ajouter une traduction pour un nouvel environnement linguistique. Pour réaliser cela, allez dans le sous-répertoire `po` de votre projet et exécutez les commandes suivantes :

    intltool-update --pot

Cette commande crée un fichier nommé `nom_du_programme.pot`. Copiez ensuite ce fichier en lui donnant le nom `code_langue.po`, comme `de.po` ou `hu.po`. Ajoutez également ce code langue dans le fichier `LINGUAS`. Le fichier `.po` comporte un en-tête et une liste des chaînes en anglais, avec des emplacements pour les chaînes traduites à saisir. Assurez-vous que vous avez défini et utilisé `UTF-8` comme codage du fichier `.po` (comme défini dans l'en-tête, mais utilisé dans le contenu).

Il est possible que certaines chaînes soient marquées `fuzzy` (approximatives) dans le fichier `.po`. Les traductions ainsi marquées ne se substituent pas à la chaîne originelle. Pour qu'elles apparaissent, enlevez simplement la marque `fuzzy`.

#### Ressources

Des informations supplémentaires sur le processus d'internationalisation et de localisation sont présentées et commentées dans :

- Internationalisation des applications GNOME

- Fichier README de Intltool

- Comment utiliser GNOME CVS pour traduire

- Manuel gettext

- Exemple de paquet logiciel `gtkmm_hello`

- Exemple de paquet logiciel `gnomemm_hello`

### En attendant UTF8

Une application correctement internationalisée ne doit pas faire de suppositions sur le nombre d'octets par caractère. Cela signifie que vous ne devez pas faire d'arithmétique de pointeurs pour cheminer parmi les caractères d'une chaîne ; cela signifie aussi que vous ne devez pas vous servir d'objets std::string ou de fonctions C standard telles que `strlen()` car elle se fondent sur de telles suppositions pour effectuer leurs calculs.

Même si vous avez certainement déjà délaissé les tableaux de `char*` vides et l'arithmétique des pointeurs en vous servant de std::string, vous devez maintenant utiliser à la place des objets Glib::ustring. Voyez le chapitre concernant les Glib::ustring dans les Fondamentaux.

#### Glib::ustring et std::iostreams

Malheureusement, l'intégration avec les flux d'entrée-sortie standards n'est pas d'une utilisation très simple. Si vous dirigez la sortie du flux standard vers un ostream avec l'opérateur `operator<<`, gtkmm convertit les Glib::ustring dans un encodage spécifique à l'environnement linguistique (qui généralement n'est pas UTF-8). De la même façon, en récupérant des objets Glib::ustring à partir d'un flux istream avec l'opérateur `operator>>`, vous déclenchez la conversion inverse. Mais ce schéma s'effondre si vous passez par un std::string, par exemple en dirigeant un flux de texte vers un std::string puis en le convertissant de manière implicite en Glib::ustring. Si la chaîne contenait des caractères non-ASCII et que l'environnement linguistique local n'est pas codé en UTF-8, il en résulte un objet Glib::ustring corrompu. Vous pouvez contourner ce problème avec une conversion manuelle. Par exemple, pour retrouver l'objet std::string à partir d'un ostringstream :

    std::ostringstream output;
    output.imbue(std::locale("")); // utiliser la locale de l'utilisateur pour ce flux
    output << percentage << " % done";
    label->set_text(Glib::locale_to_utf8(output.str()));

### Embûches

Voici quelques erreurs courantes que vous découvririez peut-être par vous-même. Mais il se peut que ce paragraphe vous aide à les éviter.

#### Mêmes chaînes, sémantiques différentes

Quelquefois deux chaînes en anglais sont identiques, mais ont des significations différentes selon le contexte ; elles ne mériteraient donc probablement pas d'être traduites de la même façon. Comme les chaînes en anglais sont utilisées comme clés de recherche, cela pose problème.

Dans ce cas, vous pouvez ajouter des caractères supplémentaires à la chaîne. Par exemple, écrivez `"jumps[noun]"` et `"jumps[verb]"` au lieu de `"jumps"` uniquement et extrayez-les à nouveau avec un appel à `gettext`. Si vous ajoutez des caractères supplémentaires, vous devez également ajouter un commentaire pour les traducteurs avant l'appel de `gettext`. De tels commentaires s'affichent dans les fichiers `.po`. Par exemple :

    // note to translators: don't translate the "[noun]" part - it is
    // just here to distinguish the string from another "jumps" string
    text = strip(gettext("jumps[noun]"), "[noun]");

#### Composition de chaînes

Les programmeurs C se servent de la fonction `sprintf()` pour composer et concaténer des chaînes. Le C++ favorise les flux, mais malheureusement, cette approche rend la traduction difficile, parce que chaque fragment de texte est traduit séparément sans permettre aux traducteurs de les ré-agencer selon la grammaire de la langue.

Par exemple, ce code risque d'être sujet à problèmes :

    std::cout << _("Current amount: ") << amount
              << _(" Future: ") << future << std::endl;

    label.set_text(_("Really delete ") + filename + _(" now?"));

Vous devez, soit éviter de tels cas, soit revenir à la fonction `sprintf()` du style C. Une autre solution possible est d'utiliser la bibliothèque compose qui prend en charge des syntaxes telles que :

    label.set_text(compose(_("Really delete %1 now?"), filename));

#### Hypothèse concernant la taille d'affichage des chaînes

Vous ne savez jamais quel sera l'espace pris à l'écran par une chaîne après traduction. Il est tout à fait possible qu'elle soit deux fois plus longue que la chaîne originelle en anglais. Par chance, la plupart des éléments graphiques gtkmm se redimensionnent à la taille voulue lors de l'exécution.

#### Mots inhabituels

Vous devez éviter les abréviations mystérieuses, l'argot ou du jargon de spécialiste. Ces termes sont généralement difficiles à traduire et souvent même à comprendre pour les autochtones. Par exemple, préférez « application » à « app ».

#### Utilisation de caractères non-ASCII dans les chaînes

Actuellement, gettext ne prend pas en charge les caractères non-ASCII (c'est-à-dire tout caractère de code supérieur à 127) dans le code source. Par exemple, vous ne pouvez pas utiliser le signe de copyright (©).

Pour contourner ce problème, vous pouvez écrire un commentaire dans le code source juste avant la chaîne, indiquant au traducteur qu'il peut utiliser le caractère spécial s'il est disponible dans leur langue. Pour l'anglais, vous pouvez ensuite faire une traduction américain-anglais dans `en_US.po` en utilisant ce caractère spécial.

### Obtenir de l'aide avec les traductions

Si votre programme est un logiciel libre, il existe un sous-projet complet `GNOME` dédié à l'aide à la traduction, le Projet de traduction `GNOME` (GNOME Translation Project).

Voici comment il fonctionne : contactez la liste de diffusion gnome-i18n pour indiquer comment les traducteurs pourraient avoir accès à votre sous-répertoire `po/` et pour ajouter votre projet aux grands tableaux d'état.

Assurez-vous que le fichier `POTFILES.in` dans le sous-répertoire `po/` est à jour (la commande `intltool‑update -M` peut vous aider pour cela) de façon à ce que les traducteurs aient toujours accès à des fichiers `mon_programme.pot` actualisés et gelez tout simplement les chaînes au moins quelques jours avant de téléverser une nouvelle version en l'annonçant sur gnome-i18n. Selon le nombre de chaînes que votre programme comporte et selon sa popularité, les traductions vont alors commencer à apparaître dans les fichiers `nom_de_langue.po`.

Notez que la plupart des équipes de traducteurs ne sont constituées que de 1 à 3 personnes ; donc, si votre programme comporte beaucoup de chaînes, cela peut prendre beaucoup de temps avant que quelqu'un ait le temps d'y jeter un coup d'œil. De plus, pas mal de traducteurs ne souhaitent pas dilapider leur temps (la traduction est une tâche très consommatrice de temps) donc, il ne prendront en charge votre projet que s'il est vraiment sérieux (dans le sens, travaillé et maintenu) ; si ce n'est pas le cas il peuvent décider de s'occuper sur d'autres projets.

## Éléments graphiques personnalisés

gtkmm facilite la dérivation de nouveaux éléments graphiques par héritage à partir d'une classe d'élément graphique existante, soit par dérivation à partir d'un conteneur et en y ajoutant des éléments graphiques enfants, soit par dérivation d'un élément graphique simple en modifiant son comportement. Mais vous pouvez parfois trouver qu'il n'y a aucun point de départ convenable. Dans ce cas, vous pouvez implémenter un élément graphique de A à Z.

### Conteneurs personnalisés

Quand vous dérivez de la classe Gtk::Container, vous pouvez surdéfinir les fonctions membres virtuelles suivantes :

- get_request_mode_vfunc() : renvoie quel est l'objet `Gtk::SizeRequestMode` préféré par le conteneur.

- get_preferred_width_vfunc() : calcule la largeur minimale naturelle du conteneur.

- get_preferred_height_vfunc() : calcule la hauteur minimale naturelle du conteneur.

- get_preferred_width_for_height_vfunc() : calcule la largeur minimale naturelle du conteneur compte tenu de la hauteur précisée.

- get_preferred_height_for_width_vfunc() : calcule la hauteur minimale naturelle du conteneur compte tenu de la largeur précisée.

- on_size_allocate() : place les éléments graphiques enfants, compte tenu de la hauteur et de la largeur réellement attribuées au conteneur.

- forall_vfunc() : appelle la même fonction de rappel pour chaque enfant.

- on_add() : ajoute un élément graphique enfant dans le conteneur.

- on_remove() : supprime un élément graphique enfant du conteneur.

- child_type_vfunc() : renvoie le type d'enfant pouvant être ajouté.

Les fonctions membres virtuelles get_request_mode_vfunc(), get_preferred_width_vfunc(), get_preferred_height_vfunc(), get_preferred_width_for_height_vfunc(), get_preferred_height_for_width_vfunc() et on_size_allocate() contrôlent la disposition des éléments graphiques enfants. Par exemple, si votre conteneur possède deux éléments graphiques enfants, l'un au dessus de l'autre, votre fonction membre get_preferred_width_vfunc() doit renvoyer la plus grande des largeurs des éléments graphiques enfants et get_preferred_height_for_width_vfunc() la somme des hauteurs. Si vous voulez de l'espace libre autour les éléments graphiques enfants, vous devez également l'additionner à la largeur et à la hauteur. Votre conteneur d'éléments graphiques se sert de ces résultats pour s'assurer que vos éléments graphiques ont assez de place. En examinant chaque parent de l'élément graphique, et les parents de celui-ci, cette logique détermine éventuellement la taille de la fenêtre de plus haut niveau.

Vous n'avez pas la garantie d'obtenir le `Gtk::SizeRequestMode` demandé. C'est pourquoi les quatre fonctions membres get_preferred_xxx_vfunc() doivent renvoyer des valeurs raisonnables.

on_size_allocate(), toutefois, reçoit les vraies hauteur et largeur que le conteneur parent a décidé de donner à l'élément graphique. Cela peut être plus que le minimum ou même plus que la taille naturelle, par exemple, si la fenêtre de haut niveau a été agrandie. Vous pouvez choisir d'ignorer l'espace supplémentaire et laisser la zone inoccupée, ou bien vous pouvez choisir d'agrandir vos éléments graphiques enfants pour remplir cet espace, ou bien encore vous pouvez choisir d'augmenter l'espace libre entre vos éléments graphiques. C'est votre conteneur, à vous de décider. N'oubliez pas d'appeler set_allocation() à l'intérieur de votre implémentation de on_size_allocate() pour utiliser effectivement l'espace alloué offert par le conteneur parent.

À moins que votre conteneur ne soit une fenêtre de haut niveau dérivée de Gtk::Window, vous devez également appeler Gtk::Widget::set_has_window(false) dans le constructeur. Cela signifie que votre conteneur ne crée pas sa propre Gdk::Window, mais utilise la fenêtre du parent. (Notez la différence entre Gtk::Window et Gdk::Window.) Si votre conteneur n'a pas besoin de sa propre Gdk::Window et ne dérive pas d'une Gtk::Window, vous devez aussi surdéfinir la fonction membre on_realize() comme cela est décrit dans la section Éléments graphiques personnalisés. Et, sauf si votre conteneur dessine directement dans la Gdk::Window sous-jacente, vous devrez probablement appeler set_redraw_on_allocate(false) pour améliorer les performances.

En surdéfinissant forall_vfunc() vous permettez aux applications d'opérer sur tous les éléments graphiques enfants du conteneur. Par exemple, show_all_children() utilise cette possibilité pour trouver tous les éléments graphiques enfants et les afficher.

Même si votre conteneur possède sa propre fonction membre pour définir ses éléments graphiques enfants, vous devez quand même fournir une implémentation des fonctions membres virtuelles on_add() et on_remove() de la classe de base de façon à ce que les fonctions membres add() et remove() fassent quelque chose d'approprié si elles sont appelées.

Votre implémentation de la fonction membre child_type_vfunc() doit renvoyer le type d'élément graphique pouvant être ajouté à votre conteneur s'il n'est pas encore rempli. Généralement, c'est à Gtk::Widget::get_type() d'indiquer quelles sont les classes dérivées de Gtk::Widget acceptées. Si le conteneur ne peut plus contenir d'autres éléments graphiques, cette fonction membre doit renvoyer la valeur `G_TYPE_NONE`.

#### Exemple

Cet exemple implémente un conteneur avec deux éléments graphiques enfants, l'un au dessus de l'autre. Bien entendu, dans ce cas il aurait été de loin beaucoup plus simple d'utiliser Gtk::VBox.

Conteneur personnalisé

Code source

File: `mycontainer.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_CUSTOM_CONTAINER_MYCONTAINER_H
    #define GTKMM_CUSTOM_CONTAINER_MYCONTAINER_H

    #include <gtkmm/container.h>

    class MyContainer : public Gtk::Container
    {
    public:
      MyContainer();
      virtual ~MyContainer();

      void set_child_widgets(Gtk::Widget& child_one, Gtk::Widget& child_two);

    protected:

      //Overrides:
      virtual Gtk::SizeRequestMode get_request_mode_vfunc() const;
      virtual void get_preferred_width_vfunc(int& minimum_width, int& natural_width) const;
      virtual void get_preferred_height_for_width_vfunc(int width, int& minimum_height, int& natural_height) const;
      virtual void get_preferred_height_vfunc(int& minimum_height, int& natural_height) const;
      virtual void get_preferred_width_for_height_vfunc(int height, int& minimum_width, int& natural_width) const;
      virtual void on_size_allocate(Gtk::Allocation& allocation);

      virtual void forall_vfunc(gboolean include_internals, GtkCallback callback, gpointer callback_data);

      virtual void on_add(Gtk::Widget* child);
      virtual void on_remove(Gtk::Widget* child);
      virtual GType child_type_vfunc() const;

      Gtk::Widget* m_child_one;
      Gtk::Widget* m_child_two;
    };

    #endif //GTKMM_CUSTOM_CONTAINER_MYCONTAINER_H

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>
    #include "mycontainer.h"

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_quit();

      //Child widgets:
      Gtk::Box m_VBox;
      MyContainer m_MyContainer;
      Gtk::Button m_Button_One;
      Gtk::Label m_Label_Two;
      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_One("Child One"),
      m_Label_Two("Child 2"),
      m_Button_Quit("Quit")
    {
      set_title("Custom Container example");
      set_border_width(6);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the child widgets to the custom container:
      m_MyContainer.set_child_widgets(m_Button_One, m_Label_Two);

      m_Label_Two.set_alignment(1.0, 0.5);

      m_VBox.pack_start(m_MyContainer, Gtk::PACK_EXPAND_WIDGET);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(6);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

File: `mycontainer.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include <algorithm> // std::max
    #include "mycontainer.h"

    MyContainer::MyContainer()
    : m_child_one(0), m_child_two(0)
    {
      set_has_window(false);
      set_redraw_on_allocate(false);
    }

    MyContainer::~MyContainer()
    {
    }

    void MyContainer::set_child_widgets(Gtk::Widget& child_one,
            Gtk::Widget& child_two)
    {
      m_child_one = &child_one;
      m_child_two = &child_two;

      m_child_one->set_parent(*this);
      m_child_two->set_parent(*this);
    }

    //This example container is a simplified VBox with at most two children.
    Gtk::SizeRequestMode MyContainer::get_request_mode_vfunc() const
    {
      return Gtk::SIZE_REQUEST_HEIGHT_FOR_WIDTH;
    }

    //Discover the total amount of minimum space and natural space needed by
    //this container and its children.
    void MyContainer::get_preferred_width_vfunc(int& minimum_width, int& natural_width) const
    {
      int child_minimum_width[2] = {0, 0};
      int child_natural_width[2] = {0, 0};

      if(m_child_one && m_child_one->get_visible())
        m_child_one->get_preferred_width(child_minimum_width[0], child_natural_width[0]);

      if(m_child_two && m_child_two->get_visible())
        m_child_two->get_preferred_width(child_minimum_width[1], child_natural_width[1]);

      //Request a width equal to the width of the widest visible child.
      minimum_width = std::max(child_minimum_width[0], child_minimum_width[1]);
      natural_width = std::max(child_natural_width[0], child_natural_width[1]);
    }

    void MyContainer::get_preferred_height_for_width_vfunc(int width,
       int& minimum_height, int& natural_height) const
    {
      int child_minimum_height[2] = {0, 0};
      int child_natural_height[2] = {0, 0};
      int nvis_children = 0;

      if(m_child_one && m_child_one->get_visible())
      {
        ++nvis_children;
        m_child_one->get_preferred_height_for_width(width, child_minimum_height[0],
                                                    child_natural_height[0]);
      }

      if(m_child_two && m_child_two->get_visible())
      {
        ++nvis_children;
        m_child_two->get_preferred_height_for_width(width, child_minimum_height[1],
                                                    child_natural_height[1]);
      }

      //The allocated height will be divided equally among the visible children.
      //Request a height equal to the number of visible children times the height
      //of the highest child.
      minimum_height = nvis_children * std::max(child_minimum_height[0],
                                                child_minimum_height[1]);
      natural_height = nvis_children * std::max(child_natural_height[0],
                                                child_natural_height[1]);
    }

    void MyContainer::get_preferred_height_vfunc(int& minimum_height, int& natural_height) const
    {
      int child_minimum_height[2] = {0, 0};
      int child_natural_height[2] = {0, 0};
      int nvis_children = 0;

      if(m_child_one && m_child_one->get_visible())
      {
        ++nvis_children;
        m_child_one->get_preferred_height(child_minimum_height[0], child_natural_height[0]);
      }

      if(m_child_two && m_child_two->get_visible())
      {
        ++nvis_children;
        m_child_two->get_preferred_height(child_minimum_height[1], child_natural_height[1]);
      }

      //The allocated height will be divided equally among the visible children.
      //Request a height equal to the number of visible children times the height
      //of the highest child.
      minimum_height = nvis_children * std::max(child_minimum_height[0],
                                                child_minimum_height[1]);
      natural_height = nvis_children * std::max(child_natural_height[0],
                                                child_natural_height[1]);
    }

    void MyContainer::get_preferred_width_for_height_vfunc(int height,
       int& minimum_width, int& natural_width) const
    {
      int child_minimum_width[2] = {0, 0};
      int child_natural_width[2] = {0, 0};
      int nvis_children = 0;

      //Get number of visible children.
      if(m_child_one && m_child_one->get_visible())
        ++nvis_children;
      if(m_child_two && m_child_two->get_visible())
        ++nvis_children;

      if(nvis_children > 0)
      {
        //Divide the height equally among the visible children.
        const int height_per_child = height / nvis_children;

        if(m_child_one && m_child_one->get_visible())
          m_child_one->get_preferred_width_for_height(height_per_child,
                       child_minimum_width[0], child_natural_width[0]);

        if(m_child_two && m_child_two->get_visible())
          m_child_two->get_preferred_width_for_height(height_per_child,
                       child_minimum_width[1], child_natural_width[1]);
      }

      //Request a width equal to the width of the widest child.
      minimum_width = std::max(child_minimum_width[0], child_minimum_width[1]);
      natural_width = std::max(child_natural_width[0], child_natural_width[1]);
    }

    void MyContainer::on_size_allocate(Gtk::Allocation& allocation)
    {
      //Do something with the space that we have actually been given:
      //(We will not be given heights or widths less than we have requested, though
      //we might get more.)

      //Use the offered allocation for this container:
      set_allocation(allocation);

      //Get number of visible children.
      int nvis_children = 0;
      if(m_child_one && m_child_one->get_visible())
        ++nvis_children;
      if(m_child_two && m_child_two->get_visible())
        ++nvis_children;

      if(nvis_children <= 0)
        return;

      //Assign space to the children:
      Gtk::Allocation child_allocation_one;
      Gtk::Allocation child_allocation_two;

      //Place the first child at the top-left:
      child_allocation_one.set_x( allocation.get_x() );
      child_allocation_one.set_y( allocation.get_y() );

      //Make it take up the full width available:
      child_allocation_one.set_width( allocation.get_width() );

      if(m_child_one && m_child_one->get_visible())
      {
        //Divide the height equally among the visible children.
        child_allocation_one.set_height( allocation.get_height() / nvis_children);
        m_child_one->size_allocate(child_allocation_one);
      }
      else
        child_allocation_one.set_height(0);

      //Place the second child below the first child:
      child_allocation_two.set_x( allocation.get_x() );
      child_allocation_two.set_y( allocation.get_y() +
              child_allocation_one.get_height());

      //Make it take up the full width available:
      child_allocation_two.set_width( allocation.get_width() );

      //Make it take up the remaining height:
      child_allocation_two.set_height( allocation.get_height() -
              child_allocation_one.get_height());

      if(m_child_two && m_child_two->get_visible())
        m_child_two->size_allocate(child_allocation_two);
    }

    void MyContainer::forall_vfunc(gboolean, GtkCallback callback, gpointer callback_data)
    {
      if(m_child_one)
        callback(m_child_one->gobj(), callback_data);

      if(m_child_two)
        callback(m_child_two->gobj(), callback_data);
    }

    void MyContainer::on_add(Gtk::Widget* child)
    {
      if(!m_child_one)
      {
        m_child_one = child;
        m_child_one->set_parent(*this);
      }
      else if(!m_child_two)
      {
        m_child_two = child;
        m_child_two->set_parent(*this);
      }
    }

    void MyContainer::on_remove(Gtk::Widget* child)
    {
      if(child)
      {
        const bool visible = child->get_visible();
        bool found = false;

        if(child == m_child_one)
        {
          m_child_one = 0;
          found = true;
        }
        else if(child == m_child_two)
        {
          m_child_two = 0;
          found = true;
        }

        if(found)
        {
          child->unparent();

          if(visible)
            queue_resize();
        }
      }
    }

    GType MyContainer::child_type_vfunc() const
    {
      //If there is still space for one widget, then report the type of widget that
      //may be added.
      if(!m_child_one || !m_child_two)
        return Gtk::Widget::get_type();
      else
      {
        //No more widgets may be added.
        return G_TYPE_NONE;
      }
    }

### Éléments graphiques personnalisés

En dérivant directement de la classe Gtk::Widget, vous pouvez faire tous les dessins voulus directement dans votre élément graphique plutôt que seulement placer des éléments graphiques enfants. Par exemple, un objet Gtk::Label écrit directement le texte de l'étiquette sans passer par l'intermédiaire d'autres éléments graphiques.

Quand vous dérivez de la classe Gtk::Widget, vous pouvez surdéfinir les fonctions membres virtuelles. Les fonctions membres marquées (optionnelles) ne nécessitent pas d'être surdéfinies pour tous les éléments graphiques personnalisés. Les fonctions membres de la classe de base peuvent se révéler appropriées.

- get_request_mode_vfunc() : (optionelle) renvoie quel est le `Gtk::SizeRequestMode` préféré par l'élément graphique.

- get_preferred_width_vfunc() : calcule la largeur minimale naturelle de l'élément graphique.

- get_preferred_height_vfunc() : calcule la hauteur minimale naturelle de l'élément graphique.

- get_preferred_width_for_height_vfunc() : calcule la largeur minimale naturelle de l'élément graphique compte tenu de la hauteur précisée.

- get_preferred_height_for_width_vfunc() : calcule la hauteur minimale naturelle de l'élément graphique compte tenu de la largeur précisée.

- on_size_allocate() : place l'élément graphique, compte tenu de la hauteur et de la largeur réellement attribuées.

- on_realize() : associe un objet Gdk::Window à l'élément graphique.

- on_unrealize() : (optionnelle) détruit l'association avec l'objet Gdk::Window.

- on_map(): (optionnelle)

- on_unmap(): (optionnelle)

- on_draw() : trace sur l'objet Cairo::Context fourni.

Les six premières fonctions membres dans le tableau précédent sont également surdéfinies dans les conteneurs personnalisés. Elles sont brièvement décrites dans la section Conteneurs personnalisés.

La plupart des éléments graphiques personnalisés nécessitent leur propre Gdk::Window pour tracer dessus. Alors vous pouvez appeler Gtk::Widget::set_has_window(true) dans votre constructeur (c'est la valeur par défaut). Si vous n'appelez pas set_has_window(false), vous devez surdéfinir on_realize() et appeler à partir de là Gtk::Widget::set_realized() et Gtk::Widget::set_window().

#### Exemple

Cet exemple implémente un élément graphique qui trace un triangle de Penrose.

Élément graphique personnalisé

Code source

File: `mywidget.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_CUSTOM_WIDGET_MYWIDGET_H
    #define GTKMM_CUSTOM_WIDGET_MYWIDGET_H

    #include <gtkmm/widget.h>
    #include <gtkmm/cssprovider.h>

    class MyWidget : public Gtk::Widget
    {
    public:
      MyWidget();
      virtual ~MyWidget();

    protected:

      //Overrides:
      virtual Gtk::SizeRequestMode get_request_mode_vfunc() const;
      virtual void get_preferred_width_vfunc(int& minimum_width, int& natural_width) const;
      virtual void get_preferred_height_for_width_vfunc(int width, int& minimum_height, int& natural_height) const;
      virtual void get_preferred_height_vfunc(int& minimum_height, int& natural_height) const;
      virtual void get_preferred_width_for_height_vfunc(int height, int& minimum_width, int& natural_width) const;
      virtual void on_size_allocate(Gtk::Allocation& allocation);
      virtual void on_map();
      virtual void on_unmap();
      virtual void on_realize();
      virtual void on_unrealize();
      virtual bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr);

      Glib::RefPtr<Gdk::Window> m_refGdkWindow;
      Glib::RefPtr<Gtk::CssProvider> m_refStyleProvider;

      int m_scale;
    };

    #endif //GTKMM_CUSTOM_WIDGET_MYWIDGET_H

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>
    #include "mywidget.h"

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_quit();

      //Child widgets:
      Gtk::Box m_VBox;
      MyWidget m_MyWidget;
      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `mywidget.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "mywidget.h"
    #include <gdkmm/general.h>  // for cairo helper functions
    #include <iostream>
    //#include <gtk/gtkwidget.h> //For GTK_IS_WIDGET()
    #include <cstring>

    MyWidget::MyWidget() :
      //The GType name will actually be gtkmm__CustomObject_mywidget
      Glib::ObjectBase("mywidget"),
      Gtk::Widget(),
      m_scale(1000)
    {
      set_has_window(true);

      //This shows the GType name, which must be used in the CSS file.
      std::cout << "GType name: " << G_OBJECT_TYPE_NAME(gobj()) << std::endl;

      //This shows that the GType still derives from GtkWidget:
      //std::cout << "Gtype is a GtkWidget?:" << GTK_IS_WIDGET(gobj()) << std::endl;

      //Install a style so that an aspect of this widget may be themed via a CSS
      //style sheet file:
      gtk_widget_class_install_style_property(GTK_WIDGET_CLASS(
                  G_OBJECT_GET_CLASS(gobj())),
          g_param_spec_int("example_scale",
            "Scale of Example Drawing",
            "The scale to use when drawing. This is just a silly example.",
            G_MININT,
            G_MAXINT,
            500,
            G_PARAM_READABLE) );

      m_refStyleProvider = Gtk::CssProvider::create();
      Glib::RefPtr<Gtk::StyleContext> refStyleContext = get_style_context();
      refStyleContext->add_provider(m_refStyleProvider,
        GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);

      try
      {
        m_refStyleProvider->load_from_path("custom_gtk.css");
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "Gtk::CssProvider::load_from_path() failed: " << ex.what() << std::endl;
      }
    }

    MyWidget::~MyWidget()
    {
    }

    Gtk::SizeRequestMode MyWidget::get_request_mode_vfunc() const
    {
      //Accept the default value supplied by the base class.
      return Gtk::Widget::get_request_mode_vfunc();
    }

    //Discover the total amount of minimum space and natural space needed by
    //this widget.
    //Let's make this simple example widget always need minimum 60 by 50 and
    //natural 100 by 70.
    void MyWidget::get_preferred_width_vfunc(int& minimum_width, int& natural_width) const
    {
      minimum_width = 60;
      natural_width = 100;
    }

    void MyWidget::get_preferred_height_for_width_vfunc(int /* width */,
       int& minimum_height, int& natural_height) const
    {
      minimum_height = 50;
      natural_height = 70;
    }

    void MyWidget::get_preferred_height_vfunc(int& minimum_height, int& natural_height) const
    {
      minimum_height = 50;
      natural_height = 70;
    }

    void MyWidget::get_preferred_width_for_height_vfunc(int /* height */,
       int& minimum_width, int& natural_width) const
    {
      minimum_width = 60;
      natural_width = 100;
    }

    void MyWidget::on_size_allocate(Gtk::Allocation& allocation)
    {
      //Do something with the space that we have actually been given:
      //(We will not be given heights or widths less than we have requested, though
      //we might get more)

      //Use the offered allocation for this container:
      set_allocation(allocation);

      if(m_refGdkWindow)
      {
        m_refGdkWindow->move_resize( allocation.get_x(), allocation.get_y(),
                allocation.get_width(), allocation.get_height() );
      }
    }

    void MyWidget::on_map()
    {
      //Call base class:
      Gtk::Widget::on_map();
    }

    void MyWidget::on_unmap()
    {
      //Call base class:
      Gtk::Widget::on_unmap();
    }

    void MyWidget::on_realize()
    {
      //Do not call base class Gtk::Widget::on_realize().
      //It's intended only for widgets that set_has_window(false).

      set_realized();

      //Get the themed style from the CSS file:
      get_style_property("example_scale", m_scale);
      std::cout << "m_scale (example_scale from the theme/css-file) is: "
          << m_scale << std::endl;

      if(!m_refGdkWindow)
      {
        //Create the GdkWindow:

        GdkWindowAttr attributes;
        memset(&attributes, 0, sizeof(attributes));

        Gtk::Allocation allocation = get_allocation();

        //Set initial position and size of the Gdk::Window:
        attributes.x = allocation.get_x();
        attributes.y = allocation.get_y();
        attributes.width = allocation.get_width();
        attributes.height = allocation.get_height();

        attributes.event_mask = get_events () | Gdk::EXPOSURE_MASK;
        attributes.window_type = GDK_WINDOW_CHILD;
        attributes.wclass = GDK_INPUT_OUTPUT;

        m_refGdkWindow = Gdk::Window::create(get_parent_window(), &attributes,
                GDK_WA_X | GDK_WA_Y);
        set_window(m_refGdkWindow);

        //set colors
        override_background_color(Gdk::RGBA("red"));
        override_color(Gdk::RGBA("blue"));

        //make the widget receive expose events
        m_refGdkWindow->set_user_data(gobj());
      }
    }

    void MyWidget::on_unrealize()
    {
      m_refGdkWindow.reset();

      //Call base class:
      Gtk::Widget::on_unrealize();
    }

    bool MyWidget::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      const double scale_x = (double)get_allocation().get_width() / m_scale;
      const double scale_y = (double)get_allocation().get_height() / m_scale;

      // paint the background
      Gdk::Cairo::set_source_rgba(cr, get_style_context()->get_background_color());
      cr->paint();

      // draw the foreground
      Gdk::Cairo::set_source_rgba(cr, get_style_context()->get_color());
      cr->move_to(155.*scale_x, 165.*scale_y);
      cr->line_to(155.*scale_x, 838.*scale_y);
      cr->line_to(265.*scale_x, 900.*scale_y);
      cr->line_to(849.*scale_x, 564.*scale_y);
      cr->line_to(849.*scale_x, 438.*scale_y);
      cr->line_to(265.*scale_x, 100.*scale_y);
      cr->line_to(155.*scale_x, 165.*scale_y);
      cr->move_to(265.*scale_x, 100.*scale_y);
      cr->line_to(265.*scale_x, 652.*scale_y);
      cr->line_to(526.*scale_x, 502.*scale_y);
      cr->move_to(369.*scale_x, 411.*scale_y);
      cr->line_to(633.*scale_x, 564.*scale_y);
      cr->move_to(369.*scale_x, 286.*scale_y);
      cr->line_to(369.*scale_x, 592.*scale_y);
      cr->move_to(369.*scale_x, 286.*scale_y);
      cr->line_to(849.*scale_x, 564.*scale_y);
      cr->move_to(633.*scale_x, 564.*scale_y);
      cr->line_to(155.*scale_x, 838.*scale_y);
      cr->stroke();

      return true;
    }

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit("Quit")
    {
      set_title("Custom Widget example");
      set_border_width(6);
      set_default_size(400, 200);

      add(m_VBox);
      m_VBox.pack_start(m_MyWidget, Gtk::PACK_EXPAND_WIDGET);
      m_MyWidget.show();

      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(6);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this, &ExampleWindow::on_button_quit) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/main.h>

    int main(int argc, char *argv[])
    {
      Gtk::Main kit(argc, argv);

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      Gtk::Main::run(window);

      return 0;
    }

## Techniques recommandées

Ce chapitre est simplement un condensé de pratiques de bon sens, de lignes directrices générales, et de conseils pour créer des applications gtkmm.

Utilisez autoconf et automake de GNU ! Ce sont des amis :) Automake examine les fichiers C, détermine leurs dépendances mutuelles et génère un `Makefile` ; ainsi les fichiers peuvent être compilés dans le bon ordre. Autoconf permet une configuration automatique de l'installation du logiciel en gérant un grand nombre de systèmes exotiques pour augmenter la portabilité.

Sous-classez vos éléments graphiques pour mieux organiser votre code. Vous devrez probablement sous-classer au moins votre fenêtre principale Window. Ensuite, vous pouvez faire des éléments graphiques enfants et des fonctions membres gestionnaires des signaux de cette classe.

Créez vos propres signaux au lieu de transmettre des pointeurs. Les objets peuvent communiquer entre eux par l'intermédiaire de signaux et de gestionnaires de signaux. C'est plus simple que des objets enregistrant des pointeurs vers d'autres objets, et vice versa, en appelant mutuellement leurs fonctions membres. Les classes de gtkmm utilisent une version spéciale de sigc::signal, mais vous pouvez utiliser les signaux normaux tels que décrits dans la documentation de libsigc++.

### Durée de vie d'une application

La plupart des applications ne disposent que d'une fenêtre de la classe Window, ou uniquement une fenêtre principale. Ces applications peuvent utiliser la surdéfinition de Gtk::Main::run(Gtk::Window&). Elle affiche la fenêtre et rend la main quand la fenêtre a été cachée. Ceci se produit quand l'utilisateur ferme la fenêtre ou quand le code applique la fonction hide() sur la fenêtre. Vous pouvez empêcher l'utilisateur de fermer la fenêtre (par exemple, s'il y a des modifications non enregistrées) en surdéfinissant Gtk::Window::on_delete_event().

La plupart de nos exemples utilisent cette technique.

### Utilisation d'un élément graphique gtkmm

Nos exemples adoptent tous la même structure. Ils suivent ces étapes pour l'utilisation d'un Élément graphique :

1. Déclarer une variable du type de l'Élément graphique que vous souhaitez utiliser, généralement en tant que variable membre d'une classe conteneur dérivée. Vous pouvez également déclarer un pointeur sur le type de l'élément graphique et le créer avec `new` dans votre code. Même si vous utilisez l'élément graphique par l'intermédiaire d'un pointeur, ce sera probablement mieux de faire en sorte que ce pointeur soit une variable membre d'une classe conteneur ; vous pouvez ainsi y accéder ultérieurement.

2. Définissez les attributs de l'élément graphique. Si l'élément graphique n'a pas de constructeur par défaut, vous devez l'initialiser à l'aide de la liste d'initialisations du constructeur de la classe conteneur.

3. Connectez tout signal que vous souhaitez utiliser aux gestionnaires appropriés.

4. Empaquetez l'élément graphique dans un conteneur par un appel approprié, par exemple Gtk::Container::add() ou pack_start().

5. Appelez show() pour afficher l'élément graphique.

Gtk::Widget::show() fait savoir à gtkmm que vous avez terminé de définir les attributs de l'élément graphique et qu'il est prêt à être affiché. Vous pouvez utiliser Gtk::Widget::hide() pour le faire disparaître à nouveau. L'ordre dans lequel vous affichez les éléments graphiques n'a pas d'importance, mais nous suggérons de n'afficher qu'en dernier la fenêtre de plus haut niveau ; ainsi, la fenêtre globale apparaît en ayant tout son contenu déjà dessinée. Sinon, l'utilisateur voit d'abord une fenêtre vierge dans laquelle les éléments graphiques sont tracés progressivement.

## Comment contribuer

Ce document, comme beaucoup d'autres grands logiciels, a été créé gratuitement par des bénévoles. Si vous avez des compétences sur un des aspects de gtkmm qui ne serait pas déjà documenté, il serait aimable à vous d'envisager une contribution à ce document.

L'idéal serait que vous fournissiez un patch pour le fichier `docs/tutorial/C/gtkmm-tutorial-in.xml`. Ce fichier est actuellement dans le module `gtkmm-documentation` du dépôt git de GNOME.

Si vous décidez de contribuer, veuillez poster votre contribution sur la liste de diffusion de gtkmm à l'adresse <gtkmm-list@gnome.org>. Également, prenez note que la totalité de ce document est libre et que tout ajout que vous feriez doit également être libre. Ce qui signifie que quiconque peut se servir de tout ou partie de vos exemples dans ses programmes et que les copies de ce document (y compris votre contribution) peuvent être diffusées gratuitement.

## Le pointeur intelligent RefPtr

Glib::RefPtr est un pointeur intelligent. Plus précisément, c'est un pointeur intelligent à décompte de références. Vous connaissez déjà peut-être le `std::auto_ptr<>`, qui est aussi un pointeur intelligent, mais `Glib::RefPtr<>` est plus simple et plus utile. Nous espérons qu'une future version de la Bibliothèque Standard C++ contiendra un pointeur partagé intelligent à décompte de références ; une future version de gtkmm pourrait alors l'utiliser à la place.

Référence

Un pointeur intelligent se comporte plus ou moins comme un pointeur normal. Voici quelques exemples.

### Copie

Vous pouvez copier les RefPtr, tout comme des pointeurs normaux. Mais contrairement aux pointeurs normaux, vous n'avez pas à vous soucier de la destruction de l'instance sous-jacente.

    Glib::RefPtr<Gdk::Pixbuf> refPixbuf = Gdk::Pixbuf::create_from_file(filename);
    Glib::RefPtr<Gdk::Pixbuf> refPixbuf2 = refPixbuf;

Of course this means that you can store RefPtrs in standard containers, such as std::vector or std::list.

    std::list< Glib::RefPtr<Gdk::Pixbuf> > listPixbufs;
    Glib::RefPtr<Gdk::Pixbuf> refPixbuf = Gdk::Pixbuf::create_from_file(filename);
    listPixbufs.push_back(refPixbuf);

### Déréférencement

Vous pouvez déréférencer un pointeur intelligent avec l'opérateur `->` pour appeler des fonctions membres de l'instance subjacente, comme pour un pointeur normal.

    Glib::RefPtr<Gdk::Pixbuf> refPixbuf = Gdk::Pixbuf::create_from_file(filename);
    int width = refPixbuf->get_width();

Mais contrairement à la plupart des pointeurs, vous ne pouvez pas utiliser l'opérateur `*` pour avoir accès à l'instance sous-jacente.

    Glib::RefPtr<Gdk::Pixbuf> refPixbuf = Gdk::Pixbuf::create_from_file(filename);
    Gdk::Pixbuf& underlying = *refPixbuf; //Syntax error - will not compile.

### Forçage de type

Vous pouvez forcer les RefPtrs à des types de base, comme des pointeurs normaux.

    Glib::RefPtr<Gtk::TreeStore> refStore = Gtk::TreeStore::create(columns);
    Glib::RefPtr<Gtk::TreeModel> refModel = refStore;

Cela signifie que toute fonction membre prenant en paramètre un `const Glib::RefPtr<BaseType>` peut également prendre un `const Glib::RefPtr<DerivedType>`. Le forçage est implicite, tout comme pour un pointeur normal.

Vous pouvez aussi faire un forçage sur un type dérivé, mais la syntaxe est alors différente de celle pour un pointeur normal.

    Glib::RefPtr<Gtk::TreeStore> refStore =
    Glib::RefPtr<Gtk::TreeStore>::cast_dynamic(refModel);
    Glib::RefPtr<Gtk::TreeStore> refStore2 =
    Glib::RefPtr<Gtk::TreeStore>::cast_static(refModel);

### Vérification du pointeur NULL

Comme pour les pointeurs normaux, vous pouvez vérifier si un pointeur RefPtr ne pointe sur rien.

    Glib::RefPtr<Gtk::TreeModel> refModel = m_TreeView.get_model();
    if(refModel)
    {
      int cols_count = refModel->get_n_columns();
      ...
    }

Mais contrairement aux pointeurs normaux, les RefPtr sont automatiquement initialisés à NULL ; vous n'avez pas à faire cela vous-même.

### Constance

L'utilisation du mot clé `const` dans le C++ n'est pas toujours claire. Vous ne devez pas penser que `const Quelquechose*` déclare un pointeur sur un type `const Quelquechose` ; le pointeur peut être modifié, mais pas le `Quelquechose` sur lequel il pointe.

Ainsi, l'équivalent RefPtr de `Quelquechose*` pour un paramètre de fonction membre est `const Glib::RefPtr<Quelquechose>&` et l'équivalent de `const Quelquechose*` est `const Glib::RefPtr<const Quelquechose>&`.

Le `const ... &` qui entoure les deux expressions est juste une question d'efficacité, c'est comme utiliser const std::string& à la place de std::string pour un paramètre de fonction pour éviter une recopie non nécessaire.

## Signaux

### Connexion aux gestionnaires de signal

Les classes d'éléments graphiques gtkmm ont des fonctions membres d'accès aux signaux, comme Gtk::Button::signal_clicked(), qui permettent de se connecter au gestionnaire de signal. Grâce à la souplesse de libsigc++, la bibliothèque utilisée par gtkmm, le gestionnaire de signal peut être n'importe quel type de fonction, mais vous souhaiterez probablement utiliser une fonction membre de la classe. Les programmeurs C de GTK+ nomment souvent ces gestionnaires de signal « fonctions de rappel » (callback).

Voici un exemple de gestionnaire de signal connecté à un signal :

    #include <gtkmm/button.h>

    void on_button_clicked()
    {
        std::cout << "Hello World" << std::endl;
    }

    main()
    {
        Gtk::Button button("Hello World");
        button.signal_clicked().connect(sigc::ptr_fun(&on_button_clicked));
    }

Il y a un certain nombre de choses à considérer à propos de ce code (non fonctionnel). D'abord identifions les parties concernées :

- Le gestionnaire de signal est on_button_clicked().

- Nous le raccrochons à l'objet Gtk::Button nommé `button`.

- Quand le bouton émet le signal `clicked`, on_button_clicked() est appelé.

Maintenant ré-examinons la connexion :

        ...
        button.signal_clicked().connect(sigc::ptr_fun(&on_button_clicked));
        ...

Notez que nous ne passons pas directement un pointeur sur on_button_clicked() à la fonction membre connect() du signal. À la place, nous faisons appel à `sigc::ptr_fun()` et passons le résultat à connect().

`sigc::ptr_fun()` génère un objet sigc::slot. Un connecteur est un objet qui ressemble et réagit comme une fonction, mais qui, en réalité, est bien un objet. Il est également connu sous le nom d'objet fonction ou « functor ». `sigc::ptr_fun()` génère un connecteur pour une fonction autonome ou une fonction membre statique. `sigc::mem_fun()` génère un connecteur pour une fonction membre d'une instance donnée.

Voici un exemple un peu plus développé de connecteurs en action :

    void on_button_clicked();

    class some_class
    {
        void on_button_clicked();
    };

    some_class some_object;

    main()
    {
        Gtk::Button button;
        button.signal_clicked().connect( sigc::ptr_fun(&on_button_clicked) );
        button.signal_clicked().connect( sigc::mem_fun(some_object,
                                         &some_class::on_button_clicked) );
    }

Le premier appel à connect() est identique à celui que nous avons vu la fois précédente ; rien de plus à dire.

Le suivant est plus intéressant. `sigc::mem_fun()` est appelé avec deux paramètres. Le premier paramètre est some_object, qui est l'objet sur lequel notre nouveau connecteur pointe. Le second paramètre est un pointeur sur une de ses fonctions membres. Cette version particulière de `sigc::mem_fun()` crée un connecteur qui, quand il sera « appelé », fera lui-même appel à la fonction membre pointée de l'objet désigné, dans ce cas some_object.on_button_clicked().

Autre chose à noter dans cet exemple : nous appelons connect() deux fois pour le même objet signal. Cela est parfaitement correct — quand le bouton est cliqué, les deux gestionnaires de signal sont appelés.

Nous venons de vous dire que le signal `clicked` d'un bouton s'attend à appeler une fonction membre sans paramètre d'entrée. Tous les signaux ont des exigences de ce type — vous ne pouvez pas accrocher une fonction avec deux paramètres à un signal n'en attendant aucun (sauf si vous utilisez un adaptateur, tels que `sigc::bind()`, bien entendu). C'est pourquoi il est important de savoir quel type de gestionnaire de signal vous devez connecter à un signal donné.

### Écriture de gestionnaires de signal

Pour savoir quel type de gestionnaire de signal vous pouvez connecter, regardez dans la documentation de référence ou dans le fichier d'en-tête. Voici un exemple de déclaration de signal que vous pouvez voir dans les fichiers d'en-tête de gtkmm :

    Glib::SignalProxy1<bool, Gtk::DirectionType> signal_focus()

Outre le nom du signal (`focus`), deux choses sont importantes à noter ici : le nombre suivant le mot SignalProxy (1, dans notre cas), et les types de la liste (`bool` et `Gtk::DirectionType`). Le nombre indique le nombre de paramètres que le gestionnaire de signal doit posséder, le premier type, `bool`, est le type de retour du gestionnaire de signal et le suivant, `Gtk::DirectionType`, est le type du premier et unique paramètre de ce signal. En consultant la documentation de référence, vous pouvez également prendre connaissance des noms des arguments.

Les mêmes principes s'appliquent aux signaux avec plus de paramètres, voici un exemple avec trois paramètres (pris dans le fichier `<gtkmm/editable.h>`) :

    Glib::SignalProxy3<void, const Glib::ustring&, int, int*> signal_insert_text()

Il est de la même forme. Le nombre 3 à la fin du nom du type indique que le gestionnaire de signal nécessite trois paramètres. Le premier type dans la liste des types est `void`, c'est le type de retour du gestionnaire de signal. Les trois types suivants sont les types des paramètres, dans l'ordre. Notre prototype de gestionnaire de signal ressemble à quelque chose comme :

    void on_insert_text(const Glib::ustring& text, int length, int* position);

### Déconnexion des gestionnaires de signal

Examinons à nouveau la fonction membre `connect` d'un signal :

    sigc::signal<void,int>::iterator signal<void,int>::connect( const sigc::slot<void,int>& );

Notez que la valeur de retour est du type sigc::signal<void,int>::iterator. Celle-ci peut être implicitement convertie en sigc::connection qui peut, à son tour, être utilisée pour contrôler la connexion. En conservant un objet connexion, vous pouvez déconnecter son signal associé avec la fonction membre sigc::connection::disconnect().

### Surdéfinition du gestionnaire de signal par défaut

Jusqu'ici nous vous avons montré la réalisation d'actions en réponse à une pression de bouton à l'aide d'un gestionnaire de signal. C'est assurément un bon moyen de réaliser les choses, mais ce n'est pas le seul.

Au lieu de connecter laborieusement les gestionnaires de signal aux signaux, vous pouvez simplement créer une nouvelle classe qui hérite d'un élément graphique — disons, un bouton —, puis surdéfinir le gestionnaire de signal par défaut, tel que Button::on_clicked(). Cela peut se révéler plus simple que d'accrocher des gestionnaires de signal pour chaque chose.

Le sous-classement n'est pas toujours la meilleure façon de réaliser les choses. Il est uniquement utile quand vous souhaitez que l'élément graphique gère son propre signal par lui-même. Si vous souhaitez qu'une autre classe gère le signal, il faut se connecter à un gestionnaire séparé. C'est encore plus vrai si vous voulez que plusieurs objets gèrent le même signal ou si vous voulez qu'un seul gestionnaire de signal réponde au même signal à partir d'objets différents.

Les classes gtkmm ont été conçues dans l'optique de surdéfinitions ; elles comportent des fonctions membres virtuelles spécialement pensées pour être surdéfinies.

Regardons un exemple de surdéfinition :

    #include <gtkmm/button.h>

    class OverriddenButton : public Gtk::Button
    {
    protected:
        virtual void on_clicked();
    }

    void OverriddenButton::on_clicked()
    {
        std::cout << "Hello World" << std::endl;

    // appeler la version de la classe de base de la fonction membre:
        Gtk::Button::on_clicked();
    }

Ici nous définissons une nouvelle classe nommée OverriddenButton qui hérite de Gtk::Button. La seule chose que nous modifions est la fonction membre on_clicked() ; cette fonction membre est appelée chaque fois qu'un objet Gtk::Button émet le signal `clicked`. Elle affiche « Hello World » sur `stdout`, puis appelle la fonction membre originelle pour que Gtk::Button fasse ce qu'il a à faire quand il n'est pas surdéfini.

Il n'est pas toujours nécessaire d'appeler la fonction membre du parent ; certaines fois vous ne le souhaiterez pas. Notez que nous avons appelé la fonction membre du parent après avoir écrit « Hello World », mais nous aurions pu l'appeler avant. Dans cet exemple simple, cela n'a pas beaucoup d'importance, mais parfois si. Avec les signaux, il n'est pas facile de modifier des détails de ce type, et vous pouvez ici faire des choses que vous ne pourrez absolument pas faire avec des gestionnaires de signal connectés : vous pouvez appeler la fonction membre du parent au milieu de votre code personnalisé.

### Liaison avec des paramètres supplémentaires

Si vous utilisez un gestionnaire de signal pour capter le même signal à partir de plusieurs éléments graphiques, vous pouvez souhaiter que le gestionnaire de signal reçoive des informations supplémentaires. Par exemple, savoir quel bouton a été cliqué. Vous pouvez réaliser cela avec `sigc::bind()`. Voici du code extrait de l'exemple helloworld2 déjà rencontré plus haut.

    m_button1.signal_clicked().connect(
                sigc::bind<Glib::ustring>(
                                     sigc::mem_fun(
                                                   *this,
                                                   &HelloWorld::on_button_clicked
                                                  ),
                                     "bouton 1")
                                      );

Ce code indique que nous voulons que le signal envoie une valeur supplémentaire de type Glib::ustring au gestionnaire et que sa valeur soit égale à « bouton 1 ». Bien évidemment, nous devons ajouter ce paramètre supplémentaire dans la déclaration de fonction de notre gestionnaire de signal :

    virtual void on_button_clicked(Glib::ustring data);

Bien évidemment encore, un gestionnaire normal de signal « clicked » ne comporterait pas de paramètre.

`sigc::bind()` n'est pas d'usage courant, mais peut-être le trouverez-vous commode parfois. Si vous êtes un familier de la programmation avec GTK+, vous avez alors probablement noté la similitude avec les paramètres supplémentaires `gpointer data` que toutes les fonctions de rappel possèdent. Généralement, cette possibilité est utilisée à l'excès dans GTK+ pour passer des informations qui devraient être stockées dans une donnée membre d'un élément graphique dérivé, mais la dérivation des éléments graphiques est très difficile en C. Nous avons beaucoup moins besoin de cette façon de faire dans gtkmm.

### Signaux des événements X

La classe Widget possède certains signaux spéciaux correspondant aux événements de la fenêtre X sous-jacente. Il possèdent le suffixe `_event` ; par exemple, Widget::signal_button_pressed_event().

Vous pouvez trouver occasionnellement utile de gérer les événements X quand il y a quelque chose que vous ne pouvez pas réaliser avec les signaux normaux. Gtk::Button, par exemple, ne renvoie pas les coordonnées du pointeur de souris avec le signal `clicked`, mais en gérant `button_pressed_event`, vous pouvez obtenir cette information. Les événements X sont également souvent utilisés pour gérer les touches pressées.

Ces signaux se comportent de façon légèrement différente. La valeur renvoyée par le gestionnaire de signal indique si l'événement a été pleinement « géré ». Si la valeur est `false`, alors gtkmm passe l'événement au gestionnaire de signal suivant. Si la valeur est `true`, aucun autre gestionnaire de signal n'est appelé.

La gestion des événements X n'affecte pas les autres signaux de l'élément graphique. Si vous gérez `button_pressed_event` pour Gtk::Button, vous serez encore en mesure de gérer le signal `clicked`. Ils sont émis (pratiquement) simultanément.

Notez aussi que tous les éléments graphiques ne reçoivent pas tous les événements X par défaut. Pour recevoir des événements X supplémentaires, vous pouvez utiliser Gtk::Widget::set_events() avant d'afficher l'élément graphique ou Gtk::Widget::add_events() après. Toutefois, certains éléments graphiques doivent préalablement avoir été placés dans un élément graphique EventBox. Consultez le chapitre Éléments graphiques sans fenêtre-X.

Voici un exemple simple :

    bool on_button_press(GdkEventButton* event);
    Gtk::Button button("label");
    button.signal_button_press_event().connect(
                      sigc::ptr_fun(&on_button_press)
                                              );

Quand la souris est au dessus du bouton et qu'un bouton de souris est pressé, on_button_press() est appelé.

`GdkEventButton` est une structure contenant les paramètres de l'événement, tels que les coordonnées du pointeur de souris et l'heure où le bouton a été pressé. Les structures `GdkEvent` sont différentes selon les événements.

#### Séquencement des gestionnaires de signaux

By default, your signal handlers are called after any previously-connected signal handlers. However, this can be a problem with the X Event signals. For instance, the existing signal handlers, or the default signal handler, might return `true` to stop other signal handlers from being called. To specify that your signal handler should be called before the other signal handlers, so that it will always be called, you can specify `false` for the optional `after` parameter. For instance,

    button.signal_button_press_event().connect(
                    sigc::ptr_fun(&on_mywindow_button_press),
                    false );

The event is delivered first to the widget the event occurred in. If all signal handlers in that widget return `false` (indicating that the event has not been handled), then the signal will be propagated to the parent widget and emitted there. This continues all the way up to the top-level widget if no one handles the event.

## Création de vos propres signaux

Maintenant que nous avons vu les signaux et les gestionnaires de signal dans gtkmm, vous aimeriez peut-être utiliser la même technique pour interagir entre vos propres classes. C'est vraiment très simple en utilisant directement la bibliothèque libsigc++.

Ce n'est pas à proprement parler un problème gtkmm ou d'interface utilisateur. gtkmm utilise libsigc++ pour implémenter ses habillages mandataires du système de signaux GTK+, mais pour des nouveaux signaux non GTK+, vous pouvez créer des signaux C++ purs en utilisant le modèle sigc::signal<>.

Par exemple, pour créer un signal qui envoie 2 paramètres, un de type `bool` et un de type `int`, déclarez juste un sigc::signal, ainsi :

    sigc::signal<void, bool, int> signal_something;

Vous pouvez simplement déclarer ce signal comme une variable membre publique, mais certaines personnes trouvent cela détestable et préfèrent aménager son accessibilité via une fonction membre de mécanisme d'accès, ainsi :

    class Server
    {
    public:
      // mécanisme d'accès au signal :
      typedef sigc::signal<void, bool, int> type_signal_something;
      type_signal_something signal_something();

    protected:
      type_signal_something m_signal_something;
    };

    Server::type_signal_something Server::signal_something()
    {
      return m_signal_something;
    }

Vous pouvez ensuite connecter le signal en utilisant la même syntaxe que celle utilisée pour connecter les signaux gtkmm. Par exemple,

    server.signal_something().connect(
      sigc::mem_fun(client, &Client::on_server_something) );

### Exemple

Voici un exemple pleinement fonctionnel définissant et utilisant un signal personnalisé.

Code source

File: `client.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_CLIENT_H
    #define GTKMM_EXAMPLE_CLIENT_H

    #include <sigc++/sigc++.h>

    //Client must inherit from sigc::trackable.
    //because libsigc++ needs to keep track of the lifetime of signal handlers.
    class Client : public sigc::trackable
    {
    public:
      Client();
      virtual ~Client();

      //Signal handler:
      void on_server_something(bool a, int b);
    };

    #endif //GTKMM_EXAMPLE_CLIENT_H

File: `server.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_SERVER_H
    #define GTKMM_EXAMPLE_SERVER_H

    #include <sigc++/sigc++.h>

    class Server
    {
    public:
      Server();
      virtual ~Server();

      void do_something();

      //signal accessor:
      typedef sigc::signal<void, bool, int> type_signal_something;
      type_signal_something signal_something();

    protected:
      type_signal_something m_signal_something;
    };

    #endif //GTKMM_EXAMPLE_SERVER_H

File: `server.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "server.h"
    #include <iostream>

    Server::Server()
    {
    }

    Server::~Server()
    {
    }

    Server::type_signal_something Server::signal_something()
    {
      return m_signal_something;
    }

    void Server::do_something()
    {
      m_signal_something.emit(false, 5);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "server.h"
    #include "client.h"
    #include <iostream>

    int main(int, char**)
    {
      Server server;
      Client client;

      //Connect a Server signal to the signal handler in Client.
      server.signal_something().connect(sigc::mem_fun(client,
                  &Client::on_server_something) );

      std::cout << "Before Server::do_something()" << std::endl;

      //Tell the server to do something that will eventually cause it to emit the
      //"something" signal.
      server.do_something();    // Client::on_server_something() will run before
                                // Server::do_something() has completed.

      std::cout << "After Server::do_something()" << std::endl;

      return 0;
    }

File: `client.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "client.h"
    #include <iostream>

    Client::Client()
    {
    }

    Client::~Client()
    {
    }

    void Client::on_server_something(bool a, int b)
    {
      std::cout << "Client::on_server_something() called with these parameters: "
          << a << ", " << b << std::endl;
    }

## Comparaison avec les autres systèmes de signalisation

(En aparté : GTK+ appelle ce mécanisme « signalisation » ; le regard avisé du lecteur ayant un certaine expérience des boîtes à outils d'interfaces utilisateur ne manquera pas de noter que cette même conception est souvent rencontrée sous l'appellation de « broadcaster-listener » (émetteur-récepteur) (comme dans l'architecture PowerPlant de Metrowerks pour le Macintosh). Cela fonctionne tout à fait de la même façon : on met en place des `broadcasters` (émetteurs), puis on y connecte des `listeners` (récepteurs) ; l'émetteur conserve une liste des objets qui l'écoutent, et quand quelqu'un donne un message à l'émetteur, il appelle tous les objets de sa liste avec le message. Dans gtkmm, les objets signaux jouent le rôle d'émetteurs et les connecteurs celui de récepteurs — en quelque sorte. Plus à ce sujet plus tard.)

Les gestionnaires de signaux gtkmm sont fortement typés, alors que le code C de GTK+ vous autorise à connecter une fonction de rappel avec un nombre de paramètres erroné ou de mauvais type, déclenchant une erreur de segmentation lors de l'exécution. Et, contrairement à Qt, gtkmm réalise cela sans modifier le langage C++.

Retour à propos de la surdéfinition des gestionnaires de signal : vous pouvez également réaliser cette surdéfinition en restant dans le domaine strict du C de GTK+ ; le système d'objets de GTK est fait pour cela. Mais dans GTK+, vous devez cheminer par des procédures complexes pour obtenir des fonctionnalités telle que l'héritage et la surdéfinition. En C++, c'est simple, car ces fonctionnalités sont prises en charge dans le langage lui-même ; vous pouvez déléguer au compilateur le soin de faire le « sale boulot ».

C'est un des aspects où la beauté du C++ ressort vraiment. Quelqu'un songerait-il à sous-classer un élément graphique GTK+ uniquement pour surdéfinir ses fonctions membres d'action ? Ce serait s'exposer à trop d'ennuis. Dans GTK+, vous utilisez pratiquement toujours les signaux pour exécuter quelque chose, à moins que vous n'écriviez un nouvel élément graphique. Mais comme la surdéfinition des fonctions membres est si facile en C++, il est tout à fait pratique — et sensé — de sous-classer un bouton pour cette seule raison.

## gtkmm et Win32

Un des avantages majeurs de gtkmm est que gtkmm est multiplate-forme. Les programmes gtkmm écrits sur des plate-formes telles que GNU/Linux peuvent généralement être portées sur Windows (et vice versa) avec peu de modifications des sources.

gtkmm fonctionne actuellement avec le compilateur MingW/GCC3.4 et Microsoft Visual C++ 2005 ou supérieur (y compris l'édition express disponible gratuitement). Un installeur de gtkmm est disponible pour Microsoft Windows. Consultez http://live.gnome.org/gtkmm/MSWindows pour des instructions sur son utilisation.

### Construction de gtkmm sur Win32

Veuillez consulter http://live.gnome.org/gtkmm/MSWindows/BuildingGtkmm pour des instructions à propos de la construction de gtkmm sur Windows.

## Travail avec le code source de gtkmm

If you are interested in helping out with the development of gtkmm, or fixing a bug in gtkmm, you'll probably need to build the development version of gtkmm. However, you should not install a development version over your stable version. Instead, you should install it alongside your existing gtkmm installation, in a separate path.

The easiest way to do this is using jhbuild. jhbuild is a program that makes building GNOME software much easier by calculating dependencies and building things in the correct order. This section will give a brief explanation of how to set up jhbuild to build and install gtkmm from the source repository (git). For up-to-date information on jhbuild, please refer to the jhbuild manual. If you need assistance using jhbuild, you should ask for help on the gnome-love mailing list.

Notez que pour construire gtkmm à partir du dépôt git, il vous sera nécessaire de construire toutes ses dépendances à partir de git également. jhbuild facilite également cette opération par comparaison avec ce qu'elle représenterait normalement sans lui, mais la construction et l'installation du tout demande tout de même pas mal de temps. Vous serez probablement confrontés à des problèmes de construction, mais ils sont en règle générale rapidement corrigés si vous les rapportez.

### Paramétrage de jhbuild

To set up jhbuild, follow the basic installation instructions from the jhbuild manual. After you have installed jhbuild, you should copy the sample jhbuild configuration file into your home directory by executing the following command from the jhbuild directory:

    $ cp examples/sample.jhbuildrc ~/.jhbuildrc

The gtkmm module is defined in the `gnome-suites-core-deps-3.x.modules` moduleset, so edit your `.jhbuildrc` file and set your moduleset setting to the latest version e.g. like so:

    moduleset = 'gnome-suites-core-deps-3.4'

Après avoir défini le module correct, vous devez indiquer à jhbuild quel est ou quels sont les modules à construire. Pour construire gtkmm et toutes ses dépendances, paramétrez la variable `modules` ainsi :

    modules = [ 'gtkmm' ]

You can build several modules by setting the `modules` variable to a meta-package, e.g. `meta-gnome-core`, or listing more than one module name. The `modules` variable specifies which modules that will be built when you don't explicitly specify anything on the command line. You can always build a different moduleset later by specifying it on the commandline (e.g. `jhbuild build gtkmm`).

Définition d'un préfixe

By default, jhbuild's configuration is configured to install all software built with jhbuild under the `/opt/gnome` prefix. You can choose a different prefix, but it is recommended that you keep this prefix different from other software that you've installed (don't set it to `/usr`!) If you've followed the jhbuild instructions then this prefix belongs to your user, so you don't need to run jhbuild as `root`.

When you downloaded jhbuild from the git repository, you got a number of `.modules` files, specifying dependencies between modules. By default jhbuild does not use the downloaded versions of these files, but reads the latest versions in the git repository. This is usually what you want. If you don't want it, use the `use_local_modulesets` variable in `.jhbuildrc`.

### Installation et utilisation de la version git de gtkmm

Après avoir configuré jhbuild comme décrit plus haut, la construction de gtkmm devrait être relativement simple. Avant de lancer une première fois jhbuild, effectuez la séquence de commandes suivante pour vous assurer que jhbuild dispose bien des outils voulus et pour vérifier que jhbuild est correctement paramétré :

    $ jhbuild bootstrap
    $ jhbuild sanitycheck

#### Installation de gtkmm avec jhbuild

Si tout fonctionne correctement, vous devez être capable de construire gtkmm et toutes ses dépendances à partir du dépôt git en exécutant la commande `jhbuild build` (ou, si vous n'avez pas précisé gtkmm dans la variable `modules`, avec la commande `jhbuild build gtkmm`).

This command will build and install a series of modules and will probably take quite a long time the first time through. After the first time, however, it should go quite a bit faster since it only needs to rebuild files that changed since the last build. Alternatively, after you've built and installed gtkmm the first time, you can rebuild gtkmm by itself (without rebuilding all of its dependencies) with the command `jhbuild buildone gtkmm`.

#### Utilisation de la version git de gtkmm

Après avoir installé la version git de gtkmm, vous êtes prêt à commencer à l'utiliser et le tester. Pour utiliser la nouvelle version de gtkmm que vous venez d'installer, il est nécessaire de paramétrer certaines variables d'environnement pour que le script `configure` sache où trouver les nouvelles librairies. Fort heureusement, jhbuild offre une solution élégante à ce problème. L'exécution de la commande `jhbuild shell` ouvre un nouveau shell avec toutes les variables d'environnement correctement fixées. Maintenant si vous re-configurez et construisez votre projet comme vous avez l'habitude de faire, il fera l'édition des liens avec les bibliothèques nouvellement installées. Pour revenir dans votre environnement précédent, sortez simplement du shell jhbuild.

Après avoir construit votre logiciel, vous devez également le lancer dans l'environnement jhbuild. Pour ce faire, vous pouvez une nouvelle fois utiliser la commande `jhbuild shell` pour ouvrir un nouveau shell dans l'environnement jhbuild. Autrement, vous pouvez lancer une commande à effet unique dans l'environnement jhbuild avec la commande suivante : `jhbuild run command-name`. Dans ce cas, la commande se déroule avec les variables d'environnement correctement fixées, mais elle retourne dans l'environnement précédent à la sortie du programme.

## Habillage des bibliothèques C avec gmmproc

gtkmm se sert de l'utilitaire `gmmproc` pour générer la plus grande partie de son code source, en utilisant les fichiers .defs définissant les API des bibliothèques fondées sur GObject. Il est donc facile de créer des habillages supplémentaires dans le style gtkmm pour les autres bibliothèques fondées sur glib/GObject.

Cela implique divers outils, dont certains sont retors, mais qui au moins fonctionnent ; ils ont été utilisés avec succès par plusieurs projets.

### La structure de construction

Générer du code source pour un habillage d'API dans le style gtkmm requiert l'utilisation d'outils tels que `gmmproc` et `generate_wrap_init.pl`. En théorie, vous pouvez écrire vos propres fichiers de construction pour utiliser ces outils de manière appropriée, mais l'utilisation de l'infrastructure de construction fournie par le module mm-common est un meilleur choix. Prendre un module de liaison existant à titre d'exemple et l'examiner est un bon début.

Par exemple, disons que nous habillons une bibliothèque C nommée libexample. Elle fournit une API fondée sur GObject dont les types sont nommés, par exemple, ExampleThing et ExampleStuff.

#### Copie du squelette du projet

Selon la coutume, la librairie habillée s'appellera libsomethingmm. Nous commençons par copier l'arborescence des sources squelettes à partir du module mm-common.

      $ git clone git://git.gnome.org/mm-common
      $ cp -a mm-common/skeletonmm libsomethingmm

Cet arbre fournit une structure de répertoires pour les fichiers sources .hg et .ccg et pour les fichiers générés .h and .cc ; à l'aide du fichier `filelist.am`, Automake inclut des fichiers qui peuvent indiquer les divers fichiers utilisés sous forme de variables génériques Automake. L'arborescence ressemble alors à quelque chose comme cela après avoir renommé les répertoires de façon appropriée :

- `libsomethingmm` : le répertoire de plus haut niveau.

  - `libsomething` : contient le fichier include principal et le fichier pkg-config .pc.

    - `src` : contient les fichiers source .hg et .ccg.

    - `libsomethingmm` : contient les fichiers .h et .cc générés et écrits à la main.

      - `private` : contient les fichiers générés `*_p.h`.

De la même manière que nous avons renommé les répertoires, nous devons renommer certains fichiers sources. Par exemple :

    $ for f in $(find libsomethingmm -depth -name '*skeleton*'); do \
        d="${f%/*}"; b="${f##*/}"; mv "$f" "$d/${b//skeleton/libsomething}"; \
      done

Un certain nombre de fichiers squelettes doivent être complétés plus tard avec les données spécifiques au contenu du projet.

Notez que les fichiers avec l'extension `.in` seront utilisés pour générer des fichiers de même nom, mais sans extension, en remplaçant certaines variables par leur vraie valeur pendant la phase de traitement par le script configure.

#### Modification des fichiers de construction

Now we edit the files to adapt them to our needs. You might prefer to use a multiple-file search-replace utility for this, such as `regexxer`. Note that nearly all of the files provided with the skeleton source tree contain placeholder text. Thus, the substitutions should be performed globally, and not be limited to the Automake and Autoconf files.

Toutes les mentions de `skeleton` doivent être remplacées par le nom adéquat de la bibliothèque C que vous habillez, comme « something » ou « libsomething ». De la même manière, toutes les occurrences de `SKELETON` doivent être remplacées par « SOMETHING » ou « LIBSOMETHING » et celles de `Skeleton` par « Something ».

De même, remplacez toutes les occurrences de `Joe Hacker` par le nom du détenteur du copyright — vous, probablement. Faites de même pour l'adresse courriel `joe@example.com`.

##### configure.ac

Dans `configure.ac`,

- la ligne `AC_CONFIG_SRCDIR()` doit mentionner un fichier de votre arborescence source. Vous pouvez modifier cela plus tard si vous ne connaissez pas encore les noms de certains fichiers à créer.

- il est courant pour les modules de liaison de garder trace du numéro de version de la bibliothèque qu'ils habillent. Ainsi, par exemple, si la bibliothèque C est à la version 1.23.4, alors la version initiale du module de liaison sera 1.23.0. Évitez toutefois de démarrer avec un numéro de version mineur pair, car il indique traditionnellement une version stable.

- la ligne `AC_CONFIG_HEADERS()` est utilisée pour générer deux ou plusieurs fichier d'en-tête de configuration. Le premier fichier d'en-tête de la liste comporte toutes les macros de configuration définies pendant le lancement de configure. Les en-têtes restants de la liste ne contiennent qu'un sous-ensemble des macros de configuration et leur fichier `configh.h.in` correspondant ne sera pas généré automatiquement. La raison de cette séparation est que les en-têtes de configuration avec une espace dans le nom sont installées dans votre bibliothèque et définissent des macros visibles publiquement.

- il se peut que la ligne `AC_SUBST([SOMETHINGMM_MODULES], ['...'])` ait besoin d'être modifiée pour vérifier les dépendances adéquates.

- le bloc `AC_CONFIG_FILES()` doit mentionner les noms de répertoires corrects, tels que décrits ci-dessus.

##### Fichiers Makefile.am

Ensuite nous devons adapter les divers fichiers `Makefile.am` :

- dans `skeleton/src/Makefile.am`, nous devons mentionner des valeurs correctes pour les variables génériques utilisées autre part dans le système de construction :

  `binding_name`

    le nom de la bibliothèque, comme libsomethingmm.

  `wrap_init_flags`

    des marqueurs additionnels en ligne de commande passés au script `generate_wrap_init.pl`, tels que le nom de l'espace de noms C++ et le préfixe du répertoire parent des fichiers include.

- dans `skeleton/skeletonmm/Makefile.am`, nous devons mentionner des valeurs correctes pour les variables génériques utilisées autre part dans le système de construction :

  `lib_LTLIBRARIES`

    cette variable doit indiquer le nom correct de la bibliothèque, tel qu'utilisé par les noms de variables `_SOURCES`, `_LDFLAGS` et `_LIBADD`. Il est autorisé d'utiliser des variables substituées par `configure` comme `@SOMETHINGMM_API_VERSION@` en tant que partie de noms de variables.

  `AM_CPPFLAGS`

    les options en ligne de commande passées au préprocesseur C.

  `AM_CXXFLAGS`

    les options en ligne de commande passées au compilateur C++.

##### Création des fichiers .hg et .ccg

Vous devez maintenant créer vos premiers fichiers `.hg` et `.ccg` pour habiller quelques objets dans la librairie C. Il y a une paire de fichiers sources à titre d'exemple : `skeleton.ccg` et `skeleton.hg`. Faites des copies de ces fichiers si nécessaire.

Il faut mentionner tous les fichiers `.hg` et `.ccg` dans le fichier `skeleton/src/filelist.am`, traditionnellement dans la variable `files_hg`.

Tout fichier source `.h` et `.cc` non généré automatiquement doit être placé dans `skeleton/skeletonmm/` et énuméré dans `skeleton/skeletonmm/filelist.am`, traditionnellement dans les variables `files_extra_h` et `files_extra_cc`.

Dans le paragraphe Fichiers .hg et .ccg vous pouvez voir la syntaxe utilisée dans ces fichiers.

### Génération des fichiers .defs

The `.defs` files are text files, in a lisp format, that describe the API of a C library, including its

- objets (GObjects, éléments graphiques, interfaces, types de boîtes et structures brutes)

- fonctions

- énumérations

- signaux

- propriétés

- fonctions virtuelles.

À ce moment, nous disposons d'outils séparés pour générer les diverses parties des fichiers `.defs`, nous les éclatons donc en fichiers séparés. Par exemple, dans le répertoire `gtk/src` des sources de gtkmm, vous trouvez ces fichiers :

`gtk.defs`

  inclut les autres fichiers.

`gtk_methods.defs`

  objets et fonctions

`gtk_enums.defs`

  énumérations.

`gtk_signals.defs`

  signaux et propriétés

`gtk_vfuncs.defs`

  fonctions virtuelles (champs de pointeurs membres de fonction dans des structures), écrites à la main.

#### Génération des .defs pour les fonctions membres

This `.defs` file describes objects and their functions. It is generated by the `h2def.py` script which you can find in glibmm's `tools/defs_gen` directory. For instance,

    $ ./h2def.py /usr/include/gtk-3.0/gtk/*.h > gtk_methods.defs

#### Génération des .defs pour les énumérations

Ce fichier `.defs` décrit les types enum et leurs valeurs possibles. Il est généré par le script `enum.pl` que vous trouverez dans le répertoire `tools` de glibmm. Par exemple,

    $ ./enum.pl /usr/include/gtk-3.0/gtk/*.h > gtk_enums.defs

#### Génération des .defs pour les signaux et les propriétés

Ce fichier `.defs` décrit les signaux et les propriétés. Il est généré par l'utilitaire spécial `extra_defs` qui se trouve dans tout projet d'habillage, tel que `gtkmm/tools/extra_defs_gen/`. Par exemple

    $ cd tools/extra_defs_gen
    $ ./generate_extra_defs > gtk_signals.defs

Vous devez rédiger le code source de votre propre outil `generate_extra_defs` pour générer les fichiers `.defs` des types C GObject que vous souhaitez habiller. Dans l'arborescence des sources squelettes, le fichier source s'appelle `codegen/extradefs/generate_extra_defs_skeleton.cc`. Si ce n'est pas déjà fait, le fichier doit être renommé en remplaçant la variable de substitution `skeleton` par le nom de base de la nouvelle liaison. Le fichier `codegen/Makefile.am` doit également citer le nouveau nom du fichier source.

Ensuite, modifiez le fichier `.cc` pour définir les types corrects. Par exemple, il se peut que votre fonction `main()` ressemble à quelque chose comme ceci :

    #include <libsomething.h>

    int main(int, char**)
    {
      something_init();

      std::cout << get_defs(EXAMPLE_TYPE_SOMETHING)
                << get_defs(EXAMPLE_TYPE_THING);
      return 0;
    }

#### Écriture des .defs pour les fonctions virtuelles

This `.defs` file describes virtual functions (vfuncs). It must be written by hand. There is no skeleton to start from. You can look at gtkmm's `gtk/src/gtk_vfuncs.defs` file.

### Les fichiers .hg et .ccg

Les fichiers sources .hg et .ccg ressemblent tout à fait aux fichiers sources .h et .cc du C++, mais il comportent des macros supplémentaires, telles que `_CLASS_GOBJECT()` et `_WRAP_METHOD()`, à partir desquelles `gmmproc` génére le code source C++ approprié, habituellement à la même position dans l'en-tête. Tout code source C++ sera copié mot pour mot dans le fichier .h ou .cc correspondant.

Un fichier .hg inclut habituellement certains fichiers d'en-tête, puis déclare une classe en utilisant certaines macros pour ajouter l'API ou certains comportements pour cette classe. Par exemple, `button.hg` de gtkmm ressemble grossièrement à ceci :

    #include <gtkmm/bin.h>
    #include <gtkmm/activatable.h>
    #include <gtkmm/stockid.h>
    _DEFS(gtkmm,gtk)
    _PINCLUDE(gtkmm/private/bin_p.h)

    namespace Gtk
    {

    class Button
      : public Bin,
        public Activatable
    {
      _CLASS_GTKOBJECT(Button,GtkButton,GTK_BUTTON,Gtk::Bin,GtkBin)
      _IMPLEMENTS_INTERFACE(Activatable)
    public:

      _CTOR_DEFAULT
      explicit Button(const Glib::ustring& label, bool mnemonic = false);
      explicit Button(const StockID& stock_id);

      _WRAP_METHOD(void set_label(const Glib::ustring& label), gtk_button_set_label)

      ...

      _WRAP_SIGNAL(void clicked(), "clicked")

      ...

      _WRAP_PROPERTY("label", Glib::ustring)
    };

    } // namespace Gtk

Les macros employées dans cet exemple effectuent les tâches suivantes :

`_DEFS()`

  Specifies the destination directory for generated sources, and the name of the main .defs file that `gmmproc` should parse.

`_PINCLUDE()`

  indique à `gmmproc` d'inclure un en-tête à partir du fichier private/button_p.h.

`_CLASS_GTKOBJECT()`

  Tells `gmmproc` to add some typedefs, constructors, and standard methods to this class, as appropriate when wrapping a widget.

`_IMPLEMENTS_INTERFACE()`

  Tells `gmmproc` to add initialization code for the interface.

`_CTOR_DEFAULT`

  Add a default constructor.

`_WRAP_METHOD()`, `_WRAP_SIGNAL()` et `_WRAP_PROPERTY()`

  ajoute des fonctions membres pour habiller des parties de l'API C.

Les fichiers .h et .cc sont générées à partir des fichiers .hg et .ccg en les traitant de la sorte avec `gmmproc`, bien que ceci se fasse automatiquement en utilisant la structure de construction suivante :

    $ cd gtk/src
    $ /usr/lib/glibmm-2.4/proc/gmmproc -I ../../tools/m4 --defs . button . ./../gtkmm

Notez que nous appelons `gmmproc` avec comme paramètre le chemin vers les fichiers .m4 convertis, le chemin vers les fichiers .defs, le nom du fichier .hg, le répertoire source et le répertoire destination.

Nous nous abstenons d'inclure le fichier d'en-tête C à partir de l'en-tête C++ pour éviter de polluer l'espace de noms global et pour éviter d'exporter des API publiques non nécessaires. Mais vous aurez besoin d'inclure les en-têtes C nécessaires à partir de votre fichier .ccg.

Les macros sont expliquées plus en détail dans les paragraphes suivants.

#### Conversions m4

Les macros utilisées dans les fichiers .hg et .ccg ont souvent besoin de savoir comment convertir un type C++ en type C ou vice-versa. gmmproc prend cette information dans un fichier .m4 du répertoire `tools/m4/`. Celle-ci lui permet d'appeler une fonction C dans l'implémentation de votre fonction membre C++, en passant les paramètres appropriés à cette fonction C. Par exemple, cette macro indique à gmmproc comment convertir un pointeur GtkTreeView en pointeur Gtk::TreeView :

    _CONVERSION(`GtkTreeView*',`TreeView*',`Glib::wrap($3)')

`$3` sera remplacé par le nom du paramètre lorsque cette conversion est utilisée par gmmproc.

Quelques macros supplémentaires rendent ceci plus facile et plus cohérent. Regardez dans les fichiers .m4 pour des exemples. Ainsi :

    _CONVERSION(`PrintSettings&',`GtkPrintSettings*',__FR2P)
    _CONVERSION(`const PrintSettings&',`GtkPrintSettings*',__FCR2P)
    _CONVERSION(`const Glib::RefPtr<Printer>&',`GtkPrinter*',__CONVERT_REFPTR_TO_P($3))

#### m4 Initializations

Often when wrapping methods, it is desirable to store the return of the C function in what is called an output parameter. In this case, the C++ method returns void but an output parameter in which to store the value of the C function is included in the argument list of the C++ method. gmmproc allows such functionality, but appropriate inizialization macros must be included to tell gmmproc how to initialize the C++ parameter from the return of the C function.

For example, if there was a C function that returned a GtkWidget* and for some reason, instead of having the C++ method also return the widget, it was desirable to have the C++ method place the widget in a specified output parameter, an initialization macro such as the following would be necessary:

    _INITIALIZATION(`Gtk::Widget&',`GtkWidget*',`$3 = Glib::wrap($4)')

`$3` will be replaced by the output parameter name of the C++ method and `$4` will be replaced by the return of the C function when this initialization is used by gmmproc. For convenience, `$1` will also be replaced by the C++ type without the ampersand (&) and `$2` will be replaced by the C type.

#### Macros de classes

La macro de classe déclare la classe elle-même et ses relations avec le type C sous-jacent. Elle génère certains constructeurs internes, la variable membre `gobject_`, des définitions de types, les mécanismes d'accès aux `gobj()`, l'enregistrement du type et la fonction membre `Glib::wrap()`, entre autres choses.

Other macros, such as `_WRAP_METHOD()` and `_WRAP_SIGNAL()` may only be used after a call to a `_CLASS_*` macro.

##### _CLASS_GOBJECT

This macro declares a wrapper for a type that is derived from GObject, but whose wrapper is not derived from Gtk::Object.

`_CLASS_GOBJECT( C++ class, C class, C casting macro, C++ base class, C base class )`

Par exemple, à partir de `accelgroup.hg` :

    _CLASS_GOBJECT(AccelGroup, GtkAccelGroup, GTK_ACCEL_GROUP, Glib::Object, GObject)

##### _CLASS_GTKOBJECT

This macro declares a wrapper for a type whose wrapper is derived from Gtk::Object, such as a widget or dialog.

`_CLASS_GTKOBJECT( C++ class, C class, C casting macro, C++ base class, C base class )`

Par exemple, à partir de `button.hg` :

    _CLASS_GTKOBJECT(Button, GtkButton, GTK_BUTTON, Gtk::Bin, GtkBin)

You will typically use this macro when the class already derives from Gtk::Object. For instance, you will use it when wrapping a GTK+ Widget, because Gtk::Widget derives from Gtk::Object.

You might also derive non-widget classes from Gtk::Object so they can be used without Glib::RefPtr. For isntance, they could then be instantiated with `Gtk::manage()` or on the stack as a member variable. This is convenient, but you should use this only when you are sure that true reference-counting is not needed. We consider it useful for widgets.

##### _CLASS_BOXEDTYPE

Cette macro déclare un habillage pour une structure non-GObject, enregistrée avec `g_boxed_type_register_static()`.

`_CLASS_BOXEDTYPE( C++ class, C class, new function, copy function, free function )`

Par exemple, pour Gdk::Color :

    _CLASS_BOXEDTYPE(Color, GdkColor, NONE, gdk_color_copy, gdk_color_free)

##### _CLASS_BOXEDTYPE_STATIC

Cette macro déclare un habillage pour une simple structure assignable comme un GdkRectangle. Elle est semblable à `_CLASS_BOXEDTYPE`, mais la structure C n'est pas allouée dynamiquement.

`_CLASS_BOXEDTYPE_STATIC( C++ class, C class )`

Par exemple, pour Gdk::Rectangle :

    _CLASS_BOXEDTYPE_STATIC(Rectangle, GdkRectangle)

##### _CLASS_OPAQUE_COPYABLE

Cette macro déclare un habillage pour une structure opaque possédant des fonctions de copie et de libération. Les fonctions new, copy et free seront utilisées pour instancier le constructeur par défaut, le constructeur de copie et le destructeur.

`_CLASS_OPAQUE_COPYABLE( C++ class, C class, new function, copy function, free function )`

For instance, from `stockitem.hg`:

    _CLASS_OPAQUE_COPYABLE(StockItem, GtkStockItem, NONE, gtk_stock_item_copy, gtk_stock_item_free)

##### _CLASS_OPAQUE_REFCOUNTED

Cette macro déclare un habillage pour une structure opaque à décompte de références. L'habillage C++ ne peut pas être directement instancié et ne peut être utilisé qu'avec un pointeur intelligent Glib::RefPtr.

`_CLASS_OPAQUE_REFCOUNTED( C++ class, C class, new function, ref function, unref function )`

Par exemple, pour Pango::Coverage :

    _CLASS_OPAQUE_REFCOUNTED(Coverage,
                             PangoCoverage,
                             pango_coverage_new,
                             pango_coverage_ref,
                             pango_coverage_unref)

##### _CLASS_GENERIC

Cette macro peut être utilisée pour habiller les structures n'entrant pas dans une catégorie particulière.

`_CLASS_GENERIC( C++ class, C class )`

Par exemple, pour Pango::AttrIter :

    _CLASS_GENERIC(AttrIter, PangoAttrIterator)

##### _CLASS_INTERFACE

This macro declares a wrapper for a type that is derived from GTypeInterface.

`_CLASS_INTERFACE( C++ class, C class, C casting macro, C interface struct, Base C++ class (optional), Base C class (optional) )`

Par exemple, pour `celleditable.hg` :

    _CLASS_INTERFACE(CellEditable, GtkCellEditable, GTK_CELL_EDITABLE, GtkCellEditableIface)

Deux paramètres sont optionnels, dans le cas où l'interface dérive d'une autre interface, ce qui doit être le cas quand la GInterface a une autre GInterface prérequise. Par exemple, pour `loadableicon.hg` :

    _CLASS_INTERFACE(LoadableIcon, GLoadableIcon, G_LOADABLE_ICON, GLoadableIconIface, Icon, GIcon)

#### Macros de constructeurs

Les macros `_CTOR_DEFAULT()` et `_WRAP_CTOR()` ajoutent des constructeurs, habillant les fonctions C `*_new()` spécifiées. Ces macros supposent que l'objet C a des propriétés de même nom que les paramètres de la fonction, ce qui est habituellement le cas ; ainsi il peut fournir les paramètres directement pour l'appel de `g_object_new()`. Ces constructeurs en réalité n'appellent jamais les fonctions C `*_new()`, car gtkmm doit en fait instancier des types GTypes dérivés et les fonctions C `*_new()` ne sont conçues que comme fonctions de commodité pour les programmeurs C.

Quand on utilise `_CLASS_GOBJECT()`, il faut que les constructeurs soient protégés (plutôt que publics) et chaque constructeur doit posséder une fonction correspondante `_WRAP_CREATE()` dans la section public. Ceci empêche l'instanciation de la classe sans utiliser de RefPtr. Par exemple :

    class ActionGroup : public Glib::Object
    {
      _CLASS_GOBJECT(ActionGroup, GtkActionGroup,
                     GTK_ACTION_GROUP, Glib::Object, GObject)

    protected:
      _WRAP_CTOR(ActionGroup(const Glib::ustring& name = Glib::ustring()),
                 gtk_action_group_new)

    public:
      _WRAP_CREATE(const Glib::ustring& name = Glib::ustring())

##### _CTOR_DEFAULT

Cette macro crée un constructeur par défaut sans paramètre.

##### _WRAP_CTOR

Cette macro crée un constructeur avec paramètres, équivalent à la fonction C `*_new()`. Elle n'appelle pas réellement la fonction `*_new()`, mais elle crée simplement un constructeur équivalent avec les mêmes types de paramètres. Elle prend en paramètres la signature d'un constructeur C++ et un nom de fonction C.

When wrapping constructors, it is possible for gmmproc to generate convenience overloads of the wrapped constructors if the C function has parameters that are optional (ie. the C API allows null for those parameters). For instance, to specify if a parameter is optional, the `_WRAP_CTOR()` macro would look something like the following:

    _WRAP_CTOR(ToolButton(Widget& icon_widget, const Glib::ustring& label{?}), gtk_tool_button_new)

The `{?}` following the name of the label parameter means that that parameter is optional. In this case, gmmproc will generate an extra constructor without that parameter.

It is also possible to have the order of the parameters of the constructor different from that of the C function by using gmmproc's C++ to C parameter mapping functionality. Using this functionality, it is possible to map a C++ parameter to a C parameter by specifying the C parameter name. For instance, assuming that the declaration of the `gtk_tool_button_new()` function is the following:

    GtkToolItem* gtk_tool_button_new(GtkWidget* icon_widget, const gchar* label);

The parameters of the wrapped constructor could be reordered using the following:

    _WRAP_CTOR(ToolButton(const Glib::ustring& label{label}, Widget& icon_widget{icon_widget}), gtk_tool_button_new)

The `{param_name}` following each of the names of the parameters tells gmmproc to map those C++ parameters to the C parameters with the given names. Since the C++ parameter names correspond to the C ones, the above could be re-written as:

    _WRAP_CTOR(ToolButton(const Glib::ustring& label{.}, Widget& icon_widget{.}), gtk_tool_button_new)

This same optional parameter syntax and parameter reordering is available for `_WRAP_CREATE()`. Additional `create()` overloads would be generated by gmmproc without the specified optional parameters.

##### Constructeurs codés à la main

Quand un constructeur doit être partiellement écrit à la main parce que, par exemple, les paramètres de la fonction C `*_new()` ne correspondent pas directement aux propriétés de l'objet ou parce que la fonction C `*_new()` fait plus qu'appeler `g_object_new()`, la macro `_CONSTRUCT()` peut s'utiliser dans le fichier .ccg pour s'économiser un peu de travail. La macro `_CONSTRUCT` prend comme paramètres une série de noms de propriétés et de valeurs. Par exemple, pour `button.ccg` :

    Button::Button(const Glib::ustring& label, bool mnemonic)
    :
      _CONSTRUCT("label", label.c_str(), "use_underline", gboolean(mnemonic))
    {}

#### Macros pour fonctions membres

##### _WRAP_METHOD

Cette macro génère une fonction membre C++ habillant une fonction C.

`_WRAP_METHOD( C++ method signature, C function name)`

Par exemple, pour `entry.hg` :

    _WRAP_METHOD(void set_text(const Glib::ustring& text), gtk_entry_set_text)

La fonction C (par exemple, `gtk_entry_set_text`) est décrite plus précisément dans les fichiers .defs et les fichiers `convert*.m4` contiennent la conversion nécessaire des types de paramètres C++ vers les paramètres de type C. Cette macro génère également des commentaires pour la documentation doxygen à partir des fichiers `*_docs.xml` et `*_docs_override.xml`.

Il y a quelques paramètres optionnels supplémentaires :

refreturn

  Do an extra `reference()` on the return value, in case the C function does not provide a reference.

errthrow

  utilise le dernier paramètre GError* de la fonction C pour déclencher une exception.

deprecated

  place le code généré dans un bloc #ifdef. Le texte concernant l'abandon peut être précisé en tant que paramètre optionnel.

constversion

  appelle simplement la version non-const de la même fonction au lieu de générer du code dupliqué.

ifdef

  Puts the generated code in #ifdef blocks.

As with `_WRAP_CTOR()` it is possible to specify if there are any optional parameters. If that is the case, gmmproc will generate convenience overload methods without those parameters. For example:

    _WRAP_METHOD(void get_preferred_size(Requisition& minimum_size, Requisition& natural_size{?}) const, gtk_widget_get_preferred_size)

Would indicate that the natural_size parameter is optional because its name ends with `{?}`. In this case, gmmproc would generate a method overload without that parameter.

Also, as with `_WRAP_CTOR()`, it is possible to reorder the parameters of the C++ method by using gmmproc's C++ to C parameter mapping functionality. Using this functionality, it is possible to map a C++ parameter to a C parameter by specifying the C parameter name. For example, if the `gtk_widget_set_device_events()` declaration is the following:

    void gtk_widget_set_device_events(GtkWidget* widget, GdkDevice* device, GdkEventMask events);

Something like the following would change the order of the parameters in the C++ method:

    _WRAP_METHOD(void set_device_events(Gdk::EventMask events{events}, const Glib::RefPtr<const Gdk::Device>& device{device}), gtk_widget_set_device_events)

The `{param_name}` following each of the names of the parameters tells gmmproc to map those C++ parameters to the C parameters with the given names. Since the C++ parameter names correspond to the C ones, the above could be re-written as:

    _WRAP_METHOD(void set_device_events(Gdk::EventMask events{.}, const Glib::RefPtr<const Gdk::Device>& device{.}), gtk_widget_set_device_events)

With `_WRAP_METHOD()` it is also possible to include an output parameter in the C++ method declaration in which the return of the C function would be placed and to have the C++ method return void. To do that, simply include the output parameter declaration in the C++ method declaration appending a `{OUT}` to the output parameter name. For example, if `gtk_widget_get_request_mode()` is declared as the following:

    GtkSizeRequestMode gtk_widget_get_request_mode(GtkWidget* widget);

And having the C++ method set an output parameter is desired instead of returning a SizeRequestMode, something like the following could be used:

    _WRAP_METHOD(void get_request_mode(SizeRequestMode& mode{OUT}) const, gtk_widget_get_request_mode)

the `{OUT}` appended to the name of the mode output parameter tells gmmproc to place the return of the C function in that output parameter. In this case, however, a necessary initialization macro like the following would also have to be specified:

    _INITIALIZATION(`SizeRequestMode&',`GtkSizeRequestMode',`$3 = (SizeRequestMode)($4)')

Which could also be written as:

    _INITIALIZATION(`SizeRequestMode&',`GtkSizeRequestMode',`$3 = ($1)($4)')

Même s'il est généralement évident que les types C++ devraient être utilisés dans les fonctions membres C++, voici quelques astuces :

- Objets utilisés par l'intermédiaire d'un RefPtr : passez le RefPtr en tant que référence const, par exemple, `const Glib::RefPtr<Gtk::Action>& action`.

- Objets const utilisés par l'intermédiaire d'un RefPtr : si l'objet ne doit pas être modifié par la fonction, assurez-vous que l'objet est const, même si le RefPtr est déjà const, par exemple, `const Glib::RefPtr<const Gtk::Action>& action`.

- Wrapping GList* and GSList* parameters: First, you need to discover what objects are contained in the list's data field for each item, usually by reading the documentation for the C function. The list can then be wrapped by a std::vector type. For instance, `std::vector< Glib::RefPtr<Action> >`. You may need to define a Traits type to specify how the C and C++ types should be converted.

- Habillage des types de retour des GList* et GSList* : vous devez découvrir comment l'appelant libère la liste et comment il libère les éléments de la liste, à nouveau en lisant la documentation de la fonction C. Avec ces informations vous pouvez choisir le type de propriété (aucun (none), superficiel (shallow), profond (deep)) pour la règle de conversion m4, règle que vous placerez probablement directement dans le fichier .hg parce que le type de propriété dépend plutôt de la fonction que du type, par exemple :

      #m4 _CONVERSION(`GSList*',`std::vector<Widget*>',`Glib::SListHandler<Widget*>::slist_to_vector($3, Glib::OWNERSHIP_SHALLOW)')

##### _WRAP_METHOD_DOCS_ONLY

Cette macro est comparable à la macro `_WRAP_METHOD()`, mais elle ne génère la documentation que dans le cas d'une fonction membre C++ habillant une fonction C. Utilisez-la si vous devez coder à la main la fonction membre, mais vous voulez utiliser la documentation qui serait générée si la fonction membre était générée.

`_WRAP_METHOD_DOCS_ONLY(C function name)`

Par exemple, pour `container.hg` :

    _WRAP_METHOD_DOCS_ONLY(gtk_container_remove)

##### _IGNORE / _IGNORE_SIGNAL

`gmmproc` will warn you on stdout about functions and signals that you have forgotten to wrap, helping to ensure that you are wrapping the complete API. But if you don't want to wrap some functions or signals, or if you chose to hand-code some methods then you can use the _IGNORE() or _IGNORE_SIGNAL() macro to make `gmmproc` stop complaining.

`_IGNORE(C function name 1, C function name2, etc)`

`_IGNORE_SIGNAL(C signal name 1, C signal name2, etc)`

Par exemple, pour `buttonbox.hg` :

    _IGNORE(gtk_button_box_set_spacing, gtk_button_box_get_spacing)

##### _WRAP_SIGNAL

Cette macro génère le signal C++ de style libsigc++ habillant un signal C GObject. Il génère en fait un mécanisme d'accès public, comme `signal_clicked()`, qui renvoie un objet mandataire. `gmmproc` utilise le fichier .defs pour découvrir le type des paramètres du C et les fichiers de conversion .m4 pour découvrir les types de conversion appropriés.

`_WRAP_SIGNAL( C++ signal handler signature, C signal name)`

Par exemple, à partir de `button.hg` :

    _WRAP_SIGNAL(void clicked(),"clicked")

Les signaux ont généralement des pointeurs de fonction dans la structure GTK, avec une valeur d'énumération correspondante, et une fonction `g_signal_new()` dans le fichier .c.

Il y a quelques paramètres optionnels supplémentaires :

no_default_handler

  ne pas générer une fonction membre virtuelle `on_something()` pour faciliter la surdéfinition du gestionnaire de signal par défaut. Ce paramètre est à utiliser quand l'ajout d'un signal avec son gestionnaire par défaut casserait l'ABI (Application Binary Interface) en augmentant la taille de la table des fonctions virtuelles de la classe.

custom_default_handler

  Generate a declaration of the `on_something()` virtual method in the `.h` file, but do not generate a definition in the `.cc` file. Use this when you must generate the definition by hand.

custom_c_callback

  Do not generate a C callback function for the signal. Use this when you must generate the callback function by hand.

refreturn

  Do an extra `reference()` on the return value of the `on_something()` virtual method, in case the C function does not provide a reference.

ifdef

  Puts the generated code in #ifdef blocks.

##### _WRAP_PROPERTY

Cette macro génère une fonction membre C++ habillant une propriété d'un GObject C. Vous devez indiquer le nom de la propriété et le type C++ souhaité pour la propriété. `gmmproc` utilise le fichier .defs pour connaître le type C et les fichiers de conversion .m4 pour découvrir les types appropriés de conversion.

`_WRAP_PROPERTY(C property name, C++ type)`

Par exemple, à partir de `button.hg` :

    _WRAP_PROPERTY("label", Glib::ustring)

##### _WRAP_VFUNC

This macro generates the C++ method to wrap a virtual C function.

`_WRAP_VFUNC( C++ method signature, C function name)`

Par exemple, pour `widget.hg` :

    _WRAP_VFUNC(SizeRequestMode get_request_mode() const, get_request_mode)

The C function (e.g. `get_request_mode`) is described more fully in the `*_vfuncs.defs` file, and the `convert*.m4` files contain the necessary conversion from the C++ parameter type to the C parameter type.

Il y a quelques paramètres optionnels supplémentaires :

refreturn

  Do an extra `reference()` on the return value of the `something_vfunc()` function, in case the virtual C function does not provide a reference.

refreturn_ctype

  Do an extra `reference()` on the return value of an overridden `something_vfunc()` function in the C callback function, in case the calling C function expects it to provide a reference.

custom_vfunc

  Do not generate a definition of the vfunc in the `.cc` file. Use this when you must generate the vfunc by hand.

custom_vfunc_callback

  Do not generate a C callback function for the vfunc. Use this when you must generate the callback function by hand.

ifdef

  Puts the generated code in #ifdef blocks.

A rule to which there may be exceptions: If the virtual C function returns a pointer to an object derived from GObject, i.e. a reference-counted object, then the virtual C++ function shall return a Glib::RefPtr<> object. One of the extra arguments refreturn or refreturn_ctype is required.

#### Autres macros :

##### _IMPLEMENTS_INTERFACE

This macro generates initialization code for the interface.

`_IMPLEMENTS_INTERFACE(C++ interface name)`

Par exemple, à partir de `button.hg` :

    _IMPLEMENTS_INTERFACE(Activatable)

There is one optional extra argument:

ifdef

  Puts the generated code in #ifdef blocks.

##### _WRAP_ENUM

Cette macro génère une énumération C++ pour habiller une énumération C. Vous devez préciser le nom C++ et le nom de l'énumération C subjacente.

Par exemple, pour `widget.hg` :

    _WRAP_ENUM(WindowType, GdkWindowType)

Si l'énumération n'est pas du type GType, vous devrez passer comme troisième paramètre NO_GTYPE. C'est le cas lorsqu'il n'existe pas de fonction `*_get_type()` pour l'énumération C ; mais, faites attention au fait qu'il n'est pas suffisant d'inclure un en-tête supplémentaire pour cette fonction. Vous devez également faire un rapport d'anomalie concernant l'API C étant donné que toutes les énumérations doivent être enregistrées en tant que GTypes.

For example, from `icontheme.hg`:

    _WRAP_ENUM(IconLookupFlags, GtkIconLookupFlags, NO_GTYPE)

##### _WRAP_GERROR

Cette macro génère une classe d'exception C++, dérivée de Glib::Error, avec un Code enum et une fonction membre code(). Vous devez préciser le nom C++ souhaité, le nom de l'énumération correspondante C et le préfixe pour les valeurs d'énumération C.

Cette exception peut alors être déclenchée par des fonctions membres générées par _WRAP_METHOD() avec l'option errthrow.

Par exemple, pour `pixbuf.hg` :

    _WRAP_GERROR(PixbufError, GdkPixbufError, GDK_PIXBUF_ERROR)

##### _MEMBER_GET / _MEMBER_SET

Si vous habillez une simple structure ou un type de boîte qui autorise un accès direct à ses données membres, utilisez ces macros pour créer les obtenteurs (get) et mutateurs (set) des données membres.

`_MEMBER_GET(C++ name, C name, C++ type, C type)`

`_MEMBER_SET(C++ name, C name, C++ type, C type)`

Par exemple, dans `rectangle.hg` :

    _MEMBER_GET(x, x, int, int)

##### _MEMBER_GET_PTR / _MEMBER_SET_PTR

Utilisez ces macros pour créer automatiquement des obtenteurs (get) et des mutateurs (set) pour une donnée membre du type pointeur. Pour le mécanisme d'obtention, elle créera deux fonctions membres, une qualifiée `const` et une non-`const`.

`_MEMBER_GET_PTR(C++ name, C name, C++ type, C type)`

`_MEMBER_SET_PTR(C++ name, C name, C++ type, C type)`

For example, for Pango::Analysis in `item.hg`:

    // _MEMBER_GET_PTR(engine_lang, lang_engine, EngineLang*, PangoEngineLang*)
    // It's just a comment. It's difficult to find a real-world example.

##### _MEMBER_GET_GOBJECT / _MEMBER_SET_GOBJECT

Use these macros to provide getters and setters for a data member that is a GObject type that must be referenced before being returned.

`_MEMBER_GET_GOBJECT(C++ name, C name, C++ type, C type)`

`_MEMBER_SET_GOBJECT(C++ name, C name, C++ type, C type)`

For example, in Pangomm, `layoutline.hg`:

    _MEMBER_GET_GOBJECT(layout, layout, Pango::Layout, PangoLayout*)

#### Types de base

Certains types de base utilisés dans les API C possèdent une meilleure typologie en C++. Par exemple, il n'est pas nécessaire d'avoir un type `gboolean` puisque le C++ dispose du type `bool`. La liste suivante montre quelques types couramment utilisés dans les API C, types que vous pouvez convertir dans la bibliothèque d'habillage C++.

Équivalents des types de base

Types C Types C++
- gboolean bool
- gint int
- guint guint
- gdouble double
- gunichar gunichar
- gchar*Glib::ustring (ou std::string pour les noms de fichiers)

### Fichiers sources codés à la main

Vous voudrez peut-être inclure des fichiers sources additionnels qui n'auraient pas été générés par `gmmproc` à partir des fichiers `.hg` et `.ccg`. Placez-les simplement dans le répertoire `libsomething/libsomethingmm` et mentionnez-les dans le fichier `Makefile.am` dans les variables `files_extra_h` et `files_extra_cc`.

### Initialisation

Avant de pouvoir vous servir de votre bibliothèque, il faut l'initialiser pour enregistrer les nouveaux types à disposition. La bibliothèque C que vous habillez doit aussi avoir sa propre fonction d'initialisation ; vous devrez l'appeler. Vous pouvez effectuer cette opération dans une fonction `init()` placée dans des fichiers `init.h` et `init.cc` codés à la main. Cette fonction doit initialiser vos dépendances (comme la fonction C et gtkmm) et appeler la fonction `wrap_init()` générée. Par exemple :

    void init()
    {
      // Définir le système des types g et la table Glib::wrap().
      Gtk::Main::init_gtkmm_internals();
      // Indiquer à la table Glib::wrap() les classes libsomethingmm.
      wrap_init();
    }

L'implémentation de la fonction membre `wrap_init()` dans `wrap_init.cc` sera générée avec `generate_wrap_init.pl`, mais sa déclaration dans `wrap_init.h` doit être codée à la main ; vous avez besoin d'ajuster `wrap_init.h` de sorte que la fonction `init()` apparaisse dans un espace de noms C++ correct.

### Problèmes dans l'API C

Vous allez vraisemblablement rencontrer des problèmes dans la bibliothèque en cours d'habillage, en particulier s'il s'agit d'un nouveau projet. Voici quelques problèmes courants et leurs solutions.

#### Impossibilité de pré-déclarer des structures

Par convention, les structures sont déclarées comme suit dans les en-têtes de style glib/GTK+ :

    typedef struct _ExampleWidget ExampleWidget;

    struct _ExampleWidget
    {
      ...
    };

The extra typedef allows the struct to be used in a header without including its full definition, simply by predeclaring it, by repeating that typedef. This means that you don't have to include the C library's header in your C++ header, thus keeping it out of your public API. `gmmproc` assumes that this technique was used, so you will see compiler errors if that is not the case.

L'erreur de compilation ressemble à quelque chose comme :

    example-widget.h:56: error: using typedef-name 'ExampleWidget' after 'struct'
    ../../libexample/libexamplemm/example-widget.h:34: error:
               'ExampleWidget' has a previous declaration here
    make[4]: *** [example-widget.lo] Error 1

ou bien encore :

    example-widget.h:60: error: '_ExampleWidget ExampleWidget'
         redeclared as different kind of symbol
    ../../libexample/libexamplemm/example-widget.h:34: error:
    previous declaration of 'typedef struct _ExampleWidget ExampleWidget'

C'est facile à corriger dans la bibliothèque C ; n'envoyez pas de correctif au mainteneur concerné.

#### Perte de propriétés

Par convention, les objets de style glib/GTK+ possèdent des fonctions `*_new()`, comme par exemple `example_widget_new()`, qui ne font rien de plus qu'appeler `g_object_new()` et renvoyer le résultat. Les paramètres en entrée sont fournis à la fonction `g_object_new()` en même temps que les noms des propriétés dont elles sont les valeurs. Par exemple,

    GtkWidget* example_widget_new(int something, const char* thing)
    {
            return g_object_new (EXAMPLE_TYPE_WIDGET,
                                 "something", something,
                                 "thing", thing, NULL);
    }

Cette façon de procéder permet des liaisons de langage pour implémenter leurs propres équivalents (comme les constructeurs C++) sans utiliser les fonctions `*_new()`. Ceci est souvent nécessaire ; elles peuvent donc instancier en réalité un GType dérivé pour ajouter leurs propres accroches pour les gestionnaires de signal et les fonctions virtuelles.

Pour le moins, la fonction `_new()` ne doit pas utiliser une quelconque API privée (fonctions uniquement dans un fichier .c). Même s'il n'y a pas de fonctions, nous pouvons ré-implémenter 2 ou 3 lignes de code dans une fonction `_new()` pour autant que ces lignes de code utilisent une API disponible pour nous.

Une autre manière de contourner ce problème consiste à ajouter une fonction `*_construct()` que le constructeur C++ peut appeler après avoir instancié son propre type. Par exemple,

    GtkWidget* example_widget_new(int something, const char* thing)
    {
            ExampleWidget* widget;
            widget = g_object_new (EXAMPLE_TYPE_WIDGET, NULL);
            example_widget_construct(widget,
                                     "something", something,
                                     "thing", thing);
    }

    void example_widget_construct(ExampleWidget* widget,
                                  int something,
                                  const char* thing)
    {
            //faire quelque chose qui utilise l'API privée:
            widget->priv->thing = thing;
            do_something(something);
    }

Ajouter des propriétés en s'assurant qu'elles interagissent proprement entre elles est relativement difficile à corriger dans une bibliothèque C, mais c'est possible ; faites remonter un rapport d'anomalie avec si possible un correctif au mainteneur concerné.

### Documentation

En règle générale, les projets du style gtkmm utilisent Doxygen, qui lit les commentaires dans un format particulier et génère une documentation HTML. Vous pouvez écrire ces commentaires doxygen directement dans les fichiers d'en-tête.

#### Réutilisation de la documentation C

You might wish to reuse documentation that exists for the C library that you are wrapping. GTK-style C libraries typically use gtk-doc and therefore have source code comments formatted for gtk-doc and some extra documentation in .sgml and .xml files. The docextract_to_xml.py script, from glibmm's `tools/defs_gen` directory, can read these files and generate an .xml file that `gmmproc` can use to generate doxygen comments. `gmmproc` will even try to transform the documentation to make it more appropriate for a C++ API.

Par exemple,

    ./docextract_to_xml.py -s ~/checkout/gnome/gtk+/gtk/ -s ~/checkout/gnome/gtk+/docs/reference/gtk/ > gtk_docs.xml

Cette transformation automatique n'est pas toujours appropriée ; vous serez amené à rédiger un texte pour des fonctions membres particulières. Vous pouvez faire cela en copiant le nœud XML concernant la fonction du fichier `something_docs.xml` vers le fichier `something_docs_override.xml` et en modifiant son contenu.

#### Structure de construction de la documentation

Si vous avez copié l'arborescence des squelettes sources de mm-common et substitué le texte à remplacer, vous disposez déjà de fichiers `Makefile.am` et `Doxyfile.in` convenables. Avec le paramétrage de construction de mm-common, la liste des fichiers d'entrée Doxygen n'est pas définie dans le fichier de configuration Doxygen, mais passée de `make` à l'entrée standard de `doxygen`. La liste des fichiers en entrée est définie par la variable `doc_input` du fichier `Makefile.am`.