# Programming with gtkmm 4

Murray Cumming
Bernhard Rieder Chapter on "Timeouts".
Jonathon Jongsma Chapter on "Drawing with Cairo". Chapter on "Working with gtkmm's Source Code". Chapter on "Recent Files".
Ole Laursen Parts of chapter on "Internationalization".
Marko Anastasov Chapter on "Printing". Parts of chapter on "Internationalization".
Daniel Elstner Section "Build Structure" of chapter on "Wrapping C Libraries with gmmproc".
Chris Vine Chapter on "Multi-threaded programs".
David King Section on Gtk::Grid.
Pedro Ferreira Chapter on Keyboard Events.
Kjell Ahlstedt Update from gtkmm 3 to gtkmm 4. Chapter on "Building applications".

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

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.

gtkmm developers tend to prefer gtkmm to Qt because gtkmm does things in a more C++ way. Qt originates from a time when C++ and the standard library were not standardised or well supported by compilers. It therefore duplicates a lot of stuff that is now in the standard library, such as containers and type information. Most significantly, Trolltech modified the C++ language to provide signals, so that Qt classes cannot be used easily with non-Qt classes. gtkmm was able to use standard C++ to provide signals without changing the C++ language. See the FAQ for more detailed differences.

#### 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-4.0, you might first need to install these other packages.

- libsigc++-3.0

- gtk+-4.0

- glibmm-2.60

- cairomm-1.16

- pangomm-2.44

- atkmm-2.30

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

- graphene

### 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.

The names of the gtkmm packages vary from distribution to distribution (e.g. libgtkmm-4.0-dev on Debian and Ubuntu or gtkmm40-devel on Red Hat Fedora), so check with your distribution's package management program for the correct package name and install it like you would any other package.

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 4.8 supplied by Debian's libgtkmm-4.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

Remember that on a Unix or Linux operating system, you will probably need to be `root` to install software. The `su` or `sudo` command will allow you to enter the `root` password and have `root` status temporarily.

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.

By default, gtkmm will be installed under the `/usr/local` directory. On some systems you may need to install to a different location. For instance, on Red Hat Linux systems you might use the `--prefix` option with configure, like so:

    # ./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+ and gtkmm were designed to work well with Microsoft Windows, and the developers encourage its use on the win32 platform. However, Windows has no standard installation system for development libraries. Please see the Windows Installation page for Windows-specific installation instructions and notes.

## 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.

Source Code

File: `base.cc` (For use with gtkmm 4)

    #include <gtkmm.h>

    int main(int argc, char* argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.examples.base");

      Gtk::Window window;
      window.set_default_size(200, 200);

      return app->run(window, argc, argv);
    }

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.

The next statement:

    auto app = Gtk::Application::create("org.gtkmm.examples.base");

creates a Gtk::Application object, stored in a Glib::RefPtr smartpointer. This is needed in all gtkmm applications. The create() method for this object initializes gtkmm.

The next two lines of code create a window and set its default (initial) size:

    Gtk::Window window;
    window.set_default_size(200, 200);

The last line shows the window and enters the gtkmm main processing loop, which will finish when the window is closed. Your `main()` function will then return with an appropriate success or error code. The argc and argv arguments, passed to your application on the command line, can be checked when run() is called, but this simple application does not use those arguments.

    return app->run(window, argc, argv);

After putting the source code in `simple.cc` you can compile the above program with gcc using:

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

Note that you must surround the `pkg-config` invocation with backquotes. Backquotes cause the shell to execute the command inside them, and to use the command's output as part of the command line. Note also that `simple.cc` must come before the `pkg-config` invocation on the command line.

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

Although we have shown the compilation command for the simple example, you really should use the automake and autoconf tools, as described in "Autoconf, Automake, Libtool", by G. V. Vaughan et al. The examples used in this book are included in the gtkmm-documentation package, with appropriate build files, so we won't show the build commands in future. You'll just need to find the appropriate directory and type `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.

However, this is even simpler when using the `PKG_CHECK_MODULES()` macro in a standard configure.ac file with autoconf and automake. For instance:

    PKG_CHECK_MODULES([MYAPP], [gtkmm-4.0 >= 4.8.0])

This checks for the presence of gtkmm and defines MYAPP_LIBS and MYAPP_CFLAGS for use in your Makefile.am files.

gtkmm-4.0 is the name of the current stable API. There are older APIs called gtkmm-2.4 and gtkmm-3.0 which install in parallel when they are available. There are several versions of gtkmm-2.4, such as gtkmm 2.10 and there are 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. There might be a future gtkmm-5.0 API which would install in parallel with gtkmm-4.0 without affecting existing applications.

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

The GNU site has more information about autoconf and automake.

If you start by experimenting with a small application that you plan to use just for yourself, it's easier to start with a Makefile similar to the `Makefile.example` files in the Building applications chapter.

### É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.

Widgets are arranged inside container widgets such as frames and notebooks, in a hierarchy of widgets within widgets. Some of these container widgets, such as Gtk::Grid, are not visible - they exist only to arrange other widgets. Here is some example code that adds 2 Gtk::Button widgets to a Gtk::Box container widget:

    m_box.add(m_Button1);
    m_box.add(m_Button2);

and here is how to add the Gtk::Box, containing those buttons, to a Gtk::Frame, which has a visible frame and title:

    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.

Although gtkmm widget instances have lifetimes and scopes just like those of other C++ classes, gtkmm has an optional time-saving feature that you will see in some of the examples. The `Gtk::make_managed()` allows you to create a new widget and state that it will become owned by the container into which you place it. This allows you to create the widget, add it to the container and not be concerned about deleting it, since that will occur when the parent container (which may itself be managed) is deleted. You can learn more about gtkmm memory management techniques in the Memory Management chapter.

### 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 uses the libsigc++ library to implement signals. Here is an example line of code that connects a Gtk::Button's "clicked" signal with a signal handler called "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

You might be surprised to learn that gtkmm doesn't use std::string in its interfaces. Instead it uses Glib::ustring, which is so similar and unobtrusive that you could actually pretend that each Glib::ustring is a std::string and ignore the rest of this section. But read on if you want to use languages other than English in your application.

std::string uses 8 bits per character, but 8 bits aren't enough to encode languages such as Arabic, Chinese, and Japanese. Although the encodings for these languages have been specified by the Unicode Consortium, the C and C++ languages do not yet provide any standardised Unicode support for UTF-8 encoding. GTK+ and GNOME chose to implement Unicode using UTF-8, and that's what is wrapped by Glib::ustring. It provides almost exactly the same interface as std::string, along with automatic conversions to and from 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.

Reference

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

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

You can use C APIs which do not yet have convenient C++ interfaces. It is generally not a problem to use C APIs from C++, and gtkmm helps by providing access to the underlying C object, and providing an easy way to create a C++ wrapper object from a C object, provided that the C API is also based on the GObject system.

To use a gtkmm instance with a C function that requires a C GObject instance, use the C++ instance’s `gobj()` function to obtain a pointer to the underlying C instance. For example:

    Gtk::Button button("example");
    gtk_button_do_something_that_gtkmm_cannot(button.gobj());

To obtain a gtkmm instance from a C GObject instance, use one of the many overloaded `Glib::wrap()` functions. The C instance’s reference count is not incremented, unless you set the optional take_copy argument to `true`. For example:

    GtkButton* cbutton = get_a_button();
    Gtk::Button* button = Glib::wrap(cbutton);
    button->set_label("Now I speak C++ too!");

The C++ wrapper shall be explicitly deleted if

- it's a widget or other class that inherits from Gtk::Object, and

- the C instance has a floating reference when the wrapper is created, and

- `Gtk::manage()` has not been called on it (which includes if it was created with `Gtk::make_managed()`), or

- `Gtk::manage()` was called on it, but it was never added to, or was later removed from, its parent.

`Glib::wrap()` binds the C and C++ instances to each other. Don't delete the C++ instance before you want the C instance to die.

In all other cases the C++ instance is automatically deleted when the last reference to the C instance is dropped. This includes all `Glib::wrap()` overloads that return a Glib::RefPtr.

### 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 :

Source Code

File: `helloworld.h` (For use with gtkmm 4)

    #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();
      ~HelloWorld() override;

    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 4)

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

    int main(int argc, char* argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      HelloWorld helloworld;

      //Shows the window and returns when it is closed.
      return app->run(helloworld, argc, argv);
    }

File: `helloworld.cc` (For use with gtkmm 4)

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

    HelloWorld::HelloWorld()
    : m_button("Hello World")   // creates a new button with label "Hello World".
    {
      // Sets the margin around the button.
      m_button.set_margin(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);
    }

    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();
      ~HelloWorld() override;

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

      //Member widgets:
      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")
    {
      m_button.set_margin(10);
      m_button.signal_clicked().connect(sigc::mem_fun(*this,
        &HelloWorld::on_button_clicked));
      add(m_button);
    }

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

Next we call the Button's set_margin() method. This sets the amount of space around the button.

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

Next, we use the Window's add() method to put `m_button` in the Window. (add() comes from Gtk::Container, which is described in the chapter on container widgets.) The add() method places the Widget in the Window.

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

    int main(int argc, char* argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");
      HelloWorld helloworld;
      return app->run(helloworld, argc, argv);
    }

First we instantiate an object stored in a RefPtr smartpointer called `app`. This is of type Gtk::Application. Every gtkmm program must have one of these.

Next we make an object of our HelloWorld class, whose constructor takes no arguments, but it isn't visible yet. When we call Gtk::Application::run(), giving it the helloworld Window and the command-line arguments, it shows the Window and starts the gtkmm event loop. During the event loop gtkmm idles, waiting for actions from the user, and responding appropriately. When the user closes the Window, run() will return, causing the final line of our `main()` function be to executed. The application will then finish.

Like the simple example we showed earlier, this Hello World program does not use the command-line parameters. It's not necessary to pass them to run().

## Changes in gtkmm 3

gtkmm-3.0 is an old version of the gtkmm API that installs in parallel with the still older gtkmm-2.4 API and the new gtkmm-4.0 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 particular type of content.

2. Gtk::Grid is a new container widget that will eventually replace Gtk::Box and Gtk::Table. 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::CheckButton. 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 own 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 have been new deprecations in later gtkmm 3.x 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 GTKMM_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.

## Changes in gtkmm-4.0 and glibmm-2.60

gtkmm-4.0 is a new version of the gtkmm API that installs in parallel with the older gtkmm-2.4 and gtkmm-3.0 APIs. The last version of the gtkmm-3.0 API is gtkmm 3.24. gtkmm 4 has no major fundamental differences to gtkmm 3 but does make several changes (both small and large ones) that were not possible while maintaining binary compatibility. If you never used the gtkmm-3.0 API then you can safely ignore this chapter.

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

gtkmm-4.0 is used in combination with glibmm-2.60, which sets the global locale for your program. The older glibmm-2.4 does not do that, and gtkmm-3.0 does it only to some extent. What this means is briefly that if your gtkmm-3.0 program contains a call to `std::locale::global(std::locale(""))`, you can probably remove it. If you don't want glibmm or gtkmm to set the global locale for you, you should add a call to `Glib::set_init_to_users_preferred_locale(false)` before any call to `Glib::init()` or Gtk::Application::create().

Reference

There are lots and lots of differences between gtkmm-3.0 and gtkmm-4.0. The following lists are not complete.

Some new classes were added in gtkmm 4 and glibmm 2.60:

1. Glib::ExtraClassInit and Gtk::Snapshot: These classes are needed only for writing custom widgets. See the Custom Widgets section.

2. Gtk::EventControllerKey, Gtk::EventControllerMotion, Gtk::EventControllerScroll and Gtk::GestureStylus

3. Gdk::Paintable, Gdk::Texture, Gtk::Picture and Gtk::WidgetPaintable

4. Gdk::Window has been renamed to Gdk::Surface. (Gtk::Window keeps its name.)

5. Gdk::DrawContext and Gdk::CairoContext are new. Gdk::DrawingContext has been removed.

6. Gtk::Clipboard has been replaced by the new Gdk::Clipboard.

7. Gdk::DragContext has been split into Gdk::Drag and Gdk::Drop.

There have also been several changes to the API, which you will probably encounter when porting code that used gtkmm-3.0 and glibmm-2.4. Here is a short list:

1. A C++17 compiler is required.

2. Gtk::Button, Gtk::ToolButton, Gtk::MenuItem and Gtk::Switch implement the Gtk::Actionable interface instead of the removed Gtk::Activatable interface.

3. Gtk::FontButton implements the Gtk::FontChooser interface.

4. Gtk::Widget: The get_preferred_*_vfunc()s have been replaced by measure_vfunc(). This change only affects custom widgets.

5. sigc::slots use the sigc::slot<R(Args...)> syntax. Example: sigc::slot<void(int, int)> instead of sigc::slot<void, int, int>.

6. Gtk::DrawingArea uses a draw function instead of the draw signal.

7. Glib::ArrayHandle, Glib::StringArrayHandle, Glib::ListHandle and Glib::SListHandle have been removed. They were used in glibmm-2.4, but not used in gtkmm-3.0. If you've ever used these classes, replace them with a standard C++ container, such as std::vector.

8. Gtk::Container::show_all_children() and Gtk::Widget::show_all() have been removed. The default value of Gtk::Widget::property_visible()has been changed from `false` to `true`.

9. All event signals have been removed from Gtk::Widget. In most cases you can use one of the subclasses of Gtk::EventController as a replacement. For instance, use Gtk::GestureMultiPress instead of signal_button_press_event() and signal_button_release_event(), and Gtk::EventControllerKey instead of signal_key_press_event() and signal_key_release_event().

10. Glib::RefPtr is an alias for std::shared_ptr. If you make your own Glib::ObjectBase-derived classes with create() methods that return a Glib::RefPtr, you must use Glib::make_refptr_for_instance() in your create() methods.

11. Gtk::Box::pack_start() and Gtk::Box::pack_end() have been removed. Use Gtk::Container::add() or the new Gtk::Box methods insert_child_after() and insert_child_at_start().

12. Gtk::ButtonBox has been removed.

All deprecated API was removed in gtkmm 4.0 and glibmm 2.60, though there will be new deprecations in future versions.

As a first step to porting your source code to gtkmm-4.0 you should probably ensure that your application builds with the deprecated gtkmm-3.0 and glibmm-2.4 API disabled, by defining the macros GTKMM_DISABLE_DEPRECATED, GDKMM_DISABLE_DEPRECATED, GLIBMM_DISABLE_DEPRECATED and GIOMM_DISABLE_DEPRECATED. There are some autotools macros that can help with this by defining them optionally at build time. See the Porting from gtkmm-2.4 to gtkmm-3.0 wiki page for more details.

See also Migrating from GTK+ 3.x to GTK+ 4.

## Boutons

gtkmm met à votre disposition quatre types basiques de boutons :

Push buttons

  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.

Check buttons

  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 CheckButton 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 CheckButtons (a small widget with a label at the side), but usually look different. See the RadioButton section.

Note that, due to GTK+'s theming system, the appearance of these widgets will vary. In the case of check buttons and radio buttons, they may vary considerably.

### Bouton

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);

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.

The Gtk::Button widget has the `clicked` signal which is emitted when the button is pressed and released.

Reference

#### Exemple

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

Exemple de bouton

Source Code

File: `buttons.h` (For use with gtkmm 4)

    #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 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      Buttons buttons;

      //Shows the window and returns when it is closed.
      return app->run(buttons, argc, argv);
    }

File: `buttons.cc` (For use with gtkmm 4)

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

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

      set_title("Pixmap'd buttons!");

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

      m_button.set_margin(10);
      add(m_button);
    }

    Buttons::~Buttons()
    {
    }

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

### 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.

Reference

### Case à cocher

Gtk::CheckButton inherits from Gtk::ToggleButton. The only real difference between the two is Gtk::CheckButton's appearance. You can check, set, and toggle a check button using the same member methods as for Gtk::ToggleButton.

Reference

#### Exemple

Case à cocher

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

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

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

      m_button.set_margin(10);
      add(m_button);
    }

    ExampleWindow::~ExampleWindow()
    {
    }

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

### Bouton radio

Like check buttons, radio buttons also inherit from Gtk::ToggleButton, but these work in groups, and only one RadioButton in a group can be selected at any one time.

#### Groupes

There are two ways to set up a group of radio buttons. The first way is to create the buttons, and set up their groups afterwards. Only the constructors without a Gtk::RadioButton::Group parameter are used. In the following example, we make a new window class called RadioButtons, and then put three radio buttons in it:

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

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

    RadioButtons::RadioButtons()
    : m_rb1("button1"),
      m_rb2("button2"),
      m_rb3("button3")
    {
      m_rb2.join_group(m_rb1);
      m_rb3.join_group(m_rb1);
    }

We told gtkmm to put all three RadioButtons in the same group by using join_group() to tell the other RadioButtons to share group with the first RadioButton.

Note that you can't do

    m_rb2.set_group(m_rb1.get_group()); //doesn't work

because get_group() returns a RadioButton::Group which is modified by set_group() and therefore is non-const.

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;
      auto m_rb1 = Gtk::make_managed<Gtk::RadioButton>(group, "button1");
      auto m_rb2 = Gtk::make_managed<Gtk::RadioButton>(group, "button2");
      auto m_rb3 = Gtk::make_managed<Gtk::RadioButton>(group, "button3");
    }

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

RadioButtons are "off" when created; this means that when you first make a group of them, they will all be off. Don't forget to turn one of them on using set_active().

Reference

#### Exemple

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

Bouton radio

Source Code

File: `radiobuttons.h` (For use with gtkmm 4)

    #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 4)

    #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");

      // Put radio buttons 2 and 3 in the same group as 1:
      m_RadioButton2.join_group(m_RadioButton1);
      m_RadioButton3.join_group(m_RadioButton1);

      // 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.add(m_Box1);
      m_Box_Top.add(m_Separator);
      m_Box_Top.add(m_Box2);
      m_Separator.set_expand();

      // Set the inner boxes' margins
      m_Box1.set_margin(10);
      m_Box2.set_margin(10);

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

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

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

      // 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) );
    }

    RadioButtons::~RadioButtons()
    {
    }

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

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      RadioButtons buttons;

      //Shows the window and returns when it is closed.
      return app->run(buttons, argc, argv);
    }

## É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.

As will be explained in the Adjustments section, all Range widgets are associated with an Adjustment object. To change the lower, upper, and current values used by the widget you need to use the methods of its Adjustment, which you can get with the get_adjustment() method. The Range widgets' default constructors create an Adjustment automatically, or you can specify an existing Adjustment, maybe to share it with another widget. See the Adjustments section for further details.

Reference

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

These are standard scrollbars. They should be used only to scroll another widget, such as a Gtk::Entry or a Gtk::Viewport, though it's usually easier to use the Gtk::ScrolledWindow widget in most cases.

The orientation of a Gtk::Scrollbar can be either horizontal or vertical.

Reference

### É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.

As with Scrollbars, the orientation can be either horizontal or vertical. The default constructor creates an Adjustment with all of its values set to `0.0`. This isn't useful so you will need to set some Adjustment details to get meaningful behaviour.

#### 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().

Reference

### 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

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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_combo_position();
      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_Combo, 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;

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_position_type); add(m_col_title); }

        Gtk::TreeModelColumn<Gtk::PositionType> m_col_position_type;
        Gtk::TreeModelColumn<Glib::ustring> m_col_title;
      };

      ModelColumns m_Columns;

      //Child widgets:
      Gtk::ComboBox m_ComboBox_Position;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;

      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLE_RANGEWIDGETS_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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_Combo(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::PositionType::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::PositionType::TOP);
      m_HScale.set_draw_value();

      add(m_VBox_Top);
      m_VBox_Top.add(m_VBox2);
      m_VBox2.set_expand(true);
      m_VBox2.set_margin(10);
      m_VBox2.add(m_HBox_Scales);
      m_HBox_Scales.set_expand(true);

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

      m_VBox_HScale.add(m_HScale);
      m_HScale.set_expand(true);

      //Scrollbar:
      m_VBox_HScale.add(m_Scrollbar);
      m_Scrollbar.set_expand(true);

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

      //Position ComboBox:
      //Create the Tree model:
      m_refTreeModel = Gtk::ListStore::create(m_Columns);
      m_ComboBox_Position.set_model(m_refTreeModel);
      m_ComboBox_Position.pack_start(m_Columns.m_col_title);

      //Fill the ComboBox's Tree Model:
      auto row = *(m_refTreeModel->append());
      row[m_Columns.m_col_position_type] = Gtk::PositionType::TOP;
      row[m_Columns.m_col_title] = "Top";
      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_position_type] = Gtk::PositionType::BOTTOM;
      row[m_Columns.m_col_title] = "Bottom";
      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_position_type] = Gtk::PositionType::LEFT;
      row[m_Columns.m_col_title] = "Left";
      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_position_type] = Gtk::PositionType::RIGHT;
      row[m_Columns.m_col_title] = "Right";

      m_VBox2.add(m_HBox_Combo);
      m_HBox_Combo.add(*Gtk::make_managed<Gtk::Label>("Scale Value Position:", 0));
      m_HBox_Combo.add(m_ComboBox_Position);
      m_ComboBox_Position.signal_changed().connect( sigc::mem_fun(*this, &ExampleWindow::on_combo_position) );
      m_ComboBox_Position.set_active(0); // Top
      m_ComboBox_Position.set_expand(true);

      //Digits:
      m_HBox_Digits.add(*Gtk::make_managed<Gtk::Label>("Scale Digits:", 0));
      m_Scale_Digits.set_digits(0);
      m_Scale_Digits.set_expand(true);
      m_adjustment_digits->signal_value_changed().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_adjustment1_value_changed));
      m_HBox_Digits.add(m_Scale_Digits);

      //Page Size:
      m_HBox_PageSize.add(*Gtk::make_managed<Gtk::Label>("Scrollbar Page Size:", 0));
      m_Scale_PageSize.set_digits(0);
      m_Scale_PageSize.set_expand(true);
      m_adjustment_pagesize->signal_value_changed().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_adjustment2_value_changed));
      m_HBox_PageSize.add(m_Scale_PageSize);

      m_VBox2.add(m_HBox_Digits);
      m_VBox2.add(m_HBox_PageSize);
      m_VBox_Top.add(m_Separator);
      m_VBox_Top.add(m_Button_Quit);

      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_margin(10);
    }

    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_combo_position()
    {
      const auto iter = m_ComboBox_Position.get_active();
      if(!iter)
        return;

      const auto row = *iter;
      if(!row)
        return;

      const auto postype = row[m_Columns.m_col_position_type];

      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();
    }

## Éléments graphiques divers

### Étiquette

Labels are the main method of placing non-editable text in windows, for instance to place a title next to an Entry widget. You can specify the text in the constructor, or later with the set_text() or set_markup() methods.

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 supports 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>` .

Reference

#### Exemple

Below is a short example to illustrate these functions. This example makes use of the Frame widget to better demonstrate the label styles. (The Frame widget is explained in the Frame section.) It is possible that the first character in `m_Label_Normal` is shown underlined only when you press the Alt key.

Étiquette

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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");

      m_HBox.set_margin(5);
      add(m_HBox);

      m_HBox.add(m_VBox);

      m_Frame_Normal.add(m_Label_Normal);
      m_VBox.add(m_Frame_Normal);

      m_Frame_Multi.add(m_Label_Multi);
      m_VBox.add(m_Frame_Multi);

      m_Label_Left.set_justify(Gtk::Justification::LEFT);
      m_Frame_Left.add(m_Label_Left);
      m_VBox.add(m_Frame_Left);

      m_Label_Right.set_justify(Gtk::Justification::RIGHT);
      m_Frame_Right.add(m_Label_Right);
      m_VBox.add(m_Frame_Right);

      m_HBox.add(m_VBox2);

      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.add(m_Frame_LineWrapped);

      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::Justification::FILL);
      m_Label_FilledWrapped.set_line_wrap();
      m_Frame_FilledWrapped.add(m_Label_FilledWrapped);
      m_VBox2.add(m_Frame_FilledWrapped);

      m_Label_Underlined.set_justify(Gtk::Justification::LEFT);
      m_Label_Underlined.set_pattern (
              "_________________________ _ _________ _ ______"
              "     __ _______ ___");
      m_Frame_Underlined.add(m_Label_Underlined);
      m_VBox2.add(m_Frame_Underlined);
    }

    ExampleWindow::~ExampleWindow()
    {
    }

### 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.

You might want to be notified whenever the user types in a text entry widget. Gtk::Entry provides two signals, `activate` and `changed`, for this purpose. `activate` is emitted when the user presses the Enter key in a text-entry widget; `changed` is emitted when the text in the widget changes. You can use these, for instance, to validate or filter the text the user types. Moving the keyboard focus to another widget may also signal that the user has finished entering text. The `focus_out_event` signal that Gtk::Entry inherits from Gtk::Widget can notify you when that happens. The ComboBox with an Entry section contains example programs that use these signals.

If you pass `true` to the set_activates_default() method, pressing Enter in the Gtk::Entry will activate the default widget for the window containing the Gtk::Entry. This is especially useful in dialog boxes. The default widget is usually one of the dialog buttons, which e.g. will close the dialog box. To set a widget as the default widget, use Gtk::Widget::set_can_default() and Gtk::Widget::grab_default().

Reference

##### 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

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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_Entry.set_expand(true);
      m_VBox.add(m_Entry);

      m_VBox.add(m_HBox);

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

      m_HBox.add(m_CheckButton_Visible);
      m_CheckButton_Visible.set_expand(true);
      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.add(m_Button_Close);
      m_Button_Close.set_expand();
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();
    }

    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();
    }

#### Complétion de saisie

An Entry widget can offer a drop-down list of pre-existing choices based on the first few characters typed by the user. For instance, a search dialog could suggest text from previous searches.

To enable this functionality, you must create an EntryCompletion object, and provide it to the Entry widget via the set_completion() method.

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.

Alternatively, if a complete list of possible entries would be too large or too inconvenient to generate, a callback slot may instead be specified with set_match_func(). This is also useful if you wish to match on a part of the string other than the start.

Reference

##### 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

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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.add(m_Entry);

      m_VBox.add(m_Label);
      m_Label.set_expand(true);

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

      //Add an EntryCompletion:
      auto completion =
          Gtk::EntryCompletion::create();
      m_Entry.set_completion(completion);

      //Create and fill the completion's filter model
      auto 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
      auto 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(const auto& the_pair : m_CompletionActions)
      {
        auto position = the_pair.first;
        auto title = the_pair.second;
        completion->insert_action_text(title, position);
      }

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

    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)
      {
        const auto row = *iter;

        const auto key_length = key.size();
        auto filter_string = row[m_Columns.m_col_name];

        auto 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)
    {
      auto iter = m_CompletionActions.find(index);
      if(iter != m_CompletionActions.end()) //If it's in the map
      {
        auto title = iter->second;
        std::cout << "Action selected: " << title << std::endl;
      }
    }

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

An Entry widget can show an icon at the start or end of the text area. The icon can be specifed by methods such as set_icon_from_pixbuf() or set_icon_from_icon_name(). An application can respond to the user pressing the icon by handling the signal_icon_press signal.

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

This example shows a Gtk::Entry widget with a named search icon, and prints text to the terminal when the icon is pressed.

Saisie avec icône

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::Entry::IconPosition icon_pos);
      void on_button_close();

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

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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.add(m_Entry);

      m_Entry.set_icon_from_icon_name("edit-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.add(m_Button_Close);
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_icon_pressed(Gtk::Entry::IconPosition /* icon_pos */)
    {
      std::cout << "Icon pressed." << std::endl;
    }

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

#### 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

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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.add(m_Entry);

      //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.add(m_Button_Close);
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();
    }

    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();
    }

### Bouton compteur

A SpinButton allows the user to select a value from a range of numeric values. It has an Entry widget with increment and decrement buttons at the side. Clicking the buttons causes the value to 'spin' up and down across the range of possible values. The Entry widget may also be used to enter a value directly.

The value can have an adjustable number of decimal places, and the step size is configurable. SpinButtons have an 'auto-repeat' feature as well: holding down the increment or decrement button can optionally cause the value to change more quickly the longer the button is held down.

SpinButtons use an Adjustment object to hold information about the range of values. These Adjustment attributes are used by the Spin Button like so:

- `value`: value for the Spin Button

- `lower`: lower range value

- `upper`: upper range value

- `step_increment`: value to increment/decrement when pressing mouse button 1

- `page_increment`: value to increment/decrement when pressing mouse button 2

- `page_size`: unused

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().

The spin() method 'spins' the SpinButton, as if its increment or decrement button had been clicked. You need to specify a Gtk::SpinType to specify the direction or new position.

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().

Reference

#### Exemple

Voici un exemple de SpinButton en action :

Bouton compteur

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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_VBox(Gtk::Orientation::VERTICAL),
      m_VBox_Day(Gtk::Orientation::VERTICAL),
      m_VBox_Month(Gtk::Orientation::VERTICAL),
      m_VBox_Year(Gtk::Orientation::VERTICAL),
      m_VBox_Accelerated(Gtk::Orientation::VERTICAL),
      m_VBox_Value(Gtk::Orientation::VERTICAL),
      m_VBox_Digits(Gtk::Orientation::VERTICAL),
      m_Label_Day("Day: ", Gtk::Align::START),
      m_Label_Month("Month: ", Gtk::Align::START),
      m_Label_Year("Year: ", Gtk::Align::START),
      m_Label_Value("Value: ", Gtk::Align::START),
      m_Label_Digits("Digits: ", Gtk::Align::START),
      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(2012.0, 1.0, 2200.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_margin(10);
      add(m_VBox_Main);

      m_VBox_Main.add(m_Frame_NotAccelerated);

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

      /* Day, month, year spinners */

      m_VBox.set_spacing(5);
      m_VBox.add(m_HBox_NotAccelerated);

      m_Label_Day.set_expand();
      m_VBox_Day.add(m_Label_Day);

      m_SpinButton_Day.set_wrap();
      m_SpinButton_Day.set_expand();
      m_VBox_Day.add(m_SpinButton_Day);

      m_HBox_NotAccelerated.set_spacing(5);
      m_HBox_NotAccelerated.add(m_VBox_Day);

      m_Label_Month.set_expand();
      m_VBox_Month.add(m_Label_Month);

      m_SpinButton_Month.set_wrap();
      m_SpinButton_Month.set_expand();
      m_VBox_Month.add(m_SpinButton_Month);

      m_HBox_NotAccelerated.add(m_VBox_Month);

      m_Label_Year.set_expand();
      m_VBox_Year.add(m_Label_Year);

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

      m_HBox_NotAccelerated.add(m_VBox_Year);

      //Accelerated:
      m_VBox_Main.add(m_Frame_Accelerated);

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

      m_VBox_Accelerated.set_spacing(5);
      m_VBox_Accelerated.add(m_HBox_Accelerated);

      m_HBox_Accelerated.add(m_VBox_Value);

      m_Label_Value.set_expand();
      m_VBox_Value.add(m_Label_Value);

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

      m_HBox_Accelerated.add(m_VBox_Digits);

      m_VBox_Digits.add(m_Label_Digits);
      m_Label_Digits.set_expand();

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

      m_VBox_Digits.add(m_SpinButton_Digits);
      m_SpinButton_Digits.set_expand();

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

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

      //Buttons:
      m_VBox_Accelerated.add(m_HBox_Buttons);

      m_Button_Int.signal_clicked().connect( sigc::bind( sigc::mem_fun(*this,
                      &ExampleWindow::on_button_getvalue), VALUE_FORMAT_INT) );
      m_HBox_Buttons.set_spacing(5);
      m_HBox_Buttons.add(m_Button_Int);
      m_Button_Int.set_expand();

      m_Button_Float.signal_clicked().connect( sigc::bind( sigc::mem_fun(*this,
                      &ExampleWindow::on_button_getvalue), VALUE_FORMAT_FLOAT) );
      m_HBox_Buttons.add(m_Button_Float);
      m_Button_Float.set_expand();

      m_VBox_Accelerated.add(m_Label_ShowValue);
      m_Label_ShowValue.set_expand();
      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.add(m_Button_Close);
    }

    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);
    }

### 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.

To change the value shown, use the set_fraction() method, passing a double between 0.0 and 1.0 to provide the new fraction.

A ProgressBar is horizontal and left-to-right by default, but you can change it to a vertical progress bar by using the set_orientation() method.

Reference

#### 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().

The progress bar can also display a configurable text string next to the bar, using the set_text() method.

#### Exemple

Barres de progression

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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();

      bool on_timeout();
      void on_button_close();

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Grid m_Grid;
      Gtk::ProgressBar m_ProgressBar;
      Gtk::Separator m_Separator;
      Gtk::CheckButton m_CheckButton_Text, m_CheckButton_Activity, m_CheckButton_Inverted;
      Gtk::Button m_Button_Close;

      sigc::connection m_connection_timeout;
      bool m_bActivityMode;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::Orientation::VERTICAL, 5),
      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_margin(10);
      add(m_VBox);

      m_VBox.add(m_ProgressBar);
      m_ProgressBar.set_margin_end(5);
      m_ProgressBar.set_halign(Gtk::Align::CENTER);
      m_ProgressBar.set_valign(Gtk::Align::CENTER);
      m_ProgressBar.set_size_request(100, -1);
      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_timeout = Glib::signal_timeout().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_timeout), 50 );

      m_VBox.add(m_Separator);
      m_VBox.add(m_Grid);
      m_Grid.set_expand(true);
      m_Grid.set_row_homogeneous(true);

      //Add a check button to select displaying of the trough text:
      m_Grid.attach(m_CheckButton_Text, 0, 0);
      m_CheckButton_Text.set_margin(5);
      m_CheckButton_Text.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbutton_text) );

      //Add a check button to toggle activity mode:
      m_Grid.attach(m_CheckButton_Activity, 0, 1);
      m_CheckButton_Activity.set_margin(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_Grid.attach(m_CheckButton_Inverted, 0, 2);
      m_CheckButton_Inverted.set_margin(5);
      m_CheckButton_Inverted.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbutton_inverted) );

      //Add a button to exit the program.
      m_VBox.add(m_Button_Close);
      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();
    }

    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;
    }

### Infobarre

An InfoBar may show small items of information or ask brief questions. Unlike a Dialog, it appears at the top of the current window instead of opening a new window. Its API is very similar to the Gtk::Dialog API.

Reference

#### Exemple

Infobarre

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::Box m_ButtonBox;
      Gtk::Button m_Button_Quit, m_Button_Clear;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::Orientation::VERTICAL, 6),
      m_Button_Quit("_Quit", true),
      m_Button_Clear("_Clear", true)
    {
      set_title("Gtk::InfoBar example");
      set_default_size(400, 200);

      m_VBox.set_margin(6);
      add(m_VBox);

      // Add the message label to the InfoBar:
      auto 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("_OK", 0);

      // Add the InfoBar to the vbox:
      m_VBox.add(m_InfoBar);

      // 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::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
      m_ScrolledWindow.set_expand();

      m_VBox.add(m_ScrolledWindow);

      // Add button box:
      m_VBox.add(m_ButtonBox);

      m_ButtonBox.add(m_Button_Clear);
      m_ButtonBox.add(m_Button_Quit);
      m_ButtonBox.set_spacing(6);
      m_Button_Clear.set_hexpand(true);
      m_Button_Clear.set_halign(Gtk::Align::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) );

      // 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::MessageType::INFO);
      m_InfoBar.show();
    }

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

### Infobulles

Tooltips are the little information windows that pop up when you leave your pointer over a widget for a few seconds. Use set_tooltip_text() to set a text string as a tooltip on any Widget. Gtk::Tooltip is used for more advanced tooltip usage, such as showing an image as well as text.

Widget Reference

Tooltip Reference

#### Exemple

Infobulle

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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::WindowType::POPUP)
    {
      //Set up window and the top-level container:
      set_title(app_title);

      m_vbox.set_margin(10);
      add(m_vbox);

      //Check button with markup in tooltip:
      m_checkbutton.set_tooltip_text(non_markedup_tip);
      m_vbox.add(m_checkbutton);

      //Label:
      m_label.set_tooltip_text("Another tooltip");
      m_vbox.add(m_label);

      //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.add(m_button);

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

      connect_signals();
    }

    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::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
      m_scrolled_window.set_expand();
      m_vbox.add(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), true);

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

    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::TextWindowType::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_icon_name("dialog-information");
      }
      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;
    }

## Éléments graphiques conteneurs

All container widgets derive from Gtk::Container, not always directly. Some container widgets, such as Gtk::Grid can hold many child widgets, so these typically have more complex interfaces. Others, such as Gtk::Frame contain only one child widget.

### 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.

Reference

##### Exemple

Cadre

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #include "examplewindow.h"

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

      /* Sets the margin around the frame. */
      m_Frame.set_margin(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::ShadowType::ETCHED_OUT);
    }

    ExampleWindow::~ExampleWindow()
    {
    }

#### Volets

Panes divide a widget into two halves, separated by a moveable divider. The two halves (panes) can be oriented either horizontally (side by side) or vertically (one above the other).

Unlike the other widgets in this section, pane widgets contain not one but two child widgets, one in each pane. Therefore, you should use add1() and add2() instead of the add() method.

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

Reference

##### Exemple

Volets

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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: `messageslist.h` (For use with gtkmm 4)

    #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 4)

    #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: `messageslist.cc` (For use with gtkmm 4)

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

    MessagesList::MessagesList()
    {
      /* Create a new scrolled window, with scrollbars only if needed */
      set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::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;

        auto 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);
    }

    MessagesList::~MessagesList()
    {
    }

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VPaned(Gtk::Orientation::VERTICAL)
    {
      set_title ("Paned Windows");
      set_default_size(450, 400);
      m_VPaned.set_margin(10);

      /* 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);
    }

    ExampleWindow::~ExampleWindow()
    {
    }

File: `messagetext.cc` (For use with gtkmm 4)

    #include "messagetext.h"

    MessageText::MessageText()
    {
      set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);

      add(m_TextView);
      insert_text();
    }

    MessageText::~MessageText()
    {
    }

    void MessageText::insert_text()
    {
      auto refTextBuffer = m_TextView.get_buffer();

      auto 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");
    }

#### 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.

Reference

##### 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

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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_dialog_response(int response_id);

      //Child widgets:
      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::Grid m_Grid;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow()
    {
      set_title("Gtk::ScrolledWindow example");
      set_size_request(300, 300);

      m_ScrolledWindow.set_margin(10);

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

      get_content_area()->add(m_ScrolledWindow);

      /* set the spacing to 10 on x and 10 on y */
      m_Grid.set_row_spacing(10);
      m_Grid.set_column_spacing(10);

      /* pack the grid into the scrolled window */
      m_ScrolledWindow.add(m_Grid);

      /* this simply creates a grid of toggle buttons
       * 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);
            auto pButton = Gtk::make_managed<Gtk::ToggleButton>(buffer);
            m_Grid.attach(*pButton, i, j, 1, 1);
         }
      }

      /* Add a "close" button to the bottom of the dialog */
      add_button("_Close", Gtk::ResponseType::CLOSE);
      signal_response().connect(sigc::mem_fun(*this, &ExampleWindow::on_dialog_response));

      /* This makes it so the button is the default.
       * Simply hitting the "Enter" key will cause this button to activate. */
      set_default_response(Gtk::ResponseType::CLOSE);
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_dialog_response(int response_id)
    {
      switch (response_id)
      {
      case Gtk::ResponseType::CLOSE:
      case Gtk::ResponseType::DELETE_EVENT:
        hide();
        break;
      default:
        std::cout << "Unexpected response_id=" << response_id << std::endl;
        break;
      }
    }

#### 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.

Reference

##### 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é

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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");

      // 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_content_width(200);
      m_DrawingArea.set_content_height(200);
      m_AspectFrame.add(m_DrawingArea);
      m_AspectFrame.set_margin(10);

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

    ExampleWindow::~ExampleWindow()
    {
    }

#### Other Single-item Containers

There are other single-item containers. See the reference documentation for a complete list. Here are links to some example programs that show containers, which are not mentioned elsewhere in this tutorial.

Source Code, ActionBar

Source Code, Expander

Source Code, Popover

### Multiple-item Containers

Multiple-item widgets inherit from Gtk::Container; just as with Gtk::Bin, you use the add() and remove() methods to add and remove contained widgets. Unlike Gtk::Bin::remove(), however, the remove() method for Gtk::Container takes an argument, specifying which widget to remove.

#### 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 uses the packing system to solve these problems. Rather than specifying the position and size of each widget in the window, you can arrange your widgets in rows, columns, and/or grids. gtkmm can size your window automatically, based on the sizes of the widgets it contains. And the sizes of the widgets are, in turn, determined by the amount of text they contain, or the minimum and maximum sizes that you specify, and/or how you have requested that the available space should be shared between sets of widgets. You can perfect your layout by specifying margins and centering values for each of your widgets. gtkmm then uses all this information to resize and reposition everything sensibly and smoothly when the user manipulates the window.

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.

Yes, that's correct: a Window can contain at most one widget. How, then, can we use a window for anything useful? By placing a multiple-child container in the window. The most useful container widgets are Gtk::Grid and Gtk::Box.

- 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::Box arranges its child widgets vertically or horizontally. Use add() to insert child widgets.

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

Source Code

File: `helloworld.h` (For use with gtkmm 4)

    #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();
      ~HelloWorld() override;

    protected:

      // Signal handlers:
      // Our new improved on_button_clicked().
      void on_button_clicked(const 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 4)

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

    int main(int argc, char* argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      HelloWorld helloworld;

      //Shows the window and returns when it is closed.
      return app->run(helloworld, argc, argv);
    }

File: `helloworld.cc` (For use with gtkmm 4)

    #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 margin around the box.
      m_box1.set_margin(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 its argument.
      m_button1.signal_clicked().connect(sigc::bind(
                  sigc::mem_fun(*this, &HelloWorld::on_button_clicked), "button 1"));

      // We use Gtk::Container::add() to pack this button into the  box,
      // which has been packed into the window.
      // A widget's default behaviour is not to expand if extra space is available.
      // A container widget by default expands if any of the contained widgets
      // wants to expand.
      m_box1.add(m_button1);
      m_button1.set_expand();

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

      m_box1.add(m_button2);
      m_button2.set_expand();

      // Gtk::Widget::show() is seldom needed. All widgets are visible by default.
    }

    HelloWorld::~HelloWorld()
    {
    }

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

After building and running this program, try resizing the window to see the behaviour. Also, try playing with set_expand(), set_hexpand(), set_vexpand(), set_halign() and set_valign() while reading the Boxes section.

#### Boîtes

Most packing uses boxes as in the above example. These are invisible containers into which we can pack our widgets. When packing widgets into a horizontal box, the objects are inserted horizontally from left to right. In a vertical box, widgets are packed from top to bottom. You may use any combination of boxes inside or beside other boxes to create the desired effect.

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

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

The add() method places widgets inside these containers. It will start at the top and work its way down in a Box with vertical orientation, or pack left to right in a Box with horizontal orientation. If it's inconvenient to add widgets in this order, use insert_child_after() or insert_child_at_start(). We will use add() in our examples.

There are several options governing how widgets are to be packed, and this can be confusing at first. You can modify the packing by using set_expand(), set_hexpand(), set_vexpand(), set_halign(), set_valign() and/or set_margin() on the child widgets. If you have difficulties, then it is sometimes a good idea to play with the glade GUI designer to see what is possible. You might even decide to use the Gtk::Builder API to load your GUI at runtime.

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

Empaquetage dans boîte n°1

Each line contains one horizontal Box with several buttons. Each of the buttons on a line is packed into the Box with the same arguments to the set_hexpand(), set_halign(), set_margin_start() and set_margin_end() methods.

Reference

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

Here's the constructor for the Box widget, and methods that set per-container packing options:

    Gtk::Box(Gtk::Orientation orientation = Gtk::Orientation::HORIZONTAL, int spacing = 0);
    void set_orientation(Gtk::Orientation orientation);
    void set_spacing(int spacing);
    void set_homogeneous(bool homogeneous = true);

Passing `true` to set_homogeneous() will cause all of the contained widgets to be the same size. spacing is a (minimum) number of pixels to leave between each widget.

What's the difference between spacing (set when the box is created) and margins (set separately for each child widget)? Spacing is added between objects, and margins are added on one or more sides of a widget. The following figure should make it clearer. The shown margins are the left and right margins of each button in the row.

Empaquetage dans boîte n°2

##### Gtk::Application and command-line options

The following example program requires a command-line option. The source code shows two ways of handling command-line options in combination with Gtk::Application.

- Handle the options in `main()` and hide them from Gtk::Application by setting `argc = 1` in the call to Gtk::Application::run().

- Give all command-line options to Gtk::Application::run() and add the flag `Gio::Application::Flags::HANDLES_COMMAND_LINE` to Gtk::Application::create(). Connect a signal handler to the `command_line` signal, and handle the command-line options in the signal handler.

  You must set the optional parameter `after = false` in the call to `signal_command_line().connect()`, because your signal handler must be called before the default signal handler. You must also call Gio::Application::activate() in the signal handler, unless you want your application to exit without showing its main window. (Gio::Application is a base class of Gtk::Application.)

##### 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.

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.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_separator1, m_separator2;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `packbox.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLE_PACKBOX_H
    #define GTKMM_EXAMPLE_PACKBOX_H

    #include <gtkmm.h>

    class PackBox : public Gtk::Box
    {
    public:
      PackBox(bool homogeneous = false, int spacing = 0, bool expand = false,
        Gtk::Align align = Gtk::Align::FILL, int margin = 0);

    protected:
      Gtk::Button m_buttons[4];
    };

    #endif //GTKMM_EXAMPLE_PACKBOX_H

File: `main.cc` (For use with gtkmm 4)

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

    #define GTK_APPLICATION_RECEIVES_COMMAND_LINE_ARGUMENTS 0

    #if GTK_APPLICATION_RECEIVES_COMMAND_LINE_ARGUMENTS
    namespace
    {
    int on_command_line(const Glib::RefPtr<Gio::ApplicationCommandLine>& command_line,
                        Glib::RefPtr<Gtk::Application>& app)
    {
      int argc = 0;
      char** argv = command_line->get_arguments(argc);

      for (int i = 0; i < argc; ++i)
        std::cout << "argv[" << i << "] = " << argv[i] << std::endl;

      app->activate(); // Without activate() the window won't be shown.
      return EXIT_SUCCESS;
    }
    } // anonymous namespace
    #endif

    int main(int argc, char *argv[])
    {
      if (argc != 2)
      {
        std::cerr << "Usage: example <num>, where <num> is 1, 2, or 3." << std::endl;
        return EXIT_FAILURE;
      }

      int argc1 = argc;

    #if GTK_APPLICATION_RECEIVES_COMMAND_LINE_ARGUMENTS
      // The Gio::Application::Flags::HANDLES_COMMAND_LINE flag and the
      // on_command_line() signal handler are not necessary. This program is simpler
      // without them, and with argc = 1 in the call to Gtk::Application::run().
      // They are included to show a program with Gio::Application::Flags::HANDLES_COMMAND_LINE.
      // Gio::Application::Flags::NON_UNIQUE makes it possible to run several instances of
      // this application simultaneously.
      auto app = Gtk::Application::create(
        "org.gtkmm.example", Gio::Application::Flags::HANDLES_COMMAND_LINE | Gio::Application::Flags::NON_UNIQUE);

      // Note after = false.
      // Only one signal handler is invoked. This signal handler must run before
      // the default signal handler, or else it won't run at all.
      app->signal_command_line().connect(sigc::bind(sigc::ptr_fun(&on_command_line), app), false);
    #else
      // Gio::Application::Flags::NON_UNIQUE makes it possible to run several instances of
      // this application simultaneously.
      argc1 = 1; // Don't give the command line arguments to Gtk::Application.
      auto app = Gtk::Application::create("org.gtkmm.example", Gio::Application::Flags::NON_UNIQUE);
    #endif

      ExampleWindow window(std::atoi(argv[1]));
      return app->run(window, argc1, argv); // Shows the window and returns when it is closed.
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

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

      m_separator1.set_margin_top(5);
      m_separator1.set_margin_bottom(5);
      m_separator2.set_margin_top(5);
      m_separator2.set_margin_bottom(5);

      switch(which)
      {
        case 1:
        {
          m_Label1.set_text("Gtk::Box(Gtk::Orientation::HORIZONTAL, 0); set_homogeneous(false);");

          // Align the label to the left side.
          m_Label1.set_halign(Gtk::Align::START);
          m_Label1.set_valign(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.add(m_Label1);

          // Create a PackBox - homogeneous = false, spacing = 0,
          // expand = false, Gtk::Align::FILL, margin = 0
          // These are the default values.
          auto pPackBox = Gtk::make_managed<PackBox>();
          m_box1.add(*pPackBox);

          // Create a PackBox - homogeneous = false, spacing = 0,
          // expand = true, Gtk::Align::CENTER, margin = 0
          pPackBox = Gtk::make_managed<PackBox>(false, 0, true, Gtk::Align::CENTER);
          m_box1.add(*pPackBox);

          // Create a PackBox - homogeneous = false, spacing = 0,
          // expand = true, Gtk::Align::FILL, margin = 0
          pPackBox = Gtk::make_managed<PackBox>(false, 0, true);
          m_box1.add(*pPackBox);

          // 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.add(m_separator1);

          // create another new label, and show it.
          m_Label2.set_text("Gtk::Box(Gtk::Orientation::HORIZONTAL, 0); set_homogeneous(true);");
          m_Label2.set_halign(Gtk::Align::START);
          m_Label2.set_valign(Gtk::Align::START);
          m_box1.add(m_Label2);

          // Args are: homogeneous, spacing, expand, align, margin
          pPackBox = Gtk::make_managed<PackBox>(true, 0, true, Gtk::Align::CENTER);
          m_box1.add(*pPackBox);

          // Args are: homogeneous, spacing, expand, align, margin
          pPackBox = Gtk::make_managed<PackBox>(true, 0, true);
          m_box1.add(*pPackBox);

          m_box1.add(m_separator2);

          break;
        }

        case 2:
        {
          m_Label1.set_text("Gtk::Box(Gtk::Orientation::HORIZONTAL, 10); set_homogeneous(false);");
          m_Label1.set_halign(Gtk::Align::START);
          m_Label1.set_valign(Gtk::Align::START);
          m_box1.add(m_Label1);

          auto pPackBox = Gtk::make_managed<PackBox>(false, 10, true, Gtk::Align::CENTER);
          m_box1.add(*pPackBox);

          pPackBox = Gtk::make_managed<PackBox>(false, 10, true);
          m_box1.add(*pPackBox);

          m_box1.add(m_separator1);

          m_Label2.set_text("Gtk::Box(Gtk::Orientation::HORIZONTAL, 0); set_homogeneous(false);");
          m_Label2.set_halign(Gtk::Align::START);
          m_Label2.set_valign(Gtk::Align::START);
          m_box1.add(m_Label2);

          pPackBox = Gtk::make_managed<PackBox>(false, 0, false, Gtk::Align::FILL, 10);
          m_box1.add(*pPackBox);

          pPackBox = Gtk::make_managed<PackBox>(false, 0, true, Gtk::Align::FILL, 10);
          m_box1.add(*pPackBox);

          m_box1.add(m_separator2);

          break;
        }

        case 3:
        {
          // This demonstrates the ability to use Gtk::Align::END to
          // right justify widgets.  First, we create a new box as before.
          auto pPackBox = Gtk::make_managed<PackBox>();

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

          // pack it using Gtk::Align::END, so it is put on the right side
          // of the PackBox.
          m_Label1.set_halign(Gtk::Align::END);
          m_Label1.set_hexpand(true);
          pPackBox->add(m_Label1);

          m_box1.add(*pPackBox);

          // This explicitly sets the separator to 700 pixels wide by 5 pixels
          // high.  This is so the hbox we created will also be 700 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_separator1.set_size_request(700, 5);

          // pack the separator into the vbox.
          m_box1.add(m_separator1);

          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.
      m_boxQuit.add(m_buttonQuit);
      m_buttonQuit.set_hexpand(true);
      m_buttonQuit.set_halign(Gtk::Align::CENTER);
      m_box1.add(m_boxQuit);

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

    ExampleWindow::~ExampleWindow()
    {
    }

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

File: `packbox.cc` (For use with gtkmm 4)

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

    namespace
    {
      const std::map<Gtk::Align, Glib::ustring> align_string = {
        {Gtk::Align::FILL, "Gtk::Align::FILL"},
        {Gtk::Align::START, "Gtk::Align::START"},
        {Gtk::Align::END, "Gtk::Align::END"},
        {Gtk::Align::CENTER, "Gtk::Align::CENTER"},
        {Gtk::Align::BASELINE, "Gtk::Align::BASELINE"},
      };
    }

    PackBox::PackBox(bool homogeneous, int spacing, bool expand, Gtk::Align align, int margin)
    : Gtk::Box(Gtk::Orientation::HORIZONTAL, spacing)
    {
      set_homogeneous(homogeneous);

      m_buttons[0].set_label("box.add(button);");
      m_buttons[1].set_label("expand=" + Glib::ustring(expand ? "true" : "false"));
      m_buttons[2].set_label(align_string.at(align));
      m_buttons[3].set_label("margin=" + Glib::ustring::format(margin));

      for (auto& button : m_buttons)
      {
        add(button);
        button.set_hexpand(expand);
        button.set_halign(align);
        button.set_margin_start(margin);
        button.set_margin_end(margin);
      }
    }

#### 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.

Reference

##### 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

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      // Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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");

      m_grid.set_margin(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::PositionType::BOTTOM, 2, 1);

      m_button_1.signal_clicked().connect(
        sigc::bind( sigc::mem_fun(*this, &ExampleWindow::on_button_numbered), "button 1") );
      m_button_2.signal_clicked().connect(
        sigc::bind( sigc::mem_fun(*this, &ExampleWindow::on_button_numbered), "button 2") );

      m_button_quit.signal_clicked().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_button_quit) );
    }

    ExampleWindow::~ExampleWindow()
    {
    }

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

    void
    ExampleWindow::on_button_numbered(const Glib::ustring& data)
    {
      std::cout << data << " was pressed" << std::endl;
    }

#### 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().

Reference

##### Exemple

Bloc-note

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::Box m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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_default_size(400, 200);

      m_VBox.set_margin(10);
      add(m_VBox);

      //Add the Notebook, with the button underneath:
      m_Notebook.set_margin(10);
      m_Notebook.set_expand();
      m_VBox.add(m_Notebook);
      m_VBox.add(m_ButtonBox);

      m_ButtonBox.add(m_Button_Quit);
      m_Button_Quit.set_hexpand(true);
      m_Button_Quit.set_halign(Gtk::Align::CENTER);
      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) );
    }

    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.
    }

#### 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().

To set the title of a page, use the set_page_title() method.

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.

Reference

##### Exemple

Assistant

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::Grid m_grid;
      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: `exampleassistant.h` (For use with gtkmm 4)

    #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: `exampleassistant.cc` (For use with gtkmm 4)

    #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_default_size(400, 300);

      m_box.add(m_label1);
      m_box.add(m_entry);
      m_label1.set_expand();
      m_entry.set_expand();

      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::AssistantPage::Type::INTRO);
      set_page_type(m_label2, Gtk::AssistantPage::Type::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));
    }

    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;
    }

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      // Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #include "examplewindow.h"
    #include "exampleassistant.h"

    ExampleWindow::ExampleWindow()
    : m_button("Show the assistant"),
      m_label1("State of assistant checkbutton:", Gtk::Align::START, Gtk::Align::CENTER),
      m_label2("Contents of assistant entry:", Gtk::Align::START, Gtk::Align::CENTER)
    {
      set_title("Gtk::Assistant example");

      m_grid.set_row_homogeneous(true);
      m_grid.set_column_spacing(5);
      m_grid.set_margin(12);

      m_grid.attach(m_button, 0, 0, 2, 1);
      m_button.set_hexpand(true);
      m_button.set_valign(Gtk::Align::CENTER);

      m_grid.attach(m_label1, 0, 1, 1, 1);

      m_grid.attach(m_label2, 0, 2, 1, 1);

      m_grid.attach(m_check, 1, 1, 1, 1);
      m_check.set_halign(Gtk::Align::START);

      m_grid.attach(m_entry, 1, 2, 1, 1);
      m_entry.set_hexpand(true);

      add(m_grid);

      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);
    }

    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();
    }

#### Other Multi-item Containers

There are other multi-item containers. See the reference documentation for a complete list. Here are links to some example programs that show containers, which are not mentioned elsewhere in this tutorial.

Source Code, FlowBox

Source Code, IconView

## 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.

Reference

#### 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

Reference

#### 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

Reference

#### 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);

As a TreeModelColumnRecord describes structure, not data, it can be shared among multiple models, and this is preferable for efficiency. However, the instance (such as `m_Columns` here) should usually not be static, because it often needs to be instantiated after glibmm has been initialized. The best solution is to make it a lazily instantiated singleton, so that it will be constructed on-demand, whenever the first model accesses it.

#### Ajout de lignes

Ajoutez des lignes au modèle avec les fonctions membres append(), prepend() ou insert().

    auto iter = m_refListStore->append();

Vous pouvez déréférencer l'itérateur pour obtenir la ligne :

    auto 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 :

    auto iter_child =
        m_refTreeStore->append(row.children());

#### Définition des valeurs

You can use the operator[] overload to set the data for a particular column in the row, specifying the TreeModelColumn used to create the model.

    row[m_Columns.m_col_text] = "textedonné";

#### Obtention des valeurs

You can use the operator[] overload to get the data in a particular column in a row, specifying the TreeModelColumn used to create the model.

    auto strText = row[m_Columns.m_col_text];
    auto 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.

Reference

#### 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);

When using this simple append_column() overload, the TreeView will display the model data with an appropriate CellRenderer. For instance, strings and numbers are shown in a simple Gtk::Entry widget, and booleans are shown in a Gtk::CheckButton. This is usually what you need. For other column types you must either connect a callback that converts your type into a string representation, with TreeViewColumn::set_cell_data_func(), or derive a custom CellRenderer. Note that (unsigned) short is not supported by default - You could use (unsigned) int or (unsigned) long as the column type instead.

#### 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.

Then use append_column() to add the view Column to the View. Notice that Gtk::TreeView::append_column() is overloaded to accept either a prebuilt Gtk::TreeView::Column widget, or just the TreeModelColumn from which it generates an appropriate Gtk::TreeView::Column widget.

Here is some example code, which has a pixbuf icon and a text name in the same column:

    auto pColumn = Gtk::make_managed<Gtk::TreeView::Column>("Icon Name");

    // m_columns.icon and m_columns.iconname are columns in the model.
    // pColumn is the column in the TreeView:
    pColumn->pack_start(m_columns.icon, /* expand= */ false);
    pColumn->pack_start(m_columns.iconname);

    m_TreeView.append_column(*pColumn);

#### Détails pour la définition du CellRenderer

The default CellRenderers and their default behaviour will normally suffice, but you might occasionally need finer control. For instance, this example code from `gtkmm/demos/gtk-demo/example_treeview_treestore.cc`, appends a Gtk::CellRenderer widget and instructs it to render the data from various model columns through various aspects of its appearance.

    auto cols_count = m_TreeView.append_column_editable("Alex", m_columns.alex);
    auto pColumn = m_TreeView.get_column(cols_count-1);
    if(pColumn)
    {
      auto pRenderer = static_cast<Gtk::CellRendererToggle*>(pColumn->get_first_cell());
      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 :

    auto pRenderer = Gtk::make_managed<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.

Cells in a TreeView can be edited in-place by the user. To allow this, use the Gtk::TreeView insert_column_editable() and append_column_editable() methods instead of insert_column() and append_column(). When these cells are edited the new values will be stored immediately in the Model. Note that these methods are templates which can only be instantiated for simple column types such as Glib::ustring, int, and 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.

To achieve this, you should use the normal Gtk::TreeView insert_column() and append_column() methods, then use get_column_cell_renderer() to get the Gtk::CellRenderer used by that column.

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.

You can then connect to the appropriate "edited" signal. For instance, connect to Gtk::CellRendererText::signal_edited(), or Gtk::CellRendererToggle::signal_toggled(). If the column contains more than one CellRenderer then you will need to use Gtk::TreeView::get_column() and then call get_cells() on that view Column.

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 :

    auto children = refModel->children();
    for (auto iter = children.begin(), end = children.end(); iter != end; ++iter)
    {
      auto row = *iter;
      //Do something with the row - see above for set/get.
    }

If you always want to iterate across the entire range, much more succinct syntax is possible using C++'s range-based `for` loop:

    for (auto row: refModel->children())
    {
      //Do something with the row - see above for set/get.
    }

#### Ligne enfant

When using a Gtk::TreeStore, the rows can have child rows, which can have their own children in turn. Use Gtk::TreeModel::Row::children() to get the container of child Rows:

    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 :

    auto refTreeSelection = m_TreeView.get_selection();

#### Sélection simple ou multiple

By default, only single rows can be selected, but you can allow multiple selection by setting the mode, like so:

    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 :

    auto iter = refTreeSelection->get_selected();
    if(iter) //If anything is selected
    {
      auto row = *iter;
      //Do something with the row.
    }

For multiple-selection, you need to call get_selected_rows() or define a callback, and give it to selected_foreach(), selected_foreach_path(), or selected_foreach_iter(), like so:

    refTreeSelection->selected_foreach_iter(
        sigc::mem_fun(*this, &TheClass::selected_row_callback) );

    void TheClass::selected_row_callback(
        const Gtk::TreeModel::const_iterator& iter)
    {
      auto row = *iter;
      //Do something with the row.
    }

#### 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_IconTheme::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 auto iter = model->get_iter(path);
      return iter->children().empty(); // only allow leaf nodes to be selected
    }

#### Modification de la sélection

Pour modifier la sélection, précisez un Gtk::TreeModel::iterator ou Gtk::TreeModel::Row, ainsi :

    auto row = m_refModel->children()[5]; //The sixth row.
    if(row)
      refTreeSelection->select(row.get_iter());

ou

    auto iter = m_refModel->children().begin()
    if(iter)
      refTreeSelection->select(iter);

### Tris

The standard tree models (TreeStore and ListStore) derive from TreeSortable, so they offer sorting functionality. For instance, call set_sort_column(), to sort the model by the specified column. Or supply a callback function to set_sort_func() to implement a more complicated sorting algorithm.

TreeSortable Reference

#### Tri en cliquant sur l'en-tête de colonne

So that a user can click on a TreeView's column header to sort the TreeView's contents, call Gtk::TreeView::Column::set_sort_column(), supplying the model column on which model should be sorted when the header is clicked. For instance:

    auto 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

The TreeView already allows you to show the same TreeModel in two TreeView widgets. If you need one of these TreeViews to sort the model differently than the other then you should use a TreeModelSort instead of just, for instance, Gtk::TreeViewColumn::set_sort_column(). TreeModelSort is a model that contains another model, presenting a sorted version of that model. For instance, you might add a sorted version of a model to a TreeView like so:

    auto 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()
    {
      auto refTreeSelection = m_treeview.get_selection();
      if(refTreeSelection)
      {
        auto sorted_iter = m_refTreeSelection->get_selected();
        if(sorted_iter)
        {
          auto iter = m_refModelSort->convert_iter_to_child_iter(sorted_iter);
          m_refModel->erase(iter);
        }
      }
    }

TreeModelSort Reference

### Glisser-déposer

Gtk::TreeView already implements simple drag-and-drop when used with the Gtk::ListStore or Gtk::TreeStore models. If necessary, it also allows you to implement more complex behaviour when items are dragged and dropped, using the normal Drag and Drop API.

#### 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.

However, this does not allow you any control of which items can be dragged, and where they can be dropped. If you need that extra control then you might create a derived `Gtk::TreeModel` from `Gtk::TreeStore` or `Gtk::ListStore` and override the `Gtk::TreeDragSource::row_draggable_vfunc()` and `Gtk::TreeDragDest::row_drop_possible_vfunc()` virtual methods. You can examine the `Gtk::TreeModel::Path`s provided and allow or disallow dragging or dropping by returning `true` or `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`

To detect a click of the right mouse button, you need to handle the `button_press_event` signal, and check exactly which button was pressed. Because the TreeView normally handles this signal completely, you need to either override the default signal handler in a derived TreeView class, use connect_notify() or use connect(slot, /* after= */ false). You probably also want to call the default handler before doing anything else, so that the right-click will cause the row to be selected first.

This is demonstrated in the Popup Context Menu example.

### Exemples

#### ListStore

Voici un exemple d'élément graphique Gtk::TreeView avec un modèle Gtk::ListStore.

TreeView - ListStore

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::Box m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::Orientation::VERTICAL),
      m_Button_Quit("Quit")
    {
      set_title("Gtk::TreeView (ListStore) example");
      set_default_size(400, 200);

      m_VBox.set_margin(5);
      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::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
      m_ScrolledWindow.set_expand();

      m_VBox.add(m_ScrolledWindow);
      m_VBox.add(m_ButtonBox);

      m_ButtonBox.add(m_Button_Quit);
      m_ButtonBox.set_margin(5);
      m_Button_Quit.set_hexpand(true);
      m_Button_Quit.set_halign(Gtk::Align::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
      auto 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:
      auto cell = Gtk::make_managed<Gtk::CellRendererProgress>();
      int cols_count = m_TreeView.append_column("Some percentage", *cell);
      auto 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++)
      {
        auto column = m_TreeView.get_column(i);
        column->set_reorderable();
      }
    }

    ExampleWindow::~ExampleWindow()
    {
    }

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

#### 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

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::Box m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::Orientation::VERTICAL),
      m_Button_Quit("Quit")
    {
      set_title("Gtk::TreeView (TreeStore) example");
      set_default_size(400, 200);

      m_VBox.set_margin(5);
      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::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
      m_ScrolledWindow.set_expand();

      m_VBox.add(m_ScrolledWindow);
      m_VBox.add(m_ButtonBox);

      m_ButtonBox.add(m_Button_Quit);
      m_ButtonBox.set_margin(5);
      m_Button_Quit.set_hexpand(true);
      m_Button_Quit.set_halign(Gtk::Align::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
      auto row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "Billy Bob";

      auto 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) );
    }

    ExampleWindow::~ExampleWindow()
    {
    }

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

    void ExampleWindow::on_treeview_row_activated(const Gtk::TreeModel::Path& path,
            Gtk::TreeViewColumn* /* column */)
    {
      const auto iter = m_refTreeModel->get_iter(path);
      if(iter)
      {
        const auto row = *iter;
        std::cout << "Row activated: ID=" << row[m_Columns.m_col_id] << ", Name="
            << row[m_Columns.m_col_name] << std::endl;
      }
    }

#### 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

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::const_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::Box 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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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_default_size(400, 200);

      m_VBox.set_margin(5);
      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::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
      m_ScrolledWindow.set_expand();

      m_VBox.add(m_ScrolledWindow);
      m_VBox.add(m_ButtonBox);

      m_ButtonBox.add(m_Button_Quit);
      m_ButtonBox.set_margin(5);
      m_Button_Quit.set_hexpand(true);
      m_Button_Quit.set_halign(Gtk::Align::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
      auto 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;
    }

    ExampleWindow::~ExampleWindow()
    {
    }

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

    void ExampleWindow::treeviewcolumn_validated_on_cell_data(
            Gtk::CellRenderer* /* renderer */,
            const Gtk::TreeModel::const_iterator& iter)
    {
      //Get the value from the model and show it appropriately in the view:
      if(iter)
      {
        const auto 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);

        auto 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.
        auto celleditable_validated = cell_editable;

        //It's usually an Entry, at least for a CellRendererText:
        auto 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 = nullptr;
      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::MessageType::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:
        auto iter = m_refTreeModel->get_iter(path);
        if(iter)
        {
          auto row = *iter;

          //Put the new value in the model:
          row[m_Columns.m_col_number_validated] = new_value;
        }
      }
    }

#### Glisser-déposer

This example is much like the TreeStore example, but has 2 extra columns to indicate whether the row can be dragged, and whether it can receive drag-and-dropped rows. It uses a derived Gtk::TreeStore which overrides the virtual functions as described in the TreeView Drag and Drop section.

TreeView - Glisser-déposer

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::Box m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `treemodel_dnd.h` (For use with gtkmm 4)

    #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:
      bool row_draggable_vfunc(const Gtk::TreeModel::Path& path) const override;
      bool row_drop_possible_vfunc(const Gtk::TreeModel::Path& dest, const Gtk::SelectionData& selection_data) const override;

    };

    #endif //GTKMM_EXAMPLE_TREEMODEL_DND_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::Orientation::VERTICAL),
      m_Button_Quit("_Quit", true)
    {
      set_title("Gtk::TreeView (Drag and Drop) example");
      set_default_size(400, 200);

      m_VBox.set_margin(5);
      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::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
      m_ScrolledWindow.set_expand();

      m_VBox.add(m_ScrolledWindow);
      m_VBox.add(m_ButtonBox);

      m_ButtonBox.add(m_Button_Quit);
      m_ButtonBox.set_margin(5);
      m_Button_Quit.set_hexpand(true);
      m_Button_Quit.set_halign(Gtk::Align::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
      auto 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;

      auto 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);
    }

    ExampleWindow::~ExampleWindow()
    {
    }

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

File: `treemodel_dnd.cc` (For use with gtkmm 4)

    #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:

      const const_iterator iter = get_iter(path);
      if(iter)
      {
        ConstRow 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:
      auto 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:
        const const_iterator iter_dest_parent = get_iter(dest_parent);
        if(iter_dest_parent)
        {
          ConstRow 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
      //   Glib::RefPtr<const Gtk::TreeModel> model_dragged_row;
      //   Gtk::TreeModel::Path path_dragged_row;
      //   Gtk::TreeModel::Path::get_from_selection_data(selection_data,
      //     model_dragged_row, path_dragged_row);
      // This is risky, though. If the row being dragged, and thus selection_data,
      // does not originate in the process that's calling get_from_selection_data(),
      // you'll most likely get a segmentation fault. See the documentation of
      // Gtk::TreePath::get_from_selection_data() or gtk_tree_get_row_drag_data().

      return Gtk::TreeStore::row_drop_possible_vfunc(dest, selection_data);
    }

#### 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

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::Box m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `treeview_withpopup.h` (For use with gtkmm 4)

    #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:
      // Signal handler for showing popup menu:
      void on_popup_button_pressed(int n_press, double x, double y);

      //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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::Orientation::VERTICAL),
      m_Button_Quit("Quit")
    {
      set_title("Gtk::TreeView (ListStore) example");
      set_default_size(400, 200);

      m_VBox.set_margin(5);
      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::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
      m_ScrolledWindow.set_expand();

      m_VBox.add(m_ScrolledWindow);
      m_VBox.add(m_ButtonBox);

      m_ButtonBox.add(m_Button_Quit);
      m_ButtonBox.set_margin(5);
      m_Button_Quit.set_hexpand(true);
      m_Button_Quit.set_halign(Gtk::Align::END);
      m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );
    }

    ExampleWindow::~ExampleWindow()
    {
    }

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

File: `treeview_withpopup.cc` (For use with gtkmm 4)

    #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
      auto 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);

      // Catch button press events:
      auto refGesture = Gtk::GestureMultiPress::create();
      refGesture->set_button(GDK_BUTTON_SECONDARY);
      refGesture->signal_pressed().connect(
        sigc::mem_fun(*this, &TreeView_WithPopup::on_popup_button_pressed));
      add_controller(refGesture);

      //Fill popup menu:
      auto item = Gtk::make_managed<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::make_managed<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::make_managed<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);
    }

    TreeView_WithPopup::~TreeView_WithPopup()
    {
    }

    void TreeView_WithPopup::on_popup_button_pressed(int /* n_press */, double /* x */, double /* y */)
    {
      m_Menu_Popup.popup_at_pointer();
    }

    void TreeView_WithPopup::on_menu_file_popup_generic()
    {
      std::cout << "A popup menu item was selected." << std::endl;

      auto refSelection = get_selection();
      if(refSelection)
      {
        auto iter = refSelection->get_selected();
        if(iter)
        {
          int id = (*iter)[m_Columns.m_col_id];
          std::cout << "  Selected ID=" << id << std::endl;
        }
      }
    }

## Boîtes combinées

The ComboBox widget offers a list (or tree) of choices in a dropdown menu. If appropriate, it can show extra information about each item, such as text, a picture, a check button, or a progress bar. The ComboBox widget usually restricts the user to the available choices, but it can optionally have an Entry, allowing the user to enter arbitrary text if none of the available choices are suitable.

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.

Reference

### Le modèle

The model for a ComboBox can be defined and filled exactly as for a TreeView. For instance, you might derive a ComboBox class with one integer and one text column, like so:

    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;

After appending rows to this model, you should provide the model to the ComboBox with the set_model() method. Then use the pack_start() or pack_end() methods to specify what columns will be displayed in the ComboBox. As with the TreeView you may either use the default cell renderer by passing the TreeModelColumn to the pack methods, or you may instantiate a specific CellRenderer and specify a particular mapping with either add_attribute() or set_cell_data_func(). Note that these methods are in the CellLayout base class.

### L'élément choisi

To discover what item, if any, the user has chosen from the ComboBox, call ComboBox::get_active(). This returns a TreeModel::iterator that you can dereference to a Row in order to read the values in your columns. For instance, you might read an integer ID value from the model, even though you have chosen only to show the human-readable description in the ComboBox. For instance:

    Gtk::TreeModel::iterator iter = m_Combo.get_active();
    if(iter)
    {
      auto row = *iter;

      //Get the data for the selected row, using our knowledge
      //of the tree model:
      auto id = row[m_Columns.m_col_id];
      set_something_id_chosen(id); //Your own function.
    }
    else
      set_nothing_chosen(); //Your own function.

### Réponse à une modification

You might need to react to every change of selection in the ComboBox, for instance to update other widgets. To do so, you should handle the `changed` signal. For instance:

    m_combo.signal_changed().connect( sigc::mem_fun(*this,
          &ExampleWindow::on_combo_changed) );

### Exemple complet

ComboBox

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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:
      void on_cell_data_extra(const Gtk::TreeModel::const_iterator& iter);

      //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); add(m_col_extra);}

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

      ModelColumns m_Columns;

      //Child widgets:
      Gtk::ComboBox m_Combo;
      Gtk::CellRendererText m_cell;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #include "examplewindow.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:
      auto iter = m_refTreeModel->append();
      auto row = *iter;
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "Billy Bob";
      row[m_Columns.m_col_extra] = "something";
      m_Combo.set_active(iter);
      /*
      auto 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_Columns.m_col_extra] = "yadda";

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 3;
      row[m_Columns.m_col_name] = "Rob McRoberts";
      row[m_Columns.m_col_extra] = "";

      /*
      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);

      //An example of adding a cell renderer manually,
      //instead of using pack_start(model_column, Gtk::PackOptions::EXPAND_WIDGET)
      //so we have more control:
      m_Combo.set_cell_data_func(m_cell,
        sigc::mem_fun(*this, &ExampleWindow::on_cell_data_extra));
      m_Combo.pack_start(m_cell);

      //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) );
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_cell_data_extra(const Gtk::TreeModel::const_iterator& iter)
    {
      auto row = *iter;
      const Glib::ustring extra = row[m_Columns.m_col_extra];

      //Some arbitrary logic just to show that this is where you can do such things:

      //Transform the value, deciding how to represent it as text:
      if(extra.empty())
        m_cell.property_text() = "(none)";
      else
        m_cell.property_text() = "-" + extra + "-";

      //Change other cell renderer properties too:
      m_cell.property_foreground() = (extra == "yadda" ? "red" : "green");
    }

    void ExampleWindow::on_combo_changed()
    {
      const auto iter = m_Combo.get_active();
      if(iter)
      {
        const auto 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;
    }

### Exemple texte simple

ComboBoxText

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #include "examplewindow.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");
      m_Combo.set_active(1);

      add(m_Combo);

      //Connect signal handler:
      m_Combo.signal_changed().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_combo_changed) );
    }

    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;
    }

### Boîte combinée avec saisie

A ComboBox may contain an Entry widget for entering of arbitrary text, by specifying `true` for the constructor's `has_entry` parameter.

#### 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_entry_text_column(). For instance:

    m_combo.set_entry_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

Because the user may enter arbitrary text, an active model row isn't enough to tell us what text the user has entered. Therefore, you should retrieve the Entry widget with the ComboBox::get_entry() method and call get_text() on that.

#### Réponse à une modification

When the user enters arbitrary text, it may not be enough to connect to the `changed` signal, which is emitted for every typed character. It is not emitted when the user presses the Enter key. Pressing the Enter key or moving the keyboard focus to another widget may signal that the user has finished entering text. To be notified of these events, connect to the Entry's `activate` and `focus_out_event` signals, like so

    auto entry = m_Combo.get_entry();
    if (entry)
    {
      // Alternatively you can connect to m_Combo.signal_changed().
      entry->signal_changed().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_entry_changed) );

      entry->signal_activate().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_entry_activate) );

      entry->signal_focus_out_event().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_entry_focus_out_event) );
    }

The `changed` signals of ComboBox and Entry are both emitted for every change. It doesn't matter which one you connect to. But only Entry's `focus_out_event` signal is useful here.

X events are described in more detail in the X Event signals section in the appendix.

#### Exemple complet

ComboBox with Entry

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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();
      void on_entry_changed();
      void on_entry_has_focus_changed();

      //Signal connection:
      sigc::connection m_ConnectionHasFocusChanged;
      bool m_entry_had_focus {false};

      //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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #include "examplewindow.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:
      auto row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = "1";
      row[m_Columns.m_col_name] = "Billy Bob";
      /*
      auto 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, Gtk::PackOptions::EXPAND_WIDGET);
      m_Combo.pack_start(m_Columns.m_col_name);

      m_Combo.set_entry_text_column(m_Columns.m_col_id);
      m_Combo.set_active(1);

      //Add the ComboBox to the window.
      add(m_Combo);

      //Connect signal handlers:
      m_Combo.signal_changed().connect(sigc::mem_fun(*this, &ExampleWindow::on_combo_changed));

      auto entry = m_Combo.get_entry();
      if (entry)
      {
        entry->signal_changed().connect(sigc::mem_fun(*this,
          &ExampleWindow::on_entry_changed) );
        m_ConnectionHasFocusChanged = entry->property_has_focus().signal_changed().
          connect(sigc::mem_fun(*this, &ExampleWindow::on_entry_has_focus_changed));
      }
      else
        std::cout << "No Entry ???" << std::endl;
    }

    ExampleWindow::~ExampleWindow()
    {
      // The has_focus changed signal may be emitted while m_Combo is being destructed.
      // The signal handler can generate critical messages, if it's called when
      // m_Combo has been partly destructed.
      m_ConnectionHasFocusChanged.disconnect();
    }

    void ExampleWindow::on_combo_changed()
    {
      auto entry = m_Combo.get_entry();
      if (entry)
      {
        std::cout << "on_combo_changed(): Row=" << m_Combo.get_active_row_number()
          << ", ID=" << entry->get_text() << std::endl;
      }
    }

    void ExampleWindow::on_entry_changed()
    {
      auto entry = m_Combo.get_entry();
      if (entry)
      {
        std::cout << "on_entry_changed(): Row=" << m_Combo.get_active_row_number()
          << ", ID=" << entry->get_text() << std::endl;
      }
    }

    void ExampleWindow::on_entry_has_focus_changed()
    {
      auto entry = m_Combo.get_entry();
      if (entry)
      {
        const bool entry_has_focus = entry->has_focus();
        if (m_entry_had_focus && !entry_has_focus)
        {
          // entry->has_focus() has changed from true to false; entry has lost focus.
          std::cout << "on_entry_has_focus_changed() to not focused: Row="
            << m_Combo.get_active_row_number() << ", ID=" << entry->get_text() << std::endl;
        }
        m_entry_had_focus = entry_has_focus;
      }
    }

#### Exemple texte simple

ComboBoxText with Entry

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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();
      void on_entry_changed();
      void on_entry_has_focus_changed();

      //Signal connection:
      sigc::connection m_ConnectionHasFocusChanged;
      bool m_entry_had_focus {false};

      //Child widgets:
      Gtk::ComboBoxText m_Combo;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #include "examplewindow.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");
      m_Combo.set_active(0);

      add(m_Combo);

      //Connect signal handlers:
      m_Combo.signal_changed().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_combo_changed) );

      auto entry = m_Combo.get_entry();
      if (entry)
      {
        entry->signal_changed().connect(sigc::mem_fun(*this,
          &ExampleWindow::on_entry_changed));
        m_ConnectionHasFocusChanged = entry->property_has_focus().signal_changed().
          connect(sigc::mem_fun(*this, &ExampleWindow::on_entry_has_focus_changed));
      }
      else
        std::cout << "No Entry ???" << std::endl;

      m_Combo.property_has_frame() = false;
    }

    ExampleWindow::~ExampleWindow()
    {
      // The has_focus changed signal may be emitted while m_Combo is being destructed.
      // The signal handler can generate critical messages, if it's called when
      // m_Combo has been partly destructed.
      m_ConnectionHasFocusChanged.disconnect();
    }

    void ExampleWindow::on_combo_changed()
    {
      std::cout << "on_combo_changed(): Row=" << m_Combo.get_active_row_number()
        << ", Text=" << m_Combo.get_active_text() << std::endl;
    }

    void ExampleWindow::on_entry_changed()
    {
      std::cout << "on_entry_changed(): Row=" << m_Combo.get_active_row_number()
        << ", Text=" << m_Combo.get_active_text() << std::endl;
    }

    void ExampleWindow::on_entry_has_focus_changed()
    {
      auto entry = m_Combo.get_entry();
      if (entry)
      {
        const bool entry_has_focus = entry->has_focus();
        if (m_entry_had_focus && !entry_has_focus)
        {
          // entry->has_focus() has changed from true to false; entry has lost focus.
          std::cout << "on_entry_has_focus_changed() to not focused: Row="
            << m_Combo.get_active_row_number() << ", ID=" << entry->get_text() << std::endl;
        }
        m_entry_had_focus = entry_has_focus;
      }
    }

## É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().

Reference

#### Itérateurs

A Gtk::TextBuffer::iterator and a Gtk::TextBuffer::const_iterator represent a position between two characters in the text buffer. Whenever the buffer is modified in a way that affects the number of characters in the buffer, all outstanding iterators become invalid. Because of this, iterators can't be used to preserve positions across buffer modifications. To preserve a position, use Gtk::TextBuffer::Mark.

Reference

#### 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 :

    auto 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.

Reference

##### 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 :

    auto refTagTable = Gtk::TextBuffer::TagTable::create();
    refTagTable->add(refTagMatch);
    //Hopefully a future version of gtkmm will have a set_tag_table() method,
    //for use after creation of the buffer.
    auto 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.

Reference

##### 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);

Or you could specify the tag when first inserting the text:

    refBuffer->insert_with_tag(iter, "Some text", 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 :

    auto 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.

There are two built-in Marks - `insert` and `selection_bound`, which you can access with TextBuffer's get_insert() and get_selection_bound() methods.

Reference

#### La vue

As mentioned above, each TextView has a TextBuffer, and one or more TextViews can share the same 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.

Reference

##### 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 has various scroll_to() methods. These allow you to ensure that a particular part of the text buffer is visible. For instance, your application's Find feature might use Gtk::TextView::scroll_to() to show the found text.

### É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() :

    auto 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);

Reference

### Exemples

#### Un exemple simple

Élément graphique TextView

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::Box m_ButtonBox;
      Gtk::Button m_Button_Quit, m_Button_Buffer1, m_Button_Buffer2;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::Orientation::VERTICAL),
      m_Button_Quit("_Quit", true),
      m_Button_Buffer1("Use buffer 1"),
      m_Button_Buffer2("Use buffer 2")
    {
      set_title("Gtk::TextView example");
      set_default_size(400, 200);

      m_VBox.set_margin(5);
      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::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
      m_ScrolledWindow.set_expand();

      m_VBox.add(m_ScrolledWindow);

      //Add buttons:
      m_VBox.add(m_ButtonBox);

      m_Button_Buffer1.set_hexpand(true);
      m_Button_Buffer1.set_halign(Gtk::Align::END);
      m_ButtonBox.add(m_Button_Buffer1);
      m_ButtonBox.add(m_Button_Buffer2);
      m_ButtonBox.add(m_Button_Quit);
      m_ButtonBox.set_margin(5);
      m_ButtonBox.set_spacing(5);

      //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();
    }

    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);
    }

## Menus et barres d'outils

There are specific APIs for menus and toolbars, but you should usually deal with them together, creating Gio::SimpleActions that you can refer to in both menus and toolbars. In this way you can handle activation of the action instead of responding to the menu and toolbar items separately. And you can enable or disable both the menu and toolbar item via the action. Gtk::Builder can create menus and toolbars.

This involves the use of the Gio::SimpleActionGroup, Gio::SimpleAction and Gtk::Builder classes, all of which should be instantiated via their create() methods, which return RefPtrs.

### Actions

First create the Gio::SimpleActions and add them to a Gio::SimpleActionGroup, with Gio::ActionMap::add_action(). (Gio::ActionMap is a base class of Gio::SimpleActionGroup.) Then add the action group to your window with Gtk::Widget::insert_action_group().

The arguments to add_action() specify the action's name, which is used in the menu items and toolbar buttons. You can also specify a signal handler when calling add_action(). This signal handler will be called when the action is activated via either a menu item or a toolbar button.

Par exemple :

    m_refActionGroup = Gio::SimpleActionGroup::create();

    m_refActionGroup->add_action("new", sigc::mem_fun(*this, &ExampleWindow::on_action_file_new));
    m_refActionGroup->add_action("open", sigc::mem_fun(*this, &ExampleWindow::on_action_file_open));
    m_refActionGroup->add_action("quit", sigc::mem_fun(*this, &ExampleWindow::on_action_file_quit));

    insert_action_group("example", m_refActionGroup);

If you use an Gtk::ApplicationWindow, you don't have to create your own action group. Gio::ActionGroup and Gio::ActionMap are base classes of Gtk::ApplicationWindow.

### Menubar and Toolbar

Next you should create a Gtk::Builder. At this point is also a good idea to tell the application to respond to keyboard shortcuts, by using Gtk::Application::set_accel_for_action().

Par exemple,

    m_refBuilder = Gtk::Builder::create();

    app->set_accel_for_action("example.new", "<Primary>n");
    app->set_accel_for_action("example.quit", "<Primary>q");
    app->set_accel_for_action("example.copy", "<Primary>c");
    app->set_accel_for_action("example.paste", "<Primary>v");

If your main window is derived from ApplicationWindow and you instantiate your menubar with Gtk::Application::set_menubar(), then you don't have to call set_accel_for_action(). See Application Menu and Main Menu example for an example.

Then, you can define the actual visible layout of the menus and toolbars, and add the UI layout to the Builder. This "ui string" uses an XML format, in which you should mention the names of the actions that you have already created. For instance:

    Glib::ustring ui_info =
      "<interface>"
      "  <menu id='menubar'>"
      "    <submenu>"
      "      <attribute name='label' translatable='yes'>_File</attribute>"
      "      <section>"
      "        <item>"
      "          <attribute name='label' translatable='yes'>_New</attribute>"
      "          <attribute name='action'>example.new</attribute>"
      "          <attribute name='accel'>&lt;Primary&gt;n</attribute>"
      "        </item>"
      "      </section>"
      "      <section>"
      "        <item>"
      "          <attribute name='label' translatable='yes'>_Quit</attribute>"
      "          <attribute name='action'>example.quit</attribute>"
      "          <attribute name='accel'>&lt;Primary&gt;q</attribute>"
      "        </item>"
      "      </section>"
      "    </submenu>"
      "    <submenu>"
      "      <attribute name='label' translatable='yes'>_Edit</attribute>"
      "      <item>"
      "        <attribute name='label' translatable='yes'>_Copy</attribute>"
      "        <attribute name='action'>example.copy</attribute>"
      "        <attribute name='accel'>&lt;Primary&gt;c</attribute>"
      "      </item>"
      "      <item>"
      "        <attribute name='label' translatable='yes'>_Paste</attribute>"
      "        <attribute name='action'>example.paste</attribute>"
      "        <attribute name='accel'>&lt;Primary&gt;v</attribute>"
      "      </item>"
      "    </submenu>"
      "  </menu>"
      "</interface>";

    m_refBuilder->add_from_string(ui_info);
    m_refBuilder->add_from_resource("/toolbar/toolbar.glade");

This is where we specify the names of the menu items as they will be seen by users in the menu. Therefore, this is where you should make strings translatable, by adding `translatable='yes'`.

To instantiate a Gtk::MenuBar and Gtk::Toolbar which you can actually show, you should use the Builder::get_object() and Builder::get_widget() methods, and then add the widgets to a container. For instance:

    auto object = m_refBuilder->get_object("menubar");
    auto gmenu = std::dynamic_pointer_cast<Gio::Menu>(object);
    auto pMenuBar = Gtk::make_managed<Gtk::MenuBar>(gmenu);
    m_Box.add(*pMenuBar);

    Gtk::Toolbar* toolbar = nullptr;
    m_refBuilder->get_widget("toolbar", toolbar);
    m_Box.add(*toolbar);

### 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.

Par exemple :

    Glib::ustring ui_info =
      "<interface>"
      "  <menu id='menu-examplepopup'>"
      "    <section>"
      "      <item>"
      "        <attribute name='label' translatable='yes'>Edit</attribute>"
      "        <attribute name='action'>examplepopup.edit</attribute>"
      "      </item>"
      "      <item>"
      "        <attribute name='label' translatable='yes'>Process</attribute>"
      "        <attribute name='action'>examplepopup.process</attribute>"
      "      </item>"
      "      <item>"
      "        <attribute name='label' translatable='yes'>Remove</attribute>"
      "        <attribute name='action'>examplepopup.remove</attribute>"
      "      </item>"
      "    </section>"
      "  </menu>"
      "</interface>";

    m_refBuilder->add_from_string(ui_info);

    auto object = m_refBuilder->get_object("menu-examplepopup");
    auto gmenu = Glib::RefPtr<Gio::Menu>::cast_dynamic(object);
    m_pMenuPopup = new Gtk::Menu(gmenu);

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) )
      {
        if(!m_pMenuPopup->get_attach_widget())
          m_pMenuPopup->attach_to_widget(*this);

        m_pMenuPopup->popup(event->button, event->time);
        return true; //It has been handled.
      }
      else
        return false;
    }

### Gio::Resource and glib-compile-resources

Applications and libraries often contain binary or textual data that is really part of the application, rather than user data. For instance Gtk::Builder `.glade` files, splashscreen images, Gio::Menu markup xml, CSS files, icons, etc. These are often shipped as files in `$datadir/appname`, or manually included as literal strings in the code.

The Gio::Resource API and the glib-compile-resources program provide a convenient and efficient alternative to this, which has some nice properties. You maintain the files as normal files, so it's easy to edit them, but during the build the files are combined into a binary bundle that is linked into the executable. This means that loading the resource files is efficient (as they are already in memory, shared with other instances) and simple (no need to check for things like I/O errors or locate the files in the filesystem). It also makes it easier to create relocatable applications.

Resource bundles are created by the glib-compile-resources program which takes an xml file that describes the bundle, and a set of files that the xml references. These are combined into a binary resource bundle.

Gio::Resource Reference

An example:

    <?xml version="1.0" encoding="UTF-8"?>
    <gresources>
      <gresource prefix="/toolbar">
        <file preprocess="xml-stripblanks">toolbar.glade</file>
        <file>rain.png</file>
      </gresource>
    </gresources>

This will create a resource bundle with the files

- `/toolbar/toolbar.glade`

- `/toolbar/rain.png`

You can then use glib-compile-resources to compile the xml to a binary bundle that you can load with Gio::Resource::create_from_file(). However, it's more common to use the --generate-source argument to create a C source file to link directly into your application. E.g.

    $ glib-compile-resources --target=resources.c --generate-source toolbar.gresource.xml

Once a Gio::Resource has been created and registered all the data in it can be accessed globally in the process by using API calls like Gio::Resource::open_stream_from_global_resources() to stream the data or Gio::Resource::lookup_data_in_global_resources() to get a direct pointer to the data. You can also use URIs like resource:///toolbar/rain.png with Gio::File to access the resource data.

Often you don't need a Gio::Resource instance, because resource data can be loaded with methods such as Gdk::Pixbuf::create_from_resource(), Gtk::Builder::add_from_resource() and Gtk::Image::set_from_resource().

### Exemples

#### Application Menu and Main Menu example

This program contains an application menu, a menubar and a toolbar. Classes are derived from Gtk::Application and Gtk::ApplicationWindow.

App and Main Menu

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

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

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

      void on_menu_choices(const Glib::ustring& parameter);
      void on_menu_choices_other(int parameter);
      void on_menu_toggle();

      //Child widgets:
      Gtk::Box m_Box;

      Glib::RefPtr<Gtk::Builder> m_refBuilder;

      //Two sets of choices:
      Glib::RefPtr<Gio::SimpleAction> m_refChoice;
      Glib::RefPtr<Gio::SimpleAction> m_refChoiceOther;

      Glib::RefPtr<Gio::SimpleAction> m_refToggle;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `exampleapplication.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEAPPLICATION_H
    #define GTKMM_EXAMPLEAPPLICATION_H

    #include <gtkmm.h>

    class ExampleApplication : public Gtk::Application
    {
    protected:
      ExampleApplication();

    public:
      static Glib::RefPtr<ExampleApplication> create();

    protected:
      //Overrides of default signal handlers:
      void on_startup() override;
      void on_activate() override;

    private:
      void create_window();

      void on_window_hide(Gtk::Window* window);
      void on_menu_file_new_generic();
      void on_menu_file_quit();
      void on_menu_help_about();

      Glib::RefPtr<Gtk::Builder> m_refBuilder;
    };

    #endif /* GTKMM_EXAMPLEAPPLICATION_H */

File: `exampleapplication.cc` (For use with gtkmm 4)

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

    ExampleApplication::ExampleApplication()
    : Gtk::Application("org.gtkmm.example.main_menu")
    {
      Glib::set_application_name("Main Menu Example");
    }

    Glib::RefPtr<ExampleApplication> ExampleApplication::create()
    {
      return Glib::RefPtr<ExampleApplication>(new ExampleApplication());
    }

    void ExampleApplication::on_startup()
    {
      //Call the base class's implementation:
      Gtk::Application::on_startup();

      //Create actions for menus and toolbars.
      //We can use add_action() because Gtk::Application derives from Gio::ActionMap.

      //File|New sub menu:
      add_action("newstandard",
        sigc::mem_fun(*this, &ExampleApplication::on_menu_file_new_generic));

      add_action("newfoo",
        sigc::mem_fun(*this, &ExampleApplication::on_menu_file_new_generic));

      add_action("newgoo",
        sigc::mem_fun(*this, &ExampleApplication::on_menu_file_new_generic));

      //File menu:
      add_action("quit", sigc::mem_fun(*this, &ExampleApplication::on_menu_file_quit));

      //Help menu:
      add_action("about", sigc::mem_fun(*this, &ExampleApplication::on_menu_help_about));

      m_refBuilder = Gtk::Builder::create();

      //Layout the actions in a menubar and an application menu:
      Glib::ustring ui_info =
        "<interface>"
        "  <!-- menubar -->"
        "  <menu id='menu-example'>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_File</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>New _Standard</attribute>"
        "          <attribute name='action'>app.newstandard</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;n</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>New _Foo</attribute>"
        "          <attribute name='action'>app.newfoo</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>New _Goo</attribute>"
        "          <attribute name='action'>app.newgoo</attribute>"
        "        </item>"
        "      </section>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Quit</attribute>"
        "          <attribute name='action'>app.quit</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;q</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_Edit</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Copy</attribute>"
        "          <attribute name='action'>win.copy</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;c</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Paste</attribute>"
        "          <attribute name='action'>win.paste</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;v</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Something</attribute>"
        "          <attribute name='action'>win.something</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_Choices</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Choice _A</attribute>"
        "          <attribute name='action'>win.choice</attribute>"
        "          <attribute name='target'>a</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Choice _B</attribute>"
        "          <attribute name='action'>win.choice</attribute>"
        "          <attribute name='target'>b</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_Other Choices</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Choice 1</attribute>"
        "          <attribute name='action'>win.choiceother</attribute>"
        "          <attribute name='target' type='i'>1</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Choice 2</attribute>"
        "          <attribute name='action'>win.choiceother</attribute>"
        "          <attribute name='target' type='i'>2</attribute>"
        "        </item>"
        "      </section>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Some Toggle</attribute>"
        "          <attribute name='action'>win.sometoggle</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_Help</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_About</attribute>"
        "          <attribute name='action'>win.about</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "  </menu>"
        ""
        "  <!-- application menu -->"
        "  <menu id='appmenu'>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_File</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>New _Standard</attribute>"
        "          <attribute name='action'>app.newstandard</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;n</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>New _Foo</attribute>"
        "          <attribute name='action'>app.newfoo</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>New _Goo</attribute>"
        "          <attribute name='action'>app.newgoo</attribute>"
        "        </item>"
        "      </section>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Quit</attribute>"
        "          <attribute name='action'>app.quit</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;q</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_Help</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_About</attribute>"
        "          <attribute name='action'>app.about</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "  </menu>"
        "</interface>";

      try
      {
        m_refBuilder->add_from_string(ui_info);
      }
      catch (const Glib::Error& ex)
      {
        std::cerr << "Building menus failed: " << ex.what();
      }

      //Get the menubar and the app menu, and add them to the application:
      auto object = m_refBuilder->get_object("menu-example");
      auto gmenu = std::dynamic_pointer_cast<Gio::Menu>(object);
      object = m_refBuilder->get_object("appmenu");
      auto appMenu = std::dynamic_pointer_cast<Gio::Menu>(object);
      if (!(gmenu && appMenu)) {
        g_warning("GMenu or AppMenu not found");
      }
      else
      {
        set_app_menu(appMenu);
        set_menubar(gmenu);
      }
    }

    void ExampleApplication::on_activate()
    {
      //std::cout << "debug1: " << G_STRFUNC << std::endl;
      // The application has been started, so let's show a window.
      // A real application might want to reuse this window in on_open(),
      // when asked to open a file, if no changes have been made yet.
      create_window();
    }

    void ExampleApplication::create_window()
    {
      auto win = new ExampleWindow();

      //Make sure that the application runs for as long this window is still open:
      add_window(*win);

      //Delete the window when it is hidden.
      //That's enough for this simple example.
      win->signal_hide().connect(sigc::bind(
        sigc::mem_fun(*this, &ExampleApplication::on_window_hide), win));

      win->show();
    }

    void ExampleApplication::on_window_hide(Gtk::Window* window)
    {
      delete window;
    }

    void ExampleApplication::on_menu_file_new_generic()
    {
      std::cout << "A File|New menu item was selected." << std::endl;
    }

    void ExampleApplication::on_menu_file_quit()
    {
      std::cout << G_STRFUNC << std::endl;
      quit(); // Not really necessary, when Gtk::Widget::hide() is called.

      // Gio::Application::quit() will make Gio::Application::run() return,
      // but it's a crude way of ending the program. The window is not removed
      // from the application. Neither the window's nor the application's
      // destructors will be called, because there will be remaining reference
      // counts in both of them. If we want the destructors to be called, we
      // must remove the window from the application. One way of doing this
      // is to hide the window.
      std::vector<Gtk::Window*> windows = get_windows();
      if (windows.size() > 0)
        windows[0]->hide(); // In this simple case, we know there is only one window.
    }

    void ExampleApplication::on_menu_help_about()
    {
      std::cout << "App|Help|About was selected." << std::endl;
    }

File: `main.cc` (For use with gtkmm 4)

    #include "exampleapplication.h"

    int main(int argc, char* argv[])
    {
      auto application = ExampleApplication::create();

      // Start the application, showing the initial window,
      // and opening extra windows for any files that it is asked to open,
      // for instance as a command-line parameter.
      // run() will return when the last window has been closed by the user.
      const int status = application->run(argc, argv);
      return status;
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow()
    : Gtk::ApplicationWindow(),
      m_Box(Gtk::Orientation::VERTICAL)
    {
      set_title("Main menu example");
      set_default_size(300, 100);

      // ExampleApplication displays the menubar. Other stuff, such as a toolbar,
      // is put into the box.
      add(m_Box);

      // Create actions for menus and toolbars.
      // We can use add_action() because Gtk::ApplicationWindow derives from Gio::ActionMap.
      // This Action Map uses a "win." prefix for the actions.
      // Therefore, for instance, "win.copy", is used in ExampleApplication::on_startup()
      // to layout the menu.

      //Edit menu:
      add_action("copy", sigc::mem_fun(*this, &ExampleWindow::on_menu_others));
      add_action("paste", sigc::mem_fun(*this, &ExampleWindow::on_menu_others));
      add_action("something", sigc::mem_fun(*this, &ExampleWindow::on_menu_others));

      //Choices menus, to demonstrate Radio items,
      //using our convenience methods for string and int radio values:
      m_refChoice = add_action_radio_string("choice",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_choices), "a");

      m_refChoiceOther = add_action_radio_integer("choiceother",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_choices_other), 1);

      m_refToggle = add_action_bool("sometoggle",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_toggle), false);

      //Help menu:
      add_action("about", sigc::mem_fun(*this, &ExampleWindow::on_menu_others));

      //Create the toolbar and add it to a container widget:

      m_refBuilder = Gtk::Builder::create();

      Glib::ustring ui_info =
        "<!-- Generated with glade 3.18.3 and then changed manually -->"
        "<interface>"
        "  <requires lib='gtk' version='3.94'/>"
        "  <object class='GtkToolbar' id='toolbar'>"
        "    <property name='can_focus'>False</property>"
        "    <child>"
        "      <object class='GtkToolButton' id='toolbutton_new'>"
        "        <property name='can_focus'>False</property>"
        "        <property name='tooltip_text' translatable='yes'>New Standard</property>"
        "        <property name='action_name'>app.newstandard</property>"
        "        <property name='icon_name'>document-new</property>"
        "        <property name='expand'>False</property>"
        "        <property name='homogeneous'>True</property>"
        "      </object>"
        "    </child>"
        "    <child>"
        "      <object class='GtkToolButton' id='toolbutton_quit'>"
        "        <property name='can_focus'>False</property>"
        "        <property name='tooltip_text' translatable='yes'>Quit</property>"
        "        <property name='action_name'>app.quit</property>"
        "        <property name='icon_name'>application-exit</property>"
        "        <property name='expand'>False</property>"
        "        <property name='homogeneous'>True</property>"
        "      </object>"
        "    </child>"
        "  </object>"
        "</interface>";

      try
      {
        m_refBuilder->add_from_string(ui_info);
      }
      catch (const Glib::Error& ex)
      {
        std::cerr << "Building toolbar failed: " <<  ex.what();
      }

      Gtk::Toolbar* toolbar = nullptr;
      m_refBuilder->get_widget("toolbar", toolbar);
      if (!toolbar)
        g_warning("GtkToolbar not found");
      else
        m_Box.add(*toolbar);
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_menu_others()
    {
      std::cout << "A menu item was selected." << std::endl;
    }

    void ExampleWindow::on_menu_choices(const Glib::ustring& parameter)
    {
      //The radio action's state does not change automatically:
      m_refChoice->change_state(parameter);

      Glib::ustring message;
      if (parameter == "a")
        message = "Choice a was selected.";
      else
        message = "Choice b was selected.";

      std::cout << message << std::endl;
    }

    void ExampleWindow::on_menu_choices_other(int parameter)
    {
      //The radio action's state does not change automatically:
      m_refChoiceOther->change_state(parameter);

      Glib::ustring message;
      if (parameter == 1)
        message = "Choice 1 was selected.";
      else
        message = "Choice 2 was selected.";

      std::cout << message << std::endl;
    }

    void ExampleWindow::on_menu_toggle()
    {
      bool active = false;
      m_refToggle->get_state(active);

      //The toggle action's state does not change automatically:
      active = !active;
      m_refToggle->change_state(active);

      Glib::ustring message;
      if (active)
        message = "Toggle is active.";
      else
        message = "Toggle is not active.";

      std::cout << message << std::endl;
    }

#### Exemple de menu principal

This program contains a menubar and a toolbar. A class is derived from Gtk::Window.

Menu principal

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow(const Glib::RefPtr<Gtk::Application>& app);
      virtual ~ExampleWindow();

    private:
      //Signal handlers:
      void on_action_file_new();
      void on_action_file_quit();
      void on_action_others();
      void on_action_toggle();

      //Child widgets:
      Gtk::Box m_Box;

      Glib::RefPtr<Gtk::Builder> m_refBuilder;
      Glib::RefPtr<Gio::SimpleActionGroup> m_refActionGroup;
      Glib::RefPtr<Gio::SimpleAction> m_refActionRain;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window(app);

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow(const Glib::RefPtr<Gtk::Application>& app)
    : m_Box(Gtk::Orientation::VERTICAL)
    {
      set_title("main_menu example");
      set_default_size(200, 200);

      add(m_Box); //We can put a MenuBar at the top of the box and other stuff below it.

      //Define the actions:
      m_refActionGroup = Gio::SimpleActionGroup::create();

      m_refActionGroup->add_action("new",
        sigc::mem_fun(*this, &ExampleWindow::on_action_file_new) );
      m_refActionGroup->add_action("open",
        sigc::mem_fun(*this, &ExampleWindow::on_action_others) );

      m_refActionRain = m_refActionGroup->add_action_bool("rain",
        sigc::mem_fun(*this, &ExampleWindow::on_action_toggle),
        false);

      m_refActionGroup->add_action("quit",
        sigc::mem_fun(*this, &ExampleWindow::on_action_file_quit) );

      m_refActionGroup->add_action("cut",
        sigc::mem_fun(*this, &ExampleWindow::on_action_others) );
      m_refActionGroup->add_action("copy",
        sigc::mem_fun(*this, &ExampleWindow::on_action_others) );
      m_refActionGroup->add_action("paste",
        sigc::mem_fun(*this, &ExampleWindow::on_action_others) );

      insert_action_group("example", m_refActionGroup);

      //Define how the actions are presented in the menus and toolbars:
      m_refBuilder = Gtk::Builder::create();

      //Layout the actions in a menubar and toolbar:
      const char* ui_info =
        "<interface>"
        "  <menu id='menubar'>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_File</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_New</attribute>"
        "          <attribute name='action'>example.new</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;n</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Open</attribute>"
        "          <attribute name='action'>example.open</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;o</attribute>"
        "        </item>"
        "      </section>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Rain</attribute>"
        "          <attribute name='action'>example.rain</attribute>"
        "        </item>"
        "      </section>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Quit</attribute>"
        "          <attribute name='action'>example.quit</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;q</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_Edit</attribute>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>_Cut</attribute>"
        "        <attribute name='action'>example.cut</attribute>"
        "        <attribute name='accel'>&lt;Primary&gt;x</attribute>"
        "      </item>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>_Copy</attribute>"
        "        <attribute name='action'>example.copy</attribute>"
        "        <attribute name='accel'>&lt;Primary&gt;c</attribute>"
        "      </item>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>_Paste</attribute>"
        "        <attribute name='action'>example.paste</attribute>"
        "        <attribute name='accel'>&lt;Primary&gt;v</attribute>"
        "      </item>"
        "    </submenu>"
        "  </menu>"
        "</interface>";

      // When the menubar is a child of a Gtk::Window, keyboard accelerators are not
      // automatically fetched from the Gio::Menu.
      // See the examples/book/menus/main_menu example for an alternative way of
      // adding the menubar when using Gtk::ApplicationWindow.
      // Gtk::Application::set_accel_for_action() is new in gtkmm 3.11.9.
      app->set_accel_for_action("example.new", "<Primary>n");
      app->set_accel_for_action("example.open", "<Primary>o");
      app->set_accel_for_action("example.quit", "<Primary>q");
      app->set_accel_for_action("example.cut", "<Primary>x");
      app->set_accel_for_action("example.copy", "<Primary>c");
      app->set_accel_for_action("example.paste", "<Primary>v");

      try
      {
        m_refBuilder->add_from_string(ui_info);
        m_refBuilder->add_from_resource("/toolbar/toolbar.glade");
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "Building menus and toolbar failed: " <<  ex.what();
      }

      //Get the menubar:
      auto object = m_refBuilder->get_object("menubar");
      auto gmenu = std::dynamic_pointer_cast<Gio::Menu>(object);
      if (!gmenu)
        g_warning("GMenu not found");
      else
      {
        auto pMenuBar = Gtk::make_managed<Gtk::MenuBar>(gmenu);

        //Add the MenuBar to the window:
        m_Box.add(*pMenuBar);
      }

      //Get the toolbar and add it to a container widget:
      Gtk::Toolbar* toolbar = nullptr;
      m_refBuilder->get_widget("toolbar", toolbar);
      if (!toolbar)
        g_warning("GtkToolbar not found");
      else
        m_Box.add(*toolbar);
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_action_file_quit()
    {
      hide(); //Closes the main window to stop the app->run().
    }

    void ExampleWindow::on_action_file_new()
    {
       std::cout << "A File|New menu item was selected." << std::endl;
    }

    void ExampleWindow::on_action_others()
    {
      std::cout << "A menu item was selected." << std::endl;
    }

    void ExampleWindow::on_action_toggle()
    {
      std::cout << "The toggle menu item was selected." << std::endl;

      bool active = false;
      m_refActionRain->get_state(active);

      //The toggle action's state does not change automatically:
      active = !active;
      m_refActionRain->change_state(active);

      Glib::ustring message;
      if(active)
        message = "Toggle is active.";
      else
        message = "Toggle is not active";

      std::cout << message << std::endl;
    }

File: `toolbar.gresource.xml` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <gresources>
      <gresource prefix="/toolbar">
        <file preprocess="xml-stripblanks">toolbar.glade</file>
        <file>rain.png</file>
      </gresource>
    </gresources>

#### Exemple de menu contextuel

Menu contextuel

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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_label_pressed(int n_press, double x, double y);

      void on_menu_file_popup_generic();

      //Child widgets:
      Gtk::Box m_Box;
      Gtk::Label m_Label;

      Glib::RefPtr<Gtk::Builder> m_refBuilder;
      Glib::RefPtr<Gtk::GestureMultiPress> m_refGesture;

      Gtk::Menu* m_pMenuPopup;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow()
    : m_Box(Gtk::Orientation::VERTICAL),
      m_Label("Right-click to see the popup menu."),
      m_pMenuPopup(nullptr)
    {
      set_title("popup example");
      set_default_size(200, 200);

      add(m_Box);

      // Catch button_press events:
      m_Box.add(m_Label);
      m_Label.set_expand();
      m_refGesture = Gtk::GestureMultiPress::create();
      m_refGesture->set_button(GDK_BUTTON_SECONDARY);
      m_refGesture->signal_pressed().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_label_pressed));
      m_Label.add_controller(m_refGesture);

      //Create actions:

      //Fill menu:

      auto refActionGroup = Gio::SimpleActionGroup::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.

      refActionGroup->add_action("edit",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_popup_generic));

      refActionGroup->add_action("process", //TODO: How to specify "<control>P" as an accelerator.
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_popup_generic));

      refActionGroup->add_action("remove",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_popup_generic));

      insert_action_group("examplepopup", refActionGroup);

      m_refBuilder = Gtk::Builder::create();

      //Layout the actions in a menubar and toolbar:
      Glib::ustring ui_info =
        "<interface>"
        "  <menu id='menu-examplepopup'>"
        "    <section>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>Edit</attribute>"
        "        <attribute name='action'>examplepopup.edit</attribute>"
        "      </item>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>Process</attribute>"
        "        <attribute name='action'>examplepopup.process</attribute>"
        "      </item>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>Remove</attribute>"
        "        <attribute name='action'>examplepopup.remove</attribute>"
        "      </item>"
        "    </section>"
        "  </menu>"
        "</interface>";

      try
      {
        m_refBuilder->add_from_string(ui_info);
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "building menus failed: " <<  ex.what();
      }

      //Get the menu:
      auto object =
        m_refBuilder->get_object("menu-examplepopup");
      auto gmenu =
        std::dynamic_pointer_cast<Gio::Menu>(object);
      if(!gmenu)
        g_warning("GMenu not found");

      m_pMenuPopup = new Gtk::Menu(gmenu);
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_menu_file_popup_generic()
    {
       std::cout << "A popup menu item was selected." << std::endl;
    }

    void ExampleWindow::on_label_pressed(int /* n_press */, double /* x */, double /* y */)
    {
      if (m_pMenuPopup && !m_pMenuPopup->get_attach_widget())
        m_pMenuPopup->attach_to_widget(*this);

      if (m_pMenuPopup)
        m_pMenuPopup->popup_at_pointer();
    }

## 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.

So that applications can react to changes, for instance when a user moves a scrollbar, Gtk::Adjustment has a `value_changed` signal. You can then use the get_value() method to discover the new value.

### Création d'un objet Adjustment

The Gtk::Adjustment is created by its create() method which is as follows:

    Glib::RefPtr<Gtk::Adjustment> Gtk::Adjustment::create(
      double value,
      double lower,
      double upper,
      double step_increment = 1,
      double page_increment = 10,
      double page_size = 0);

The value argument is the initial value of the adjustment, usually corresponding to the topmost or leftmost position of an adjustable widget. The lower and upper arguments specify the possible range of values which the adjustment can hold. The step_increment argument specifies the smaller of the two increments by which the user can change the value, while the page_increment is the larger one. The page_size argument usually corresponds somehow to the visible area of a panning widget. The upper argument is used to represent the bottommost or rightmost coordinate in a panning widget's child.

### 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.

The group which treats the values as arbitrary numbers includes the Range widgets (Scrollbar and Scale), the ScaleButton widget, and the SpinButton widget. These widgets are typically "adjusted" directly by the user with the mouse or keyboard. They will treat the lower and upper values of an adjustment as a range within which the user can manipulate the adjustment's value. By default, they will only modify the value of an adjustment.

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 :

    // creates its own adjustments
    Gtk::TextView textview;
    // uses the newly-created adjustment for the scrollbar as well
    Gtk::Scrollbar vscrollbar (textview.get_vadjustment(), Gtk::ORIENTATION_VERTICAL);

### À 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 (MyPicture* picture)
    {
      picture->set_rotation(adj->get_value());
    ...

et la connectez à l'ajustement de l'élément graphique `Scale` ainsi :

    adj->signal_value_changed().connect(sigc::bind<MyPicture*>(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->signal_changed();

## 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.

The run() method returns an `int`. This may be a value from the `Gtk::ResponseType` if the user closed the dialog by clicking a standard button, or it could be the custom response value that you specified when using add_button().

Reference

### 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`.

Reference

#### Exemple

Boîte de dialogue Message

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::Box m_ButtonBox;
      Gtk::Button m_Button_Info, m_Button_Question;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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.add(m_Button_Info);
      m_Button_Info.set_expand(true);
      m_Button_Info.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_info_clicked) );

      m_ButtonBox.add(m_Button_Question);
      m_Button_Question.set_expand(true);
      m_Button_Question.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_question_clicked) );
    }

    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::MessageType::QUESTION,
              Gtk::ButtonsType::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::ResponseType::OK:
        {
          std::cout << "OK clicked." << std::endl;
          break;
        }
        case Gtk::ResponseType::CANCEL:
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked." << std::endl;
          break;
        }
      }
    }

### 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.

Reference

#### Exemple

Boîte de dialogue Sélection de fichier

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::Box m_ButtonBox;
      Gtk::Button m_Button_File, m_Button_Folder;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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.add(m_Button_File);
      m_Button_File.set_expand(true);
      m_Button_File.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_file_clicked) );

      m_ButtonBox.add(m_Button_Folder);
      m_Button_Folder.set_expand(true);
      m_Button_Folder.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_folder_clicked) );
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_folder_clicked()
    {
      Gtk::FileChooserDialog dialog("Please choose a folder",
              Gtk::FileChooser::Action::SELECT_FOLDER);
      dialog.set_transient_for(*this);

      //Add response buttons the the dialog:
      dialog.add_button("_Cancel", Gtk::ResponseType::CANCEL);
      dialog.add_button("Select", Gtk::ResponseType::OK);

      int result = dialog.run();

      //Handle the response:
      switch(result)
      {
        case Gtk::ResponseType::OK:
        {
          std::cout << "Select clicked." << std::endl;
          std::cout << "Folder selected: " << dialog.get_filename()
              << std::endl;
          break;
        }
        case Gtk::ResponseType::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::FileChooser::Action::OPEN);
      dialog.set_transient_for(*this);

      //Add response buttons the the dialog:
      dialog.add_button("_Cancel", Gtk::ResponseType::CANCEL);
      dialog.add_button("_Open", Gtk::ResponseType::OK);

      //Add filters, so that only certain file types can be selected:

      auto filter_text = Gtk::FileFilter::create();
      filter_text->set_name("Text files");
      filter_text->add_mime_type("text/plain");
      dialog.add_filter(filter_text);

      auto 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);

      auto 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::ResponseType::OK:
        {
          std::cout << "Open clicked." << std::endl;

          //Notice that this is a std::string, not a Glib::ustring.
          auto filename = dialog.get_filename();
          std::cout << "File selected: " <<  filename << std::endl;
          break;
        }
        case Gtk::ResponseType::CANCEL:
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked." << std::endl;
          break;
        }
      }
    }

### ColorChooserDialog

The ColorChooserDialog allows the user to choose a color. The ColorButton opens a color selection dialog when it is clicked.

Reference

#### Exemple

ColorChooserDialog

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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();

      //Draw function:
      void on_drawing_area_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height);

      //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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::Orientation::VERTICAL, 5),
      m_Button_Dialog("Choose Color")
    {
      set_title("Gtk::ColorChooserDialog example");
      set_default_size(200, 200);

      add(m_VBox);

      m_VBox.add(m_ColorButton);
      m_ColorButton.signal_color_set().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_color_button_color_set) );

      m_VBox.add(m_Button_Dialog);
      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_VBox.add(m_DrawingArea);
      m_DrawingArea.set_expand(true);
      m_DrawingArea.set_draw_func(sigc::mem_fun(*this, &ExampleWindow::on_drawing_area_draw));
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_color_button_color_set()
    {
      //Store the chosen color:
      m_Color = m_ColorButton.get_rgba();
    }

    void ExampleWindow::on_button_dialog_clicked()
    {
      Gtk::ColorChooserDialog dialog("Please choose a color");
      dialog.set_transient_for(*this);

      //Get the previously selected color:
      dialog.set_rgba(m_Color);

      const int result = dialog.run();

      //Handle the response:
      switch(result)
      {
        case Gtk::ResponseType::OK:
        {
          //Store the chosen color:
          m_Color = dialog.get_rgba();
          m_ColorButton.set_rgba(m_Color);
          break;
        }
        case Gtk::ResponseType::CANCEL:
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked: " << result << std::endl;
          break;
        }
      }
    }

    void ExampleWindow::on_drawing_area_draw(const Cairo::RefPtr<Cairo::Context>& cr, int, int)
    {
      Gdk::Cairo::set_source_rgba(cr, m_Color);
      cr->paint();
    }

### FontChooserDialog

The FontChooserDialog allows the user to choose a font. The FontButton opens a font chooser dialog when it is clicked.

Reference

#### Exemple

FontChooserDialog

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::Box m_ButtonBox;
      Gtk::FontButton m_FontButton;
      Gtk::Button m_Button_Dialog;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #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.add(m_FontButton);
      m_FontButton.set_expand(true);
      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.add(m_Button_Dialog);
      m_Button_Dialog.set_expand(true);
      m_Button_Dialog.signal_clicked().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_button_dialog_clicked) );
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_font_button_font_set()
    {
      auto font_name = m_FontButton.get_font();
      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());

      int result = dialog.run();

      //Handle the response:
      switch(result)
      {
        case Gtk::ResponseType::OK:
        {
          auto font_name = dialog.get_font();
          std::cout << "Font chosen: " << font_name << std::endl;
          m_FontButton.set_font(font_name);
          break;
        }
        case Gtk::ResponseType::CANCEL:
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked: " << result << std::endl;
          break;
        }
      }
    }

### Non-modal AboutDialog

The AboutDialog offers a simple way to display information about a program, like its logo, name, copyright, website and license.

Most dialogs in this chapter are modal, that is, they freeze the rest of the application while they are shown. It's also possible to create a non-modal dialog, which does not freeze other windows in the application. The following example shows a non-modal AboutDialog. This is perhaps not the kind of dialog you would normally make non-modal, but non-modal dialogs can be useful in other cases. E.g. gedit's search-and-replace dialog is non-modal.

Reference

#### Exemple

AboutDialog

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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();
      void on_about_dialog_response(int response_id);

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Label m_Label;
      Gtk::Box m_ButtonBox;
      Gtk::Button m_Button;
      Gtk::AboutDialog m_Dialog;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::Orientation::VERTICAL),
      m_Label("The AboutDialog is non-modal. "
        "You can select parts of this text while the AboutDialog is shown."),
      m_ButtonBox(Gtk::Orientation::VERTICAL),
      m_Button("Show AboutDialog")
    {
      set_title("Gtk::AboutDialog example");

      add(m_VBox);

      m_VBox.add(m_Label);
      m_Label.set_expand(true);
      m_Label.set_line_wrap(true);
      m_Label.set_selectable(true);

      m_VBox.add(m_ButtonBox);
      m_ButtonBox.add(m_Button);
      m_Button.set_expand(true);
      m_Button.set_halign(Gtk::Align::CENTER);
      m_Button.set_valign(Gtk::Align::CENTER);
      m_Button.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_clicked) );

      m_Dialog.set_transient_for(*this);

      m_Dialog.set_logo(Gdk::Texture::create_for_pixbuf(
        Gdk::Pixbuf::create_from_resource("/about/gtkmm_logo.gif", -1, 40, true)));
      m_Dialog.set_program_name("Example application");
      m_Dialog.set_version("1.0.0");
      m_Dialog.set_copyright("Murray Cumming");
      m_Dialog.set_comments("This is just an example application.");
      m_Dialog.set_license("LGPL");

      m_Dialog.set_website("http://www.gtkmm.org");
      m_Dialog.set_website_label("gtkmm website");

      std::vector<Glib::ustring> list_authors;
      list_authors.push_back("Murray Cumming");
      list_authors.push_back("Somebody Else");
      list_authors.push_back("AN Other");
      m_Dialog.set_authors(list_authors);

      m_Dialog.signal_response().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_about_dialog_response) );

      m_Button.grab_focus();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_about_dialog_response(int response_id)
    {
      std::cout << response_id
        << ", close=" << Gtk::ResponseType::CLOSE
        << ", cancel=" << Gtk::ResponseType::CANCEL
        << ", delete_event=" << Gtk::ResponseType::DELETE_EVENT
        << std::endl;

      switch (response_id)
      {
      case Gtk::ResponseType::CLOSE:
      case Gtk::ResponseType::CANCEL:
      case Gtk::ResponseType::DELETE_EVENT:
        m_Dialog.hide();
        break;
      default:
        std::cout << "Unexpected response!" << std::endl;
        break;
      }
    }

    void ExampleWindow::on_button_clicked()
    {
      m_Dialog.show();

      //Bring it to the front, in case it was already shown:
      m_Dialog.present();
    }

File: `aboutdialog.gresource.xml` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <gresources>
      <gresource prefix="/about">
        <file>gtkmm_logo.gif</file>
      </gresource>
    </gresources>

## The DrawingArea Widget

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 draw 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 function to determine how the contents of the widget will be drawn. This is done by setting a draw function with a call to the set_draw_func() member function.

GTK+ uses the Cairo drawing API. With gtkmm, you may use the cairomm C++ API for cairo.

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 get 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. Usually, you use the Cairo::Context that you get as input data to the draw function that you set with the call to set_draw_func(). It's also possible to create a Cairo::Context by calling the Gdk::Surface::create_cairo_context() and Gdk::CairoContext::cairo_create() functions. Since Cairo contexts are reference-counted objects, cairo_create() returns a Cairo::RefPtr<Cairo::Context> object. (Note the difference between Gdk::CairoContext and Cairo::Context.)

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;
    auto gdkCairoContext = myArea.get_surface()->create_cairo_context();
    auto myContext = gdkCairoContext->cairo_create();
    myContext->set_source_rgb(1.0, 0.0, 0.0);
    myContext->set_line_width(2.0);

Each Cairo::Context is associated with a particular Gdk::Surface, so the first line of the above example creates a Gtk::DrawingArea widget and the next two lines use its associated Gdk::Surface to create a Cairo::Context object. The final two lines change the graphics state of the context.

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.

The current state of a Cairo::Context can be saved to an internal stack of saved states and later be restored to the state it was in when you saved it. To do this, use the save() method and the restore() method. This can be useful if you need to temporarily change the line width and color (or any other graphics setting) in order to draw something and then return to the previous settings. In this situation, you could call Cairo::Context::save(), change the graphics settings, draw the lines, and then call Cairo::Context::restore() to restore the original graphics state. Multiple calls to save() and restore() can be nested; each call to restore() restores the state from the matching paired save().

It is good practice to put all modifications to the graphics state between save()/restore() function calls. For example, if you have a function that takes a Cairo::Context reference as an argument, you might implement it as follows:

    void doSomething(const Cairo::RefPtr<Cairo::Context>& context, int x)
    {
        context->save();
        // change graphics state
        // perform drawing operations
        context->restore();
    }

The draw function that you set with a call to set_draw_func() is called with 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 the draw function.

### Tracé de droites

Now that we understand the basics of the Cairo graphics library, we're almost ready to start drawing. We'll start with the simplest of drawing elements: the straight line. But first you need to know a little bit about Cairo's coordinate system. The origin of the Cairo coordinate system is located in the upper-left corner of the window with positive x values to the right and positive y values going down.

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

Source Code

File: `myarea.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

    protected:
      void on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height);
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `main.cc` (For use with gtkmm 4)

    #include "myarea.h"
    #include <gtkmm/application.h>
    #include <gtkmm/window.h>

    int main(int argc, char** argv)
    {
       auto app = Gtk::Application::create("org.gtkmm.example");

       Gtk::Window win;
       win.set_title("DrawingArea");

       MyArea area;
       win.add(area);
       area.show();

       return app->run(win, argc, argv);
    }

File: `myarea.cc` (For use with gtkmm 4)

    #include "myarea.h"
    #include <cairomm/context.h>

    MyArea::MyArea()
    {
      set_draw_func(sigc::mem_fun(*this, &MyArea::on_draw));
    }

    MyArea::~MyArea()
    {
    }

    void MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int 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();
    }

This program contains a single class, MyArea, which is a subclass of Gtk::DrawingArea and contains an on_draw() member function. This function becomes the draw function by a call to set_draw_func() in MyArea's constructor. on_draw() is then 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.

#### Drawing thin lines

If you try to draw one pixel wide lines, you may notice that the line sometimes comes up blurred and wider than it ought to be. This happens because Cairo will try to draw from the selected position, to both sides (half to each), so if you're positioned right on the intersection of the pixels, and want a one pixel wide line, Cairo will try to use half of each adjacent pixel, which isn't possible (a pixel is the smallest unit possible). This happens when the width of the line is an odd number of pixels (not just one pixel).

The trick is to position in the middle of the pixel where you want the line to be drawn, and thus guaranteeing you get the desired results. See Cairo FAQ.

Drawing Area - Thin Lines

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm/window.h>
    #include <gtkmm/grid.h>
    #include <gtkmm/checkbutton.h>
    #include "myarea.h"

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

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

    private:
      Gtk::Grid m_Container;
      MyArea m_Area_Lines;
      Gtk::CheckButton m_Button_FixLines;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `myarea.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

      void fix_lines(bool fix = true);

    protected:
      void on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height);

    private:
      double m_fix;
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char* argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_Button_FixLines("Fix lines")
    {
      set_title("Thin lines example");

      m_Container.set_orientation(Gtk::Orientation::HORIZONTAL);

      m_Container.add(m_Area_Lines);
      m_Container.add(m_Button_FixLines);

      add(m_Container);

      m_Button_FixLines.signal_toggled().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_button_toggled));

      // Synchonize the drawing in m_Area_Lines with the state of the toggle button.
      on_button_toggled();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_toggled()
    {
      m_Area_Lines.fix_lines(m_Button_FixLines.get_active());
    }

File: `myarea.cc` (For use with gtkmm 4)

    #include "myarea.h"

    MyArea::MyArea()
    : m_fix (0)
    {
      set_content_width(200);
      set_content_height(100);
      set_draw_func(sigc::mem_fun(*this, &MyArea::on_draw));
    }

    MyArea::~MyArea()
    {
    }

    void MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height)
    {
      cr->set_line_width(1.0);

      // draw one line, every two pixels
      // without the 'fix', you won't notice any space between the lines,
      // since each one will occupy two pixels (width)
      for (int i = 0; i < width; i += 2)
      {
        cr->move_to(i + m_fix, 0);
        cr->line_to(i + m_fix, height);
      }

      cr->stroke();
    }

    // Toogle between both values (0 or 0.5)
    void MyArea::fix_lines(bool fix)
    {
      // to get the width right, we have to draw in the middle of the pixel
      m_fix = fix ? 0.5 : 0.0;

      // force the redraw of the image
      queue_draw();
    }

### 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

Source Code

File: `myarea.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

    protected:
      void on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height);
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `main.cc` (For use with gtkmm 4)

    #include "myarea.h"
    #include <gtkmm/application.h>
    #include <gtkmm/window.h>

    int main(int argc, char** argv)
    {
       auto app = Gtk::Application::create("org.gtkmm.example");

       Gtk::Window win;
       win.set_title("DrawingArea");

       MyArea area;
       win.add(area);
       area.show();

       return app->run(win, argc, argv);
    }

File: `myarea.cc` (For use with gtkmm 4)

    #include "myarea.h"
    #include <cairomm/context.h>

    MyArea::MyArea()
    {
      set_draw_func(sigc::mem_fun(*this, &MyArea::on_draw));
    }

    MyArea::~MyArea()
    {
    }

    void MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int 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();
    }

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.

The call to Cairo::Context::curve_to() should be fairly self-explanatory. The first pair of coordinates define the control point for the beginning of the curve. The second set of coordinates define the control point for the end of the curve, and the last set of coordinates define the destination point. To make the concept of control points a bit easier to visualize, a line has been drawn from each control point to the end-point on the curve that it is associated with. Note that these control point lines are both translucent. This is achieved with a variant of set_source_rgb() called set_source_rgba(). This function takes a fourth argument specifying the alpha value of the color (valid values are between 0 and 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

Source Code

File: `myarea.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

    protected:
      void on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height);
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `main.cc` (For use with gtkmm 4)

    #include "myarea.h"
    #include <gtkmm/application.h>
    #include <gtkmm/window.h>

    int main(int argc, char** argv)
    {
       auto app = Gtk::Application::create("org.gtkmm.example");

       Gtk::Window win;
       win.set_title("DrawingArea");

       MyArea area;
       win.add(area);
       area.show();

       return app->run(win, argc, argv);
    }

File: `myarea.cc` (For use with gtkmm 4)

    #include "myarea.h"
    #include <cairomm/context.h>
    #include <cmath>

    MyArea::MyArea()
    {
      set_draw_func(sigc::mem_fun(*this, &MyArea::on_draw));
    }

    MyArea::~MyArea()
    {
    }

    void MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height)
    {
      const int lesser = std::min(width, height);

      // coordinates for the center of the window
      const int xc = width / 2;
      const int 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();
    }

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.

#### Exemple

Here is an example of a program that draws some text, some of it upside-down. The Printing chapter contains another example of drawing text.

Drawing Area - Text

Source Code

File: `myarea.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

    protected:
      void on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height);

    private:
      void draw_rectangle(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height);
      void draw_text(const Cairo::RefPtr<Cairo::Context>& cr, int rectangle_width, int rectangle_height);

    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `main.cc` (For use with gtkmm 4)

    #include "myarea.h"
    #include <gtkmm/application.h>
    #include <gtkmm/window.h>

    int main(int argc, char* argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      Gtk::Window window;
      window.set_title("Drawing text example");

      MyArea area;
      window.add(area);
      area.show();

      return app->run(window, argc, argv);
    }

File: `myarea.cc` (For use with gtkmm 4)

    #include "myarea.h"

    MyArea::MyArea()
    {
      set_draw_func(sigc::mem_fun(*this, &MyArea::on_draw));
    }

    MyArea::~MyArea()
    {
    }

    void MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height)
    {
      const int rectangle_width = width;
      const int rectangle_height = height / 2;

      // Draw a black rectangle
      cr->set_source_rgb(0.0, 0.0, 0.0);
      draw_rectangle(cr, rectangle_width, rectangle_height);

      // and some white text
      cr->set_source_rgb(1.0, 1.0, 1.0);
      draw_text(cr, rectangle_width, rectangle_height);

      // flip the image vertically
      // see http://www.cairographics.org/documentation/cairomm/reference/classCairo_1_1Matrix.html
      // the -1 corresponds to the yy part (the flipping part)
      // the height part is a translation (we could have just called cr->translate(0, height) instead)
      // it's height and not height / 2, since we want this to be on the second part of our drawing
      // (otherwise, it would draw over the previous part)
      Cairo::Matrix matrix(1.0, 0.0, 0.0, -1.0, 0.0, height);

      // apply the matrix
      cr->transform(matrix);

      // white rectangle
      cr->set_source_rgb(1.0, 1.0, 1.0);
      draw_rectangle(cr, rectangle_width, rectangle_height);

      // black text
      cr->set_source_rgb(0.0, 0.0, 0.0);
      draw_text(cr, rectangle_width, rectangle_height);
    }

    void MyArea::draw_rectangle(const Cairo::RefPtr<Cairo::Context>& cr,
                                int width, int height)
    {
      cr->rectangle(0, 0, width, height);
      cr->fill();
    }

    void MyArea::draw_text(const Cairo::RefPtr<Cairo::Context>& cr,
                           int rectangle_width, int rectangle_height)
    {
      // http://developer.gnome.org/pangomm/unstable/classPango_1_1FontDescription.html
      Pango::FontDescription font;

      font.set_family("Monospace");
      font.set_weight(Pango::Weight::BOLD);

      // http://developer.gnome.org/pangomm/unstable/classPango_1_1Layout.html
      auto layout = create_pango_layout("Hi there!");

      layout->set_font_description(font);

      int text_width;
      int text_height;

      //get the text dimensions (it updates the variables -- by reference)
      layout->get_pixel_size(text_width, text_height);

      // Position the text in the middle
      cr->move_to((rectangle_width-text_width)/2, (rectangle_height-text_height)/2);

      layout->show_in_cairo_context(cr);
    }

### 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.

Probably the most common way of creating Gdk::Pixbufs is to use Gdk::Pixbuf::create_from_file() or Gdk::Pixbuf::create_from_resource(), which can read an image file, such as a png file into a pixbuf ready for rendering.

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.)

    void MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height)
    {
      auto 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();
    }

#### Exemple

Here is an example of a simple program that draws an image. The program loads the image from a resource file. See the Gio::Resource and glib-compile-resources section. Use glib-compile-resources to compile the resources into a C source file that can be compiled and linked with the C++ code. E.g.

    $ glib-compile-resources --target=resources.c --generate-source image.gresource.xml

Drawing Area - Image

Source Code

File: `myarea.h` (For use with gtkmm 4)

    #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:
      void on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height);

      Glib::RefPtr<Gdk::Pixbuf> m_image;
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `main.cc` (For use with gtkmm 4)

    #include "myarea.h"
    #include <gtkmm/application.h>
    #include <gtkmm/window.h>

    int main(int argc, char** argv)
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      Gtk::Window win;
      win.set_title("DrawingArea");
      win.set_default_size(300, 200);

      MyArea area;
      win.add(area);
      area.show();

      return app->run(win, argc, argv);
    }

File: `myarea.cc` (For use with gtkmm 4)

    #include "myarea.h"
    #include <cairomm/context.h>
    #include <giomm/resource.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_resource("/image/fractal_image.png");
      }
      catch(const Gio::ResourceError& ex)
      {
        std::cerr << "ResourceError: " << 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_content_width(m_image->get_width()/2);
        set_content_height(m_image->get_height()/2);
      }

      // Set the draw function.
      set_draw_func(sigc::mem_fun(*this, &MyArea::on_draw));
    }

    MyArea::~MyArea()
    {
    }

    void MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height)
    {
      if (!m_image)
        return;

      // 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();
    }

File: `image.gresource.xml` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <gresources>
      <gresource prefix="/image">
        <file>fractal_image.png</file>
      </gresource>
    </gresources>

### 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.

Source Code

File: `clock.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLE_CLOCK_H
    #define GTKMM_EXAMPLE_CLOCK_H

    #include <gtkmm/drawingarea.h>

    class Clock : public Gtk::DrawingArea
    {
    public:
      Clock();
      virtual ~Clock();

    protected:
      void on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height);

      bool on_timeout();

      double m_radius;
      double m_line_width;
    };

    #endif // GTKMM_EXAMPLE_CLOCK_H

File: `main.cc` (For use with gtkmm 4)

    #include "clock.h"
    #include <gtkmm/application.h>
    #include <gtkmm/window.h>

    int main(int argc, char** argv)
    {
       auto app = Gtk::Application::create("org.gtkmm.example");

       Gtk::Window win;
       win.set_title("Cairomm Clock");

       Clock c;
       win.add(c);
       c.show();

       return app->run(win, argc, argv);
    }

File: `clock.cc` (For use with gtkmm 4)

    #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 );
      set_draw_func(sigc::mem_fun(*this, &Clock::on_draw));
    }

    Clock::~Clock()
    {
    }

    void Clock::on_draw(const Cairo::RefPtr<Cairo::Context>& cr, int width, int 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::Context::LineCap::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::Context::LineCap::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();
    }

    bool Clock::on_timeout()
    {
      // force our program to redraw the entire clock.
      queue_draw();
      return true;
    }

As before, almost all of the interesting stuff is done in the draw function on_draw(). Before we dig into the draw function, 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.

The function Cairo::Context::paint() is used here to set the background color of the window. This function takes no arguments and fills the current surface (or the clipped portion of the surface) with the source color currently active. After setting the background color of the window, we draw a circle for the clock outline, fill it with white, and then stroke the outline in black. Notice that both of these actions use the _preserve variant to preserve the current path, and then this same path is clipped to make sure that our next lines don't go outside the outline of the clock.

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

Things are dragged from `sources` to be dropped on `destinations`. Each source and destination has information about the data formats that it can send or receive, provided by Gdk::ContentFormats. A drop destination will only accept a dragged item if they both share a compatible format. Appropriate signals will then be emitted, telling the signal handlers which format was used.

Gdk::ContentFormats objects contain information about available GTypes and mime types (media types).

### Fonctions membres

Widgets can be identified as sources or destinations using these Gtk::Widget methods:

    void drag_source_set(const Glib::RefPtr<Gdk::ContentFormats>& targets,
          Gdk::ModifierType start_button_mask, Gdk::DragAction actions);

- `targets` is a Gdk::ContentFormats object.

- `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` is an ORed combination of values, which specify which Drag and Drop operations will be possible from this source - for instance, copy, move, or link. The user can choose between the actions by using modifier keys, such as Shift to change from `copy` to `move`, and this will be shown by a different cursor.

    void drag_dest_set(const Glib::RefPtr<Gdk::ContentFormats>& targets,
        Gtk::DestDefaults flags, Gdk::DragAction 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.

There are several methods to add source formats and destination formats. Examples:

- drag_source_add_text_targets()

- drag_source_add_image_targets()

- drag_dest_add_text_targets()

- drag_dest_add_image_targets()

### 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

The source widget will emit these signals, in this order:

- `drag_begin`: Provides a Gdk::Drag.

- `drag_data_get`: Provides a Gdk::Drag, and a Gtk::SelectionData object, in which you should put the requested data.

- `drag_end`: Provides a Gdk::Drag.

The destination widget will emit these signals, in this order:

- `drag_motion`: Provides a Gdk::Drop and coordinates. You can call the status() method of the Gdk::Drop to indicate which action will be accepted.

- `drag_drop`: Provides a Gdk::Drop and coordinates. You can call drag_get_data(), which triggers the `drag_data_get` signal in the source widget, and then the `drag_data_received` signal in the destination widget.

- `drag_data_received`: Provides a Gdk::Drop, and a Gtk::SelectionData object which contains the dropped data. You should call the finish() or failed() method of the Gdk::Drop to indicate whether the operation was successful.

#### Déplacement

During a `move`, the source widget will also emit this signal:

- `drag_data_delete`: Gives the source the opportunity to delete the original data if that's appropriate.

### Exemple

Voici un exemple très simple montrant une opération de glisser-déposer avec `copie` :

Glisser-déposer

Source Code

File: `dndwindow.h` (For use with gtkmm 4)

    #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::Drag>& drag,
              Gtk::SelectionData& selection_data);
      void on_label_drop_drag_data_received(
              const Glib::RefPtr<Gdk::Drop>& drop,
              const Gtk::SelectionData& selection_data);

      //Member widgets:
      Gtk::Box m_HBox;
      Gtk::Button m_Button_Drag;
      Gtk::Label m_Label_Drop;
    };

    #endif // GTKMM_EXAMPLE_DNDWINDOW_H

File: `main.cc` (For use with gtkmm 4)

    #include "dndwindow.h"
    #include <gtkmm/application.h>

    int main (int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      DnDWindow dndWindow;

      //Shows the window and returns when it is closed.
      return app->run(dndWindow, argc, argv);
    }

File: `dndwindow.cc` (For use with gtkmm 4)

    #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);

      //Drag site:

      //Make m_Button_Drag a DnD drag source:
      m_Button_Drag.drag_source_set(Glib::RefPtr<Gdk::ContentFormats>());
      m_Button_Drag.drag_source_add_text_targets();

      //Connect signals:
      m_Button_Drag.signal_drag_data_get().connect(sigc::mem_fun(*this,
                  &DnDWindow::on_button_drag_data_get));

      m_HBox.add(m_Button_Drag);
      m_Button_Drag.set_expand(true);

      //Drop site:

      //Make m_Label_Drop a DnD drop destination:
      // Don't do this: m_Label_Drop.drag_dest_set({}).
      // It would call the wrong overload of drag_dest_set() with the wrong
      // default values of flags and actions (wrong in this simple example).
      m_Label_Drop.drag_dest_set(Glib::RefPtr<Gdk::ContentFormats>());
      m_Label_Drop.drag_dest_add_text_targets();

      //Connect signals:
      m_Label_Drop.signal_drag_data_received().connect(sigc::mem_fun(*this,
                  &DnDWindow::on_label_drop_drag_data_received) );

      m_HBox.add(m_Label_Drop);
      m_Label_Drop.set_expand(true);
    }

    DnDWindow::~DnDWindow()
    {
    }

    void DnDWindow::on_button_drag_data_get(
            const Glib::RefPtr<Gdk::Drag>&,
            Gtk::SelectionData& selection_data)
    {
      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::Drop>& drop,
            const Gtk::SelectionData& selection_data)
    {
      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;
      }

      drop->failed();
    }

There is a more complex example in examples/others/dnd.

## Le presse-papier

Simple text copy-paste functionality is provided for free by widgets such as Gtk::Entry and Gtk::TextView, but you might need special code to deal with your own data formats. For instance, a drawing program would need special code to allow copy and paste within a view, or between documents.

You can get a clipboard instance with Gtk::Widget::get_clipboard() or Gdk::Display::get_clipboard().

Your application doesn't need to wait for clipboard operations, particularly between the time when the user chooses Copy and then later chooses Paste. Many Gdk::Clipboard methods take sigc::slots which specify callback methods. When Gdk::Clipboard is ready, it will call these methods, providing the requested data.

Reference

### Formats

Different applications contain different types of data, and they might make that data available in a variety of formats. gtkmm calls these data types `format`s.

For instance, gedit can supply and receive the `text/plain` mime type, so you can paste data into gedit from any application that supplies that format. Or two different image editing applications might supply and receive a variety of image formats. As long as one application can receive one of the formats that the other supplies then you will be able to copy data from one to the other.

Clipboard data can be in a variety of binary formats. This chapter, and the examples, assume that the data is 8-bit text. This would allow us to use an XML format for the clipboard data. However this would probably not be appropriate for binary data such as images.

The Drag and Drop API uses the same mechanism. You should probably use the same data formats for both Clipboard and Drag and Drop operations.

### Copie

When the user asks to copy some data, you should copy the data to the Clipboard. For instance,

    void ExampleWindow::on_button_copy()
    {
      get_clipboard()->set_text("example_custom_target");
    }

### 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 :

    void ExampleWindow::on_button_paste()
    {
      get_clipboard()->read_text_async(sigc::mem_fun(*this,
                  &ExampleWindow::on_clipboard_received));
    }

Voici un exemple de fonction de rappel :

    void ExampleWindow::on_clipboard_received(Glib::RefPtr<Gio::AsyncResult>& result)
    {
      auto text = get_clipboard()->read_text_finish(result);
      //Do something with the pasted data.
    }

#### Discovering the available formats

To find out what formats are currently available on the Clipboard for pasting, call the get_formats() method. Then call a Gdk::ContentFormats method to find out if a format that your application supports is available.

### Exemples

#### Simple

This example allows copy and pasting of application-specific data, using the standard text format. Although this is simple, it's not ideal because it does not identify the Clipboard data as being of a particular type.

Presse-papier - Simple

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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(Glib::RefPtr<Gio::AsyncResult>& result);

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::Label m_Label;

      Gtk::Grid m_Grid;
      Gtk::ToggleButton m_ButtonA1, m_ButtonA2, m_ButtonB1, m_ButtonB2;

      Gtk::Box m_ButtonBox;
      Gtk::Button m_Button_Copy, m_Button_Paste;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      // Gio::Application::Flags::NON_UNIQUE because it shall be possible to run
      // several instances of this application simultaneously.
      auto app = Gtk::Application::create(
        "org.gtkmm.example", Gio::Application::Flags::NON_UNIQUE);

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::Orientation::VERTICAL),
      m_Label("Select cells in the grid, click Copy, then open a second "
            "instance of this example to try pasting the copied data."),
      m_ButtonA1("A1"), m_ButtonA2("A2"), m_ButtonB1("B1"), m_ButtonB2("B2"),
      m_Button_Copy("_Copy", /* mnemonic= */ true), m_Button_Paste("_Paste", true)
    {
      set_title("Gtk::Clipboard example");

      m_VBox.set_margin(12);
      add(m_VBox);

      m_VBox.add(m_Label);

      //Fill Grid:
      m_VBox.add(m_Grid);
      m_Grid.set_expand(true);
      m_Grid.set_row_homogeneous(true);
      m_Grid.set_column_homogeneous(true);
      m_Grid.attach(m_ButtonA1, 0, 0);
      m_Grid.attach(m_ButtonA2, 1, 0);
      m_Grid.attach(m_ButtonB1, 0, 1);
      m_Grid.attach(m_ButtonB2, 1, 1);

      //Add ButtonBox to bottom:
      m_VBox.add(m_ButtonBox);
      m_VBox.set_spacing(6);

      //Fill ButtonBox:
      m_ButtonBox.add(m_Button_Copy);
      m_Button_Copy.set_hexpand(true);
      m_Button_Copy.set_halign(Gtk::Align::END);
      m_Button_Copy.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_copy) );
      m_ButtonBox.add(m_Button_Paste);
      m_Button_Paste.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_paste) );
    }

    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";

      get_clipboard()->set_text(strData);
    }

    void ExampleWindow::on_button_paste()
    {
      //Tell the clipboard to call our method when it is ready:
      get_clipboard()->read_text_async(sigc::mem_fun(*this,
                  &ExampleWindow::on_clipboard_text_received));
    }

    void ExampleWindow::on_clipboard_text_received(Glib::RefPtr<Gio::AsyncResult>& result)
    {
      Glib::ustring text;
      try
      {
        text = get_clipboard()->read_text_finish(result);
      }
      catch (const Glib::Error& err)
      {
        // Print an error about why pasting failed.
        // Usually you probably want to ignore such failures,
        // but for demonstration purposes, we show the error.
        std::cout << "Pasting failed: " << err.what() << std::endl;
      }

      //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' );
      }
    }

#### Idéal

This is like the simple example, but it

1. Defines a custom clipboard target, though the format is still text.

2. It uses the Gdk::ContentFormats::signal_changed() signal and disables the Paste button if it can't use anything on the clipboard.

Presse-papier - Idéal

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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_content_changed();

      void on_clipboard_received(Glib::RefPtr<Gio::AsyncResult>& result);
      void on_clipboard_received_targets(Glib::RefPtr<Gio::AsyncResult>& result);

      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::Grid m_Grid;
      Gtk::ToggleButton m_ButtonA1, m_ButtonA2, m_ButtonB1, m_ButtonB2;

      Gtk::Box m_ButtonBox;
      Gtk::Button m_Button_Copy, m_Button_Paste;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      // Gio::Application::Flags::NON_UNIQUE because it shall be possible to run
      // several instances of this application simultaneously.
      auto app = Gtk::Application::create(
        "org.gtkmm.example", Gio::Application::Flags::NON_UNIQUE);

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    namespace
    {

    const char example_format_custom[] = "gtkmmclipboardexample";

    } // anonymous namespace

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::Orientation::VERTICAL),
      m_Label("Select cells in the grid, 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_ButtonA1("A1"), m_ButtonA2("A2"), m_ButtonB1("B1"), m_ButtonB2("B2"),
      m_Button_Copy("_Copy", /* mnemonic= */ true), m_Button_Paste("_Paste", true)
    {
      set_title("Gtk::Clipboard example");

      m_VBox.set_margin(12);
      add(m_VBox);

      m_VBox.add(m_Label);

      //Fill Grid:
      m_VBox.add(m_Grid);
      m_Grid.set_expand(true);
      m_Grid.set_row_homogeneous(true);
      m_Grid.set_column_homogeneous(true);
      m_Grid.attach(m_ButtonA1, 0, 0);
      m_Grid.attach(m_ButtonA2, 1, 0);
      m_Grid.attach(m_ButtonB1, 0, 1);
      m_Grid.attach(m_ButtonB2, 1, 1);

      //Add ButtonBox to bottom:
      m_VBox.add(m_ButtonBox);
      m_VBox.set_spacing(6);

      //Fill ButtonBox:
      m_ButtonBox.add(m_Button_Copy);
      m_Button_Copy.set_hexpand(true);
      m_Button_Copy.set_halign(Gtk::Align::END);
      m_Button_Copy.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_copy) );
      m_ButtonBox.add(m_Button_Paste);
      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.
      get_clipboard()->property_content().signal_changed().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_clipboard_content_changed));

      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(example_format_custom);
      strData += m_ButtonA1.get_active() ? " A1" : "";
      strData += m_ButtonA2.get_active() ? " A2" : "";
      strData += m_ButtonB1.get_active() ? " B1" : "";
      strData += m_ButtonB2.get_active() ? " B2" : "";

      get_clipboard()->set_text(strData);
    }

    void ExampleWindow::on_button_paste()
    {
      //Tell the clipboard to call our method when it is ready:
      get_clipboard()->read_text_async(sigc::mem_fun(*this,
                  &ExampleWindow::on_clipboard_received));
    }

    void ExampleWindow::on_clipboard_content_changed()
    {
      update_paste_status();
    }

    void ExampleWindow::on_clipboard_received(Glib::RefPtr<Gio::AsyncResult>& result)
    {
      Glib::ustring text;
      try
      {
        text = get_clipboard()->read_text_finish(result);
      }
      catch (const Glib::Error& err)
      {
        // Print an error about why pasting failed.
        // Usually you probably want to ignore such failures,
        // but for demonstration purposes, we show the error.
        std::cout << "Pasting failed: " << err.what() << std::endl;
      }

      if (text.find(example_format_custom) == 0)
      {
        // It's the expected format.
        m_ButtonA1.set_active(text.find("A1") != std::string::npos);
        m_ButtonA2.set_active(text.find("A2") != std::string::npos);
        m_ButtonB1.set_active(text.find("B1") != std::string::npos);
        m_ButtonB2.set_active(text.find("B2") != std::string::npos);
      }
      else
      {
        // Unexpected format. Disable the Paste button.
        std::cout << "Unexpected pasted text: \"" << text << "\"" << std::endl;
        m_Button_Paste.set_sensitive(false);
      }
    }

    void ExampleWindow::update_paste_status()
    {
      // Disable the paste button if there is nothing to paste.
      get_clipboard()->read_text_async(sigc::mem_fun(*this,
                  &ExampleWindow::on_clipboard_received_targets));
    }

    void ExampleWindow::on_clipboard_received_targets(Glib::RefPtr<Gio::AsyncResult>& result)
    {
      Glib::ustring text;
      try
      {
        text = get_clipboard()->read_text_finish(result);
      }
      catch (const Glib::Error&)
      {
      }

      const bool bPasteIsPossible = text.find(example_format_custom) == 0;

      // Enable/Disable the Paste button appropriately:
      m_Button_Paste.set_sensitive(bPasteIsPossible);
    }

## Impression

At the application development level, gtkmm's printing API provides dialogs that are consistent across applications and allows use of Cairo's common drawing API, with Pango-driven text rendering. In the implementation of this common API, platform-specific backends and printer-specific drivers are used.

### 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

The PrintOperation::run() method starts the print loop, during which various signals are emitted:

- `begin_print`: You must handle this signal, because this is where you create and set up a Pango::Layout using the provided Gtk::PrintContext, and break up your printing output into pages.

- `paginate`: Pagination is potentially slow so if you need to monitor it you can call the PrintOperation::set_show_progress() method and handle this signal.

- For each page that needs to be rendered, the following signals are emitted:

  - `request_page_setup`: Provides a PrintContext, page number and Gtk::PageSetup. Handle this signal if you need to modify page setup on a per-page basis.

  - `draw_page`: You must handle this signal, which provides a PrintContext and a page number. The PrintContext should be used to create a Cairo::Context into which the provided page should be drawn. To render text, iterate over the Pango::Layout you created in the `begin_print` handler.

- `end_print`: A handler for it is a safe place to free any resources related to a PrintOperation. If you have your custom class that inherits from PrintOperation, it is naturally simpler to do it in the destructor.

- `done`: This signal is emitted when printing is finished, meaning when the print data is spooled. Note that the provided `Gtk::PrintOperationResult` may indicate that an error occurred. In any case you probably want to notify the user about the final status.

- `status_changed`: Emitted whenever a print job's status changes, until it is finished. Call the PrintOperation::set_track_print_status() method to monitor the job status after spooling. To see the status, use get_status() or get_status_string().

Reference

### 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.

For instance,

    //Within a class that inherits from Gtk::Window and keeps m_refPageSetup and m_refSettings as members...
    auto new_page_setup = Gtk::run_page_setup_dialog(*this, m_refPageSetup, m_refSettings);
    m_refPageSetup = new_page_setup;

Reference

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` :

For instance,

    // in class ExampleWindow's method...
    auto op = PrintOperation::create();
    // ...set up op...
    op->signal_done().connect(sigc::bind(sigc::mem_fun(*this, &ExampleWindow::on_printoperation_done), op));
    // run the op

Second, check for an error and connect to the `status_changed` signal. For instance:

    void ExampleWindow::on_printoperation_done(Gtk::PrintOperationResult result, const Glib::RefPtr<PrintOperation>& op)
    {
      if (result == Gtk::PRINT_OPERATION_RESULT_ERROR)
        //notify user
      else if (result == Gtk::PRINT_OPERATION_RESULT_APPLY)
        //Update PrintSettings with the ones used in this PrintOperation

      if (! op->is_finished())
        op->signal_status_changed().connect(sigc::bind(sigc::mem_fun(*this, &ExampleWindow::on_printoperation_status_changed), op));
    }

Finally, check the status. For instance,

    void ExampleWindow::on_printoperation_status_changed(const Glib::RefPtr<PrintOperation>& op)
    {
      if (op->is_finished())
        //the print job is finished
      else
        //get the status with get_status() or get_status_string()

      //update UI
    }

### Exportation au format PDF

The 'Print to file' option is available in the print dialog, without the need for extra implementation. However, it is sometimes useful to generate a pdf file directly from code. For instance,

    auto op = Gtk::PrintOperation::create();
    // ...set up op...
    op->set_export_filename("test.pdf");
    auto res = op->run(Gtk::PRINT_OPERATION_ACTION_EXPORT);

### Extension de la boîte de dialogue d'impression

You may add a custom tab to the print dialog:

- Set the title of the tab via PrintOperation::set_custom_tab_label(), create a new widget and return it from the `create_custom_widget` signal handler. You'll probably want this to be a container widget, packed with some others.

- Get the data from the widgets in the `custom_widget_apply` signal handler.

Although the `custom_widget_apply` signal provides the widget you previously created, to simplify things you can keep the widgets you expect to contain some user input as class members. For example, let's say you have a Gtk::Entry called `m_Entry` as a member of your CustomPrintOperation class:

    Gtk::Widget* CustomPrintOperation::on_create_custom_widget()
    {
      set_custom_tab_label("My custom tab");

      auto hbox = new Gtk::Box(Gtk::Orientation::HORIZONTAL, 8);
      hbox->set_margin(6);

      auto label = Gtk::make_managed<Gtk::Label>("Enter some text: ");
      hbox->add(*label);

      hbox->add(m_Entry);

      return hbox;
    }

    void CustomPrintOperation::on_custom_widget_apply(Gtk::Widget* /* widget */)
    {
      auto 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

The native GTK+ print dialog has a preview button, but you may also start a preview directly from an application:

    // in a class that inherits from Gtk::Window...
    auto op = PrintOperation::create();
    // ...set up 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

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    // This file is part of the printing/simple and printing/advanced examples

    #include <gtkmm.h>

    class PrintFormOperation;

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow(const Glib::RefPtr<Gtk::Application>& app);
      virtual ~ExampleWindow();

    protected:

      void build_main_menu(const Glib::RefPtr<Gtk::Application>& app);

      void print_or_preview(Gtk::PrintOperation::Action 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();
      void on_printoperation_done(Gtk::PrintOperation::Result result);

      //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;
      Glib::RefPtr<PrintFormOperation> m_refPrintFormOperation;

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Grid m_Grid;

      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::Builder> m_refBuilder;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `printformoperation.h` (For use with gtkmm 4)

    #ifndef GTKMM_PRINT_FORM_OPERATION_H
    #define GTKMM_PRINT_FORM_OPERATION_H

    #include <gtkmm.h>
    #include <pangomm.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:
      void on_begin_print(const Glib::RefPtr<Gtk::PrintContext>& context) override;
      void on_draw_page(const Glib::RefPtr<Gtk::PrintContext>& context, int page_nr) override;

      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: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char* argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window(app);

      // Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    const Glib::ustring app_title = "gtkmm Printing Example";

    ExampleWindow::ExampleWindow(const Glib::RefPtr<Gtk::Application>& app)
    : m_VBox(Gtk::Orientation::VERTICAL),
      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(app);

      m_VBox.add(m_Grid);

      //Arrange the widgets inside the grid:
      m_Grid.set_expand(true);
      m_Grid.set_row_spacing(5);
      m_Grid.set_column_spacing(5);
      m_Grid.attach(m_NameLabel, 0, 0);
      m_Grid.attach(m_NameEntry, 1, 0);

      m_Grid.attach(m_SurnameLabel, 0, 1);
      m_Grid.attach(m_SurnameEntry, 1, 1);

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

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);

      m_Grid.attach(m_CommentsLabel, 0, 2);
      m_Grid.attach(m_ScrolledWindow, 1, 2);
      m_ScrolledWindow.set_hexpand(true);
      m_ScrolledWindow.set_vexpand(true);

      m_refTextBuffer = Gtk::TextBuffer::create();
      m_TextView.set_buffer(m_refTextBuffer);

      m_Statusbar.set_expand(true);
      m_VBox.add(m_Statusbar);
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::build_main_menu(const Glib::RefPtr<Gtk::Application>& app)
    {
      //Create actions for menus and toolbars:
      auto refActionGroup = Gio::SimpleActionGroup::create();

      //File menu:
      refActionGroup->add_action("new",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_new));

      refActionGroup->add_action("pagesetup",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_page_setup));

      refActionGroup->add_action("printpreview",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_print_preview));

      refActionGroup->add_action("print",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_print));

      refActionGroup->add_action("quit",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_quit));

      insert_action_group("example", refActionGroup);

      // When the menubar is a child of a Gtk::Window, keyboard accelerators are not
      // automatically fetched from the Gio::Menu.
      // See the examples/book/menus/main_menu example for an alternative way of
      // adding the menubar when using Gtk::ApplicationWindow.
      app->set_accel_for_action("example.new", "<Primary>n");
      app->set_accel_for_action("example.print", "<Primary>p");
      app->set_accel_for_action("example.quit", "<Primary>q");

      m_refBuilder = Gtk::Builder::create();

      // Layout the actions in a menubar:
      Glib::ustring ui_menu_info =
        "<interface>"
        "  <menu id='menu-example'>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_File</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_New</attribute>"
        "          <attribute name='action'>example.new</attribute>"
        "        </item>"
        "      </section>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Page _Setup...</attribute>"
        "          <attribute name='action'>example.pagesetup</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Print Preview</attribute>"
        "          <attribute name='action'>example.printpreview</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Print...</attribute>"
        "          <attribute name='action'>example.print</attribute>"
        "        </item>"
        "      </section>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Quit</attribute>"
        "          <attribute name='action'>example.quit</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "  </menu>"
        "</interface>";

      try
      {
        m_refBuilder->add_from_string(ui_menu_info);
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "building menus failed: " << ex.what();
      }

      // Layout the actions in a toolbar:
      Glib::ustring ui_toolbar_info =
        "<!-- Generated with glade 3.18.3 and then changed manually -->"
        "<interface>"
          "<requires lib='gtk' version='3.94'/>"
          "<object class='GtkToolbar' id='toolbar'>"
            "<property name='can_focus'>False</property>"
            "<child>"
              "<object class='GtkToolButton' id='toolbutton_new'>"
                "<property name='can_focus'>False</property>"
                "<property name='tooltip_text' translatable='yes'>New</property>"
                "<property name='action_name'>example.new</property>"
                "<property name='icon_name'>document-new</property>"
                "<property name='expand'>False</property>"
                "<property name='homogeneous'>True</property>"
              "</object>"
            "</child>"
            "<child>"
              "<object class='GtkToolButton' id='toolbutton_print'>"
                "<property name='can_focus'>False</property>"
                "<property name='tooltip_text' translatable='yes'>Print</property>"
                "<property name='action_name'>example.print</property>"
                "<property name='icon_name'>document-print</property>"
                "<property name='expand'>False</property>"
                "<property name='homogeneous'>True</property>"
              "</object>"
            "</child>"
            "<child>"
              "<object class='GtkSeparatorToolItem' id='separator1'>"
                "<property name='can_focus'>False</property>"
                "<property name='expand'>False</property>"
                "<property name='homogeneous'>False</property>"
              "</object>"
            "</child>"
            "<child>"
              "<object class='GtkToolButton' id='toolbutton_quit'>"
                "<property name='can_focus'>False</property>"
                "<property name='tooltip_text' translatable='yes'>Quit</property>"
                "<property name='action_name'>example.quit</property>"
                "<property name='icon_name'>application-exit</property>"
                "<property name='expand'>False</property>"
                "<property name='homogeneous'>True</property>"
              "</object>"
            "</child>"
          "</object>"
        "</interface>";

      try
      {
        m_refBuilder->add_from_string(ui_toolbar_info);
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "building toolbar failed: " << ex.what();
      }

      // Get the menubar and add it to a container widget:
      auto object = m_refBuilder->get_object("menu-example");
      auto gmenu = std::dynamic_pointer_cast<Gio::Menu>(object);
      if (!gmenu)
        g_warning("GMenu not found");
      else
      {
        auto pMenuBar = Gtk::make_managed<Gtk::MenuBar>(gmenu);

        // Add the MenuBar to the window:
        m_VBox.add(*pMenuBar);
      }

      // Get the toolbar and add it to a container widget:
      Gtk::Toolbar* toolbar = nullptr;
      m_refBuilder->get_widget("toolbar", toolbar);
      if (!toolbar)
        g_warning("GtkToolbar not found");
      else
        m_VBox.add(*toolbar);
    }

    void ExampleWindow::on_printoperation_status_changed()
    {
      Glib::ustring status_msg;

      if (m_refPrintFormOperation->is_finished())
      {
        status_msg = "Print job completed.";
      }
      else
      {
        //You could also use get_status().
        status_msg = m_refPrintFormOperation->get_status_string();
      }

      m_Statusbar.push(status_msg, m_ContextId);
    }

    void ExampleWindow::on_printoperation_done(Gtk::PrintOperation::Result result)
    {
      //Printing is "done" when the print data is spooled.

      if (result == Gtk::PrintOperation::Result::ERROR)
      {
        Gtk::MessageDialog err_dialog(*this, "Error printing form", false,
                Gtk::MessageType::ERROR, Gtk::ButtonsType::OK, true);
        err_dialog.run();
      }
      else if (result == Gtk::PrintOperation::Result::APPLY)
      {
        //Update PrintSettings with the ones used in this PrintOperation:
        m_refSettings = m_refPrintFormOperation->get_print_settings();
      }

      if (!m_refPrintFormOperation->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.
        m_refPrintFormOperation->signal_status_changed().connect(sigc::mem_fun(*this,
                        &ExampleWindow::on_printoperation_status_changed));
      }
    }

    void ExampleWindow::print_or_preview(Gtk::PrintOperation::Action print_action)
    {
      //Create a new PrintOperation with our PageSetup and PrintSettings:
      //(We use our derived PrintOperation class)
      m_refPrintFormOperation = PrintFormOperation::create();

      m_refPrintFormOperation->set_name(m_NameEntry.get_text() + " " + m_SurnameEntry.get_text());
      m_refPrintFormOperation->set_comments(m_refTextBuffer->get_text(false /*Don't include hidden*/));
      // In the printing/advanced example, the font will be set through a custom tab
      // in the print dialog.

      m_refPrintFormOperation->set_track_print_status();
      m_refPrintFormOperation->set_default_page_setup(m_refPageSetup);
      m_refPrintFormOperation->set_print_settings(m_refSettings);

      m_refPrintFormOperation->signal_done().connect(sigc::mem_fun(*this,
                      &ExampleWindow::on_printoperation_done));
      try
      {
        m_refPrintFormOperation->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:
      auto 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::PrintOperation::Action::PREVIEW);
    }

    void ExampleWindow::on_menu_file_print()
    {
      print_or_preview(Gtk::PrintOperation::Action::PRINT_DIALOG);
    }

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

File: `printformoperation.cc` (For use with gtkmm 4)

    #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:
      auto iter = m_refLayout->get_iter();

      double start_pos = 0;
      int line_index = 0;

      do
      {
        if(line_index >= start_page_line)
        {
          auto layout_line = iter.get_line();
          auto 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());
    }

## Documents récents

gtkmm provides an easy way to manage recently used documents. This functionality is implemented in the Gtk::RecentManager class.

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().

#### 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 :

    auto 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:

    auto 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.

### Boîte de dialogue Sélection de fichier

FileChooser is an interface that can be implemented by widgets displaying a list of files. gtkmm provides four built-in implementations for choosing recent files or other files: FileChooserWidget, FileChooserDialog, FileChooserButton, and FileChooserNative.

FileChooserWidget is a simple widget for displaying a list of recently used files or other files. FileChooserWidget is the basic building block for FileChooserDialog, but you can embed it into your user interface if you want to.

#### Simple FileChooserDialog example

Shown below is a simple example of how to use the FileChooserDialog class in a program. This simple program has a menubar with a File Chooser Dialog menu item. When you select this menu item, a dialog pops up showing a list of files. If you select Recent in the sidebar, the list of recently used files is shown.

À 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.

After selecting the File Chooser Dialog menu item and the Recent sidebar item, you should see something similar to the following window.

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow(const Glib::RefPtr<Gtk::Application>& app);
      ~ExampleWindow() override;

    protected:
      //Signal handlers:
      void on_menu_file_files_dialog();
      void on_menu_file_quit();
      void on_menu_file_new();

      //Child widgets:
      Gtk::Box m_Box;

      Glib::RefPtr<Gtk::Builder> m_refBuilder;
      Glib::RefPtr<Gio::SimpleActionGroup> m_refActionGroup;

      Glib::RefPtr<Gtk::RecentManager> m_refRecentManager;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window(app);

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow(const Glib::RefPtr<Gtk::Application>& app)
    : m_Box(Gtk::Orientation::VERTICAL),
      m_refRecentManager(Gtk::RecentManager::get_default())
    {
      set_title("Recent files example");
      set_default_size(300, 150);

      //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 = Gio::SimpleActionGroup::create();

      //File menu:
      m_refActionGroup->add_action("new",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_new));

      //A menu item to open the file chooser dialog:
      m_refActionGroup->add_action("files-dialog",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_files_dialog));

      m_refActionGroup->add_action("quit",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_quit) );

      insert_action_group("example", m_refActionGroup);

      m_refBuilder = Gtk::Builder::create();

      // When the menubar is a child of a Gtk::Window, keyboard accelerators are not
      // automatically fetched from the Gio::Menu.
      // See the examples/book/menus/main_menu example for an alternative way of
      // adding the menubar when using Gtk::ApplicationWindow.
      app->set_accel_for_action("example.new", "<Primary>n");
      app->set_accel_for_action("example.files-dialog", "<Primary>o");
      app->set_accel_for_action("example.quit", "<Primary>q");

      //Layout the actions in a menubar and a toolbar:
      const char* ui_info =
        "<interface>"
        "  <menu id='menubar'>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_File</attribute>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>_New</attribute>"
        "        <attribute name='action'>example.new</attribute>"
        "        <attribute name='accel'>&lt;Primary&gt;n</attribute>"
        "      </item>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>File Chooser _Dialog</attribute>"
        "        <attribute name='action'>example.files-dialog</attribute>"
        "        <attribute name='accel'>&lt;Primary&gt;o</attribute>"
        "      </item>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>_Quit</attribute>"
        "        <attribute name='action'>example.quit</attribute>"
        "        <attribute name='accel'>&lt;Primary&gt;q</attribute>"
        "      </item>"
        "    </submenu>"
        "  </menu>"
        "  <object class='GtkToolbar' id='toolbar'>"
        "    <property name='can_focus'>False</property>"
        "    <child>"
        "      <object class='GtkToolButton' id='toolbutton_new'>"
        "        <property name='can_focus'>False</property>"
        "        <property name='tooltip_text' translatable='yes'>New</property>"
        "        <property name='action_name'>example.new</property>"
        "        <property name='icon_name'>document-new</property>"
        "        <property name='expand'>False</property>"
        "        <property name='homogeneous'>True</property>"
        "      </object>"
        "    </child>"
        "    <child>"
        "      <object class='GtkToolButton' id='toolbutton_quit'>"
        "        <property name='can_focus'>False</property>"
        "        <property name='tooltip_text' translatable='yes'>Quit</property>"
        "        <property name='action_name'>example.quit</property>"
        "        <property name='icon_name'>application-exit</property>"
        "        <property name='expand'>False</property>"
        "        <property name='homogeneous'>True</property>"
        "      </object>"
        "    </child>"
        "  </object>"
        "</interface>";

      try
      {
        m_refBuilder->add_from_string(ui_info);
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "building menubar and toolbar failed: " <<  ex.what();
      }

      //Get the menubar and toolbar widgets, and add them to a container widget:
      auto object = m_refBuilder->get_object("menubar");
      auto gmenu = std::dynamic_pointer_cast<Gio::Menu>(object);
      if (gmenu)
      {
        //Menubar:
        auto pMenubar = Gtk::make_managed<Gtk::MenuBar>(gmenu);
        m_Box.add(*pMenubar);
      }
      else
        g_warning("GMenu not found");

      Gtk::Toolbar* pToolbar = nullptr;
      m_refBuilder->get_widget("toolbar", pToolbar);
      if (pToolbar)
        //Toolbar:
        m_Box.add(*pToolbar);
      else
        g_warning("GtkToolbar not found");
    }

    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 app->run().
    }

    void ExampleWindow::on_menu_file_files_dialog()
    {
      Gtk::FileChooserDialog dialog(*this, "Files", Gtk::FileChooser::Action::OPEN,
        /* use_header_bar= */ true);
      dialog.add_button("Select File", Gtk::ResponseType::OK);
      dialog.add_button("_Cancel", Gtk::ResponseType::CANCEL);

      const int response = dialog.run();
      dialog.hide();
      if (response == Gtk::ResponseType::OK)
      {
        auto selected_uri = dialog.get_uri();
        std::cout << "URI selected = " << selected_uri << std::endl;
        std::cout << (m_refRecentManager->has_item(selected_uri) ? "A" : "Not a")
          << " recently used file" << std::endl;
      }
    }

The constructor for ExampleWindow creates the menu and the toolbar using Builder (see for more information). It then adds the menu and the toolbar to the window.

#### Filtering Files

For any of the FileChooser classes, if you don't wish to display all of the items in the list of files, you can filter the list to show only those that you want. You can filter the list with the help of the FileFilter class. This class allows you to filter files by their name (add_pattern()), or their mime type (add_mime_type()).

After you've created and set up the filter to match only the items you want, you can apply a filter to a chooser widget with the FileChooser::add_filter() function.

## 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.

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`.

Here's a simple example:

    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) );

#### 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. The default event signal handler is overridden, as described in the Overriding default signal handlers section in the appendix.

Keyboard Events - Simple

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:

      ExampleWindow();
      virtual ~ExampleWindow();

    private:
      // Signal handler:
      bool on_window_key_pressed(guint keyval, guint keycode, Gdk::ModifierType state);

      Gtk::Grid m_container;
      Gtk::RadioButton m_first;
      Gtk::RadioButton m_second;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    {
      set_title("Keyboard Events");
      m_container.set_margin(10);
      add(m_container);

      // Radio buttons:
      m_first.set_label("First");
      m_second.set_label("Second");

      m_second.join_group(m_first);
      m_first.set_active();

      // Main Container:
      m_container.add(m_first);
      m_container.add(m_second);

      // Events.
      auto controller = Gtk::EventControllerKey::create();
      controller->signal_key_pressed().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_window_key_pressed), false);
      add_controller(controller);
    }

    bool ExampleWindow::on_window_key_pressed(guint keyval, guint, Gdk::ModifierType state)
    {
      //Gdk::ModifierType::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((keyval == GDK_KEY_1) &&
        (state & (Gdk::ModifierType::SHIFT_MASK | Gdk::ModifierType::CONTROL_MASK | Gdk::ModifierType::MOD1_MASK)) == Gdk::ModifierType::MOD1_MASK)
      {
        m_first.set_active();
        //returning true, cancels the propagation of the event
        return true;
      }
      else if((keyval == GDK_KEY_2) &&
        (state & (Gdk::ModifierType::SHIFT_MASK | Gdk::ModifierType::CONTROL_MASK | Gdk::ModifierType::MOD1_MASK)) == Gdk::ModifierType::MOD1_MASK)
      {
        //and the second radio button, when we press alt + 2
        m_second.set_active();
        return true;
      }
      else if(keyval == GDK_KEY_Escape)
      {
        //close the window, when the 'esc' key is pressed
        hide();
        return true;
      }

      //the event has not been handled
      return false;
    }

    ExampleWindow::~ExampleWindow()
    {
    }

### 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.

Contrary to other events, keyboard events are first sent to the toplevel window (Gtk::Window), where it will be checked for any keyboard shortcuts that may be set (accelerator keys and mnemonics, used for selecting menu items from the keyboard). After this (and assuming the event wasn't handled), it is sent to the widget which has focus, and the propagation begins from there.

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 that are called after Gtk::Window's default event handler, one in the Gtk::Entry, one in the Gtk::Grid and one in the Gtk::Window.

In the Gtk::Window, we have also the default handler overridden (on_key_release_event()), and another handler being called before the default handler (windowKeyReleaseBefore()).

The purpose of this example is to show the steps the event takes when it is emitted.

When you write in the entry, a key release event will be emitted, which will go first to the toplevel window (Gtk::Window), since we have one event handler set to be called before, that's what is called first (windowKeyReleaseBefore()). Then the default handler is called (which we have overridden), and after that the event is sent to the widget that has focus, the Entry in our example 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

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EVENT_PROPAGATION_H
    #define GTKMM_EVENT_PROPAGATION_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:

      ExampleWindow();
      virtual ~ExampleWindow();

    private:
      // Signal handlers:
      bool label2_key_pressed(guint keyval, guint keycode, Gdk::ModifierType state, const Glib::ustring& phase);
      bool grid_key_pressed(guint keyval, guint keycode, Gdk::ModifierType state, const Glib::ustring& phase);
      bool window_key_pressed(guint keyval, guint keycode, Gdk::ModifierType state, const Glib::ustring& phase);

      bool m_first = true;
      Gtk::Grid m_container;
      Gtk::Frame m_frame;
      Gtk::Label m_label1;
      Gtk::Label m_label2;
      Gtk::CheckButton m_checkbutton_can_propagate_down;
      Gtk::CheckButton m_checkbutton_can_propagate_up;
    };

    #endif //GTKMM_EVENT_PROPAGATION_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow()
    :
    m_label1("A label"),
    m_label2("Write here"),
    m_checkbutton_can_propagate_down("Can propagate down"),
    m_checkbutton_can_propagate_up("Can propagate up")
    {
      set_title("Event Propagation");
      m_container.set_margin(10);
      add(m_container);

      m_frame.add(m_label2);
      m_label2.set_selectable();
      m_checkbutton_can_propagate_down.set_active();
      m_checkbutton_can_propagate_up.set_active();

      // Main container
      m_container.set_orientation(Gtk::Orientation::VERTICAL);
      m_container.add(m_label1);
      m_container.add(m_frame);
      m_container.add(m_checkbutton_can_propagate_down);
      m_container.add(m_checkbutton_can_propagate_up);

      // Events
      const bool after = false; // Run before or after the default signal handlers.

      // Called in the capture phase of the event handling.
      auto controller = Gtk::EventControllerKey::create();
      controller->set_propagation_phase(Gtk::PropagationPhase::CAPTURE);
      controller->signal_key_pressed().connect(
        sigc::bind(sigc::mem_fun(*this, &ExampleWindow::label2_key_pressed), "capture"), after);
      m_label2.add_controller(controller);

      controller = Gtk::EventControllerKey::create();
      controller->set_propagation_phase(Gtk::PropagationPhase::CAPTURE);
      controller->signal_key_pressed().connect(
        sigc::bind(sigc::mem_fun(*this, &ExampleWindow::grid_key_pressed), "capture"), after);
      m_container.add_controller(controller);

      controller = Gtk::EventControllerKey::create();
      controller->set_propagation_phase(Gtk::PropagationPhase::CAPTURE);
      controller->signal_key_pressed().connect(
        sigc::bind(sigc::mem_fun(*this, &ExampleWindow::window_key_pressed), "capture"), after);
      add_controller(controller);

      // Called in the target phase of the event handling.
      controller = Gtk::EventControllerKey::create();
      controller->set_propagation_phase(Gtk::PropagationPhase::TARGET);
      controller->signal_key_pressed().connect(
        sigc::bind(sigc::mem_fun(*this, &ExampleWindow::label2_key_pressed), "target"), after);
      m_label2.add_controller(controller);

      controller = Gtk::EventControllerKey::create();
      controller->set_propagation_phase(Gtk::PropagationPhase::TARGET);
      controller->signal_key_pressed().connect(
        sigc::bind(sigc::mem_fun(*this, &ExampleWindow::grid_key_pressed), "target"), after);
      m_container.add_controller(controller);

      controller = Gtk::EventControllerKey::create();
      controller->set_propagation_phase(Gtk::PropagationPhase::TARGET);
      controller->signal_key_pressed().connect(
        sigc::bind(sigc::mem_fun(*this, &ExampleWindow::window_key_pressed), "target"), after);
      add_controller(controller);

      // Called in the bubble phase of the event handling.
      // This is the default, if set_propagation_phase() is not called.
      controller = Gtk::EventControllerKey::create();
      controller->set_propagation_phase(Gtk::PropagationPhase::BUBBLE);
      controller->signal_key_pressed().connect(
        sigc::bind(sigc::mem_fun(*this, &ExampleWindow::label2_key_pressed), "bubble"), after);
      m_label2.add_controller(controller);

      controller = Gtk::EventControllerKey::create();
      controller->set_propagation_phase(Gtk::PropagationPhase::BUBBLE);
      controller->signal_key_pressed().connect(
        sigc::bind(sigc::mem_fun(*this, &ExampleWindow::grid_key_pressed), "bubble"), after);
      m_container.add_controller(controller);

      controller = Gtk::EventControllerKey::create();
      controller->set_propagation_phase(Gtk::PropagationPhase::BUBBLE);
      controller->signal_key_pressed().connect(
        sigc::bind(sigc::mem_fun(*this, &ExampleWindow::window_key_pressed), "bubble"), after);
      add_controller(controller);
    }

    // By changing the return value we allow, or don't allow, the event to propagate to other elements.
    bool ExampleWindow::label2_key_pressed(guint keyval, guint, Gdk::ModifierType, const Glib::ustring& phase)
    {
      std::cout << "Label,  " << phase << " phase" << std::endl;

      if (phase == "bubble")
      {
        const gunichar unichar = gdk_keyval_to_unicode(keyval);
        if (unichar != 0)
        {
          if (m_first)
          {
            m_label2.set_label("");
            m_first = false;
          }
          if (unichar == '\b')
            m_label2.set_label("");
          else
          {
            const Glib::ustring newchar(1, unichar);
            m_label2.set_label(m_label2.get_label() + newchar);
          }
        }

        if (!m_checkbutton_can_propagate_up.get_active())
          return true; // Don't propagate
      }
      return false;
    }

    bool ExampleWindow::grid_key_pressed(guint, guint, Gdk::ModifierType, const Glib::ustring& phase)
    {
      std::cout << "Grid,   " << phase << " phase" << std::endl;

      // Let it propagate
      return false;
    }

    // This will set the second label's text in the first label every time a key is pressed.
    bool ExampleWindow::window_key_pressed(guint, guint, Gdk::ModifierType, const Glib::ustring& phase)
    {
      if (phase == "capture")
        std::cout << std::endl;
      std::cout << "Window, " << phase << " phase";

      // Checking if the second label is on focus, otherwise the label would get
      // changed by pressing keys on the window (when the label is not on focus),
      // even if m_checkbutton_can_propagate_up wasn't active.
      if (phase == "bubble" && m_label2.has_focus())
      {
        m_label1.set_text(m_label2.get_text());
        std::cout << ", " << m_label2.get_text();
      }
      std::cout << std::endl;

      if (phase == "capture" && !m_checkbutton_can_propagate_down.get_active())
        return true; // Don't propagate
      return false;
    }

    ExampleWindow::~ExampleWindow()
    {
    }

## Fonctions à délai échu, d'entrées/sorties et de temporisation

### Fonctions à délai échu

You may be wondering how to make gtkmm do useful work while it's idling along. Happily, you have several options. Using the following methods you can create a timeout method that will be called every few milliseconds.

    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();

Another way of destroying the connection is your signal handler. It has to be of the type sigc::slot<bool()>. As you see from the definition your signal handler has to return a value of the type `bool`. A definition of a sample method might look like this:

    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 :

Source Code

File: `timerexample.h` (For use with gtkmm 4)

    #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: `main.cc` (For use with gtkmm 4)

    #include "timerexample.h"
    #include <gtkmm/application.h>

    int main (int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      TimerExample example;
      return app->run(example, argc, argv);
    }

File: `timerexample.cc` (For use with gtkmm 4)

    #include "timerexample.h"

    TimerExample::TimerExample() :
      m_Box(Gtk::Orientation::HORIZONTAL, 10),
      m_ButtonAddTimer("_Add", true),
      m_ButtonDeleteTimer("_Remove", true),
      m_ButtonQuit("_Quit", true),
      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
    {
      m_Box.set_margin(10);
      add(m_Box);
      m_Box.add(m_ButtonAddTimer);
      m_Box.add(m_ButtonDeleteTimer);
      m_Box.add(m_ButtonQuit);
      for (auto child : m_Box.get_children())
        child->set_expand();

      // 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));
    }

    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()
      auto 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;
    }

### 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::SignalIO::connect(const sigc::slot<bool(Glib::IOCondition)>& slot,
                                     Glib::PollFD::fd_t fd, Glib::IOCondition condition,
                                     int priority = Glib::PRIORITY_DEFAULT);

The first argument is a slot you wish to have called when the specified event (see argument 3) occurs on the file descriptor you specify using argument two. Argument three may be one or more (using `|`) of:

- 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);

where condition is as specified above. As usual the slot is created with `sigc::mem_fun()` (for a member method of an object), or `sigc::ptr_fun()` (for a function).

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`.

Source Code

File: `main.cc` (For use with gtkmm 4)

    #include <build/config.h>
    #include <gtkmm/application.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>

    Glib::RefPtr<Gtk::Application> app;

    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::IOCondition::IO_IN) != Glib::IOCondition::IO_IN) {
        std::cerr << "Invalid fifo response" << std::endl;
      }
      else {
       Glib::ustring buf;

       iochannel->read_line(buf);
       std::cout << buf;
       if (buf == "Q\n")
         app->quit();

      }
      return true;
    }

    int main(int argc, char *argv[])
    {
      app = Gtk::Application::create("org.gtkmm.example");

      if (access("testfifo", F_OK) == -1) {
        // fifo doesn't exist - 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
      }

      // Although we will only read from the fifo, we open it in read/write mode.
      // Due to a peculiarity with the poll() system call, used deep down in glib,
      // this small program will use all available CPU time, if the fifo is opened
      // as O_RDONLY. See a discussion on the gtkmm-list, e.g.
      // https://mail.gnome.org/archives/gtkmm-list/2015-September/msg00034.html
      // and the link from there to stackoverflow.
      read_fd = open("testfifo", O_RDWR);
      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::IOCondition::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->hold(); // keep the application running without a window
      app->run(argc, argv);

      // 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 :

Source Code

File: `idleexample.h` (For use with gtkmm 4)

    #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 4)

    #include "idleexample.h"

    IdleExample::IdleExample() :
      m_Box(Gtk::Orientation::VERTICAL, 5),
      m_ButtonQuit("_Quit", true)
    {
      m_Box.set_margin(5);

      // Put buttons into container

      // Adding a few widgets:
      add(m_Box);
      m_Box.add(*Gtk::make_managed<Gtk::Label>("Formatting Windows drive C:"));
      m_Box.add(*Gtk::make_managed<Gtk::Label>("100 MB"));
      m_Box.add(m_ProgressBar_c);
      m_ProgressBar_c.set_expand();

      m_Box.add(*Gtk::make_managed<Gtk::Label>(""));

      m_Box.add(*Gtk::make_managed<Gtk::Label>("Formatting Windows drive D:"));
      m_Box.add(*Gtk::make_managed<Gtk::Label>("5000 MB"));
      m_Box.add(m_ProgressBar_d);
      m_ProgressBar_d.set_expand();

      auto hbox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL,10);
      m_Box.add(*hbox);
      hbox->add(m_ButtonQuit);
      m_ButtonQuit.set_expand();
      m_ButtonQuit.set_halign(Gtk::Align::END);
      m_ButtonQuit.set_valign(Gtk::Align::END);

      // 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) );
    }

    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 4)

    #include "idleexample.h"
    #include <gtkmm/application.h>

    int main (int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      IdleExample example;
      return app->run(example, argc, argv);
    }

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.

The primary disadvantage of using class scope widgets is revealing the class implementation rather than the class interface in the class header.

    #include <gtkmm/button.h>
    #include <gtkmm/window.h>
    class Foo : public Gtk::Window
    {
    private:
      Gtk::Button theButton;
      // will be destroyed when the Foo object is destroyed
    };

##### Éléments graphiques à portée de fonction

If a programmer does not need a class scope widget, a function scope widget may also be used. The advantages to function scope over class scope are the increased data hiding and reduced dependencies.

    {
      Gtk::Button aButton;
      aButton.show();
      ...
      app->run();
    }

##### Allocation dynamique avec new et delete

Usually, the programmer will prefer to allow containers to automatically destroy their children by creating them using `Gtk::make_managed()` (see below). This is not strictly required, as the `new` and `delete` operators may also be used, but modern C++ style discourages those in favour of safer models of memory management, so it is better to create widgets using `Gtk::make_managed()` and let their parent destroy them, than to manually perform dynamic allocation.

    auto pButton = new Gtk::Button("Test");

    // do something useful with pButton

    delete pButton;

Here, the programmer deletes `pButton` to prevent a memory leak.

#### Éléments graphiques gérés

Alternatively, you can let a widget's container control when the widget is destroyed. In most cases, you want a widget to last only as long as the container it is in. To delegate the management of a widget's lifetime to its container, create it with `Gtk::make_managed()` and then pack it into its container with Gtk::Container::add() or a similar method. Now the widget will be destroyed whenever its container is destroyed.

##### Dynamic allocation with make_managed() and add()

gtkmm provides ways including the `make_managed()` function and Gtk::Container::add() method to simplify creation and destruction of widgets whose lifetime can be managed by a parent.

Every widget except a top-level window must be added to a parent container in order to be displayed. The `manage()` function marks a widget so that when that widget is added to a parent container, said container becomes responsible for deleting the widget, meaning the user no longer needs to do so. The original way to create widgets whose lifetime is managed by their parent in this way was to call `manage()`, passing in the result of a `new` expression that created a dynamically allocated widget.

However, usually, when you create such a widget, you will already know that its parent container should be responsible for destroying it, In addition, modern C++ style discourages use of the `new` operator, which was required when passing a newly created widget to `manage()`. Therefore, gtkmm has added `make_managed()`, which combines creation and marking with `manage()` into a single step. This avoids you having to write `new`, which is discouraged in modern C++ style, and more clearly expresses intent to create a managed widget.

    MyContainer::MyContainer()
    {
      auto pButton = Gtk::make_managed<Gtk::Button>("Test");
      add(*pButton); //add *pButton to MyContainer
    }

Now, when objects of type MyContainer are destroyed, the button will also be deleted. It is no longer necessary to delete `pButton` to free the button's memory; its deletion has been delegated to the MyContainer object.

Note that if you never added the widget to any parent container, or you did but later Gtk::Container::remove()d it from said parent, gtkmm restores the widget’s lifetime management to whatever state it had before `manage()` was called, which typically means that the responsibility for `delete`ing the widget returns to the user.

Of course, a top-level container will not be added to another container. The programmer is responsible for destroying the top-level container using one of the traditional C++ techniques. For instance, your top-level Window might just be an instance in your `main()` function.

### 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,

    auto 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:

    auto 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`.

If you copy a RefPtr, for instance

    auto pixbuf2 = pixbuf;

, or if you pass it as a method argument or a return type, then RefPtr will do any necessary referencing to ensure that the instance will not be destroyed until the last RefPtr has gone out of scope.

Consultez cette annexe pour une information détaillée concernant les RefPtr.

If you wish to learn more about smartpointers, you might look in these books:

- Bjarne Stroustrup, "The C++ Programming Language" Forth Edition - section 34.3

- Nicolai M. Josuttis, "The C++ Standard Library" - section 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é.

This has the following advantages:

1. Less C++ code is required.

2. UI changes can be seen more quickly, so UIs are able to improve.

3. Designers without programming skills can create and edit UIs.

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 must be used via a Glib::RefPtr. Like all such classes, you need to use a create() method to instantiate it. For instance,

    auto builder = Gtk::Builder::create_from_file("basic.glade");

This will instantiate the windows defined in the .glade file, though they will not be shown immediately unless you have specified that via the Properties window in Glade.

To instantiate just one window, or just one of the child widgets, you can specify the name of a widget as the second parameter. For instance,

    auto builder = Gtk::Builder::create_from_file("basic.glade", "treeview_products");

### Accès aux éléments graphiques

To access a widget, for instance to show() a dialog, use the get_widget() method, providing the widget's name. This name should be specified in the Glade Properties window. If the widget could not be found, or is of the wrong type, then the pointer will be set to nullptr.

    Gtk::Dialog* pDialog = nullptr;
    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.

Source Code

File: `main.cc` (For use with gtkmm 4)

    #include <gtkmm.h>
    #include <iostream>

    Gtk::Dialog* pDialog = nullptr;

    static
    void on_button_clicked()
    {
      if(pDialog)
        pDialog->hide(); //hide() will cause main::run() to end.
    }

    int main (int argc, char **argv)
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      //Load the GtkBuilder file and instantiate its widgets:
      auto 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 = nullptr;
        refBuilder->get_widget("quit_button", pButton);
        if(pButton)
        {
          pButton->signal_clicked().connect( sigc::ptr_fun(on_button_clicked) );
        }

        app->run(*pDialog, argc, argv);
      }

      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.

Use Gtk::Builder::get_widget_derived() like so:

    DerivedDialog* pDialog = nullptr;
    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`).

You must call the base class's constructor in the initialization list, providing the C pointer. For instance,

    DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& builder)
    : Gtk::Dialog(cobject)
    {
    }

You could then encapsulate the manipulation of the child widgets in the constructor of the derived class, maybe using get_widget() or get_widget_derived() again. For instance,

    DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& builder)
    : Gtk::Dialog(cobject),
      m_builder(builder),
      m_pButton(nullptr)
    {
      //Get the Glade-instantiated Button, and connect a signal handler:
      m_builder->get_widget("quit_button", m_pButton);
      if(m_pButton)
      {
        m_pButton->signal_clicked().connect( sigc::mem_fun(*this, &DerivedDialog::on_button_quit) );
      }
    }

It's possible to pass additional arguments from get_widget_derived() to the constructor of the derived widget. For instance, this call to get_widget_derived()

    DerivedDialog* pDialog = nullptr;
    builder->get_widget_derived("DialogBasic", pDialog, true);

can invoke this constructor

    DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& builder, bool warning)
    : Gtk::Dialog(cobject),
      m_builder(builder),
      m_pButton(nullptr)
    {
      // ....
    }

#### 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.

Source Code

File: `deriveddialog.h` (For use with gtkmm 4)

    #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);
      DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& refGlade,
        bool is_glad);
      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 4)

    #include "deriveddialog.h"
    #include <iostream>
    #include <cstring>

    int main (int argc, char **argv)
    {
      bool show_icon = false;
      bool is_glad = true;
      int argc1 = argc;
      if (argc > 1)
      {
        if (std::strcmp(argv[1], "--glad") == 0)
        {
          show_icon = true;
          is_glad = true;
          argc1 = 1; // Don't give the command line arguments to Gtk::Application.
        }
        else if (std::strcmp(argv[1], "--sad") == 0)
        {
          show_icon = true;
          is_glad = false;
          argc1 = 1; // Don't give the command line arguments to Gtk::Application.
        }
      }

      auto app = Gtk::Application::create("org.gtkmm.example");

      //Load the Glade file and instantiate its widgets:
      auto 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 = nullptr;
      if (show_icon)
        // This call to get_widget_derived() requires gtkmm 3.19.7 or higher.
        Gtk::Builder::get_widget_derived(refBuilder, "DialogDerived", pDialog, is_glad);
      else
        Gtk::Builder::get_widget_derived(refBuilder, "DialogDerived", pDialog);
      if(pDialog)
      {
        //Start:
        app->run(*pDialog, argc1, argv);
      }

      delete pDialog;

      return 0;
    }

File: `deriveddialog.cc` (For use with gtkmm 4)

    #include "deriveddialog.h"

    DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& refGlade)
    : Gtk::Dialog(cobject),
      m_refGlade(refGlade),
      m_pButton(nullptr)
    {
      //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) );
      }
    }

    // The first two parameters are mandatory in a constructor that will be called
    // from Gtk::Builder::get_widget_derived().
    // Additional parameters, if any, correspond to additional arguments in the call
    // to Gtk::Builder::get_widget_derived().
    DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& refGlade,
      bool is_glad)
    : DerivedDialog(cobject, refGlade) // Delegate to the other constructor
    {
      // Show an icon.
      auto pImage = Gtk::make_managed<Gtk::Image>();
      pImage->set_from_icon_name(is_glad ? "face-smile" : "face-sad");
      pImage->set_icon_size(Gtk::IconSize::LARGE);
      pImage->set_expand();
      get_content_area()->add(*pImage);
    }

    DerivedDialog::~DerivedDialog()
    {
    }

    void DerivedDialog::on_button_quit()
    {
      hide(); //hide() will cause Gtk::Application::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.

String literals should be typed in the source code in English, but surrounded by a macro. The gettext (or intltool) utility can then extract the marked strings for translation, and substitute the translated text at runtime.

### Préparation du projet

In the instructions below we will assume that you will not be using gettext directly, but intltool, which was written specifically for `GNOME`. intltool uses `gettext()`, which extracts strings from source code, but intltool can also combine strings from other files, for example from desktop menu details, and GUI resource files such as Glade files, into standard gettext `.pot/.po` files.

We also assume that you are using autotools (e.g. automake and autoconf) to build your project, and that you are using `./autogen.sh` from gnome-common or a similar `autogen.sh` file, which, among other things, takes care of some intltool initialization.

An alternative to gnome-common's `autogen.sh` may look like this:

    #! /bin/sh -e
    test -n "$srcdir" || srcdir=`dirname "$0"`
    test -n "$srcdir" || srcdir=.

    autoreconf --force --install --verbose --warnings=all "$srcdir"
    echo "Running intltoolize --copy --force --automake"
    intltoolize --copy --force --automake
    test -n "$NOCONFIGURE" || "$srcdir/configure" "$@"

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=programname
    AC_SUBST(GETTEXT_PACKAGE)
    AC_DEFINE_UNQUOTED([GETTEXT_PACKAGE], ["$GETTEXT_PACKAGE"],
                       [The domain to use with gettext])
    AM_GNU_GETTEXT([external])
    AM_GNU_GETTEXT_VERSION([0.17])

    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.

`AM_GLIB_GNU_GETTEXT` has been an alternative to `AM_GNU_GETTEXT` and `AM_GNU_GETTEXT_VERSION`, but `AM_GLIB_GNU_GETTEXT` is now deprecated, and shall not be used in new code.

In the top-level Makefile.am:

- Add `po` to the `SUBDIRS` variable. Without this, your translations won't get built and installed when you build the program

- Define `INTLTOOL_FILES` as:

      INTLTOOL_FILES = intltool-extract.in \
                       intltool-merge.in \
                       intltool-update.in

- Add `INTLTOOL_FILES` to the `EXTRA_DIST` list of files. This ensures that when you do a `make dist`, these files will be included in the source tarball.

- Update your `DISTCLEANFILES`:

      DISTCLEANFILES = ... intltool-extract \
                       intltool-merge \
                       intltool-update \
                       po/.intltool-merge-cache

- Depending on the types of files that contain translatable strings, add code such as

      desktopdir = $(datadir)/applications
      desktop_in_files = programname.desktop.in
      desktop_DATA = $(desktop_in_files:.desktop.in=.desktop)
      @INTLTOOL_DESKTOP_RULE@

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.

However, Glib defines `gettext()` support macros which are shorter wrappers in an easy-to-use form. To use these macros, include `<glibmm/i18n.h>`, and then, for example, substitute:

    display_message("Getting ready for i18n.");

with:

    display_message(_("Getting ready for i18n."));

For reference, it is possible to generate a file which contains all strings which appear in your code, even if they are not marked for translation, together with file name and line number references. To generate such a file named `my-strings`, execute the following command, within the source code directory:

    xgettext -a -o my-strings --omit-header *.cc *.h

Finally, to let your program use the translation for the current locale, add this code to the beginning of your `main.cc` file, to initialize gettext.

    bindtextdomain(GETTEXT_PACKAGE, PROGRAMNAME_LOCALEDIR);
    bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
    textdomain(GETTEXT_PACKAGE);

#### Comment fonctionne gettext

The intltool-update or xgettext script extracts the strings and puts them in a `mypackage.pot` file. The translators of your application create their translations by first copying this `.pot` file to a `localename.po` file. A locale identifies a language and an encoding for that language, including date and numerical formats. Later, when the text in your source code has changed, the msgmerge or intltool-update script is used to update the `localename.po` files from the regenerated `.pot` file.

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

To convince yourself that you've done well, you may wish to add a translation for a new locale. In order to do that, go to the `po` subdirectory of your project and execute the following command:

    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

More information about what lies behind the internationalization and localization process is presented and demonstrated in:

- L10N Guidelines for Developers

- Intltool README

- How to use Git for GNOME translators

- gettext manual

- `gtkmm_hello` example package

- `gnomemm_hello` example package

### 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

Unfortunately, the integration with the standard iostreams is not completely foolproof. gtkmm converts Glib::ustrings to a locale-specific encoding (which usually is not UTF-8) if you output them to an ostream with `operator<<`. Likewise, retrieving Glib::ustrings from istream with `operator>>` causes a conversion in the opposite direction. But this scheme breaks down if you go through a std::string, e.g. by inputting text from a stream to a std::string and then implicitly converting it to a Glib::ustring. If the string contained non-ASCII characters and the current locale is not UTF-8 encoded, the result is a corrupted Glib::ustring. You can work around this with a manual conversion. For instance, to retrieve the std::string from a ostringstream:

    std::locale::global(std::locale("")); // Set the global locale to the user's preferred locale.
                                          // Usually unnecessary here, because Glib::init()
                                          // or Gtk::Application::create() does it for you.
    std::ostringstream output;
    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

Sometimes two English strings are identical but have different meanings in different contexts, so they would probably not be identical when translated. Since the English strings are used as look-up keys, this causes problems.

In these cases, you should add extra characters to the strings. For instance, use `"jumps[noun]"` and `"jumps[verb]"` instead of just `"jumps"` and strip them again outside the `gettext` call. If you add extra characters you should also add a comment for the translators before the `gettext` call. Such comments will be shown in the `.po` files. For instance:

    // 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]");

If you use Glib's support macros, it's easier. Use `C_()` instead of `_()`. For instance:

    GLib::ustring text(C_("noun", "jumps"));

#### 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?"));

So you should either avoid this situation or use `Glib::ustring::compose()` which supports syntax such as:

    std::cout << Glib::ustring::compose(
                 _("Current amount: %1 Future: %2"), amount, future) << std::endl;

    label.set_text(Glib::ustring::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 (©).

To work around this, you could write a comment in the source code just before the string, telling the translators to use the special character if it is available in their languages. For English, you could then make an American English `en_US.po` translation which used that special character.

### Obtenir de l'aide avec les traductions

If your program is free software, there is a whole `GNOME` subproject devoted to helping you make translations, the `GNOME` Translation Project.

The way it works is that you upload your source code to a git repository where translators can access it, then contact the gnome-i18n mailing list and ask to have your program added to the list of modules to translate.

Then you make sure you update the file `POTFILES.in` in the `po/` subdirectory (`intltool-update -m` can help with this) so that the translators always access updated `myprogram.pot` files, and simply freeze the strings at least a couple of days before you make a new release, announcing it on gnome-i18n. Depending on the number of strings your program contains and how popular it is, the translations will then start to tick in as `languagename.po` files.

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

When deriving from Gtk::Container, you should override the following virtual methods:

- get_request_mode_vfunc(): Return what `Gtk::SizeRequestMode` is preferred by the container.

- measure_vfunc(): Calculate the minimum and natural width or height of the container.

- on_size_allocate(): Position the child widgets, given the height and width that the container has actually been given.

- forall_vfunc(): Call the same callback for each of the children.

- on_add(): Add a child widget to the container.

- on_remove(): Remove a child widget from the container.

- child_type_vfunc(): Return what type of child can be added.

The get_request_mode_vfunc(), measure_vfunc(), and on_size_allocate() virtual methods control the layout of the child widgets. For instance, if your container has 2 child widgets, with one below the other, your get_request_mode_vfunc() might request height-for-width layout. Then your measure_vfunc() might report the maximum of the widths of the child widgets when asked to report width, and it might report the sum of their heights when asked to report height. If you want padding between the child widgets then you would add that to the width and height too. Your widget's container will use this result to ensure that your widget gets enough space, and not less. By examining each widget's parent, and its parent, this logic will eventually decide the size of the top-level window.

You are not guaranteed to get the `Gtk::SizeRequestMode` that you request. Therefore measure_vfunc() must return sensible values for all reasonable values of its input parameters. For a description of measure_vfunc()'s parameters see also the description of Gtk::Widget::measure(), which may be better documented than measure_vfunc().

on_size_allocate() receives the actual height and width that the parent container has decided to give to your widget. This might be more than the minimum, or even more than the natural size, for instance if the top-level window has been expanded. You might choose to ignore the extra space and leave a blank area, or you might choose to expand your child widgets to fill the space, or you might choose to expand the padding between your widgets. It's your container, so you decide.

Unless your container is a top-level window that derives from Gtk::Window, you should probably also call Gtk::Widget::set_has_surface(false) in your constructor. This means that your container does not create its own Gdk::Surface, but uses its parent's surface. If your container does need its own Gdk::Surface, and does not derive from Gtk::Window, you must also override the on_realize() method as described in the Custom Widgets section.

GTK+ requires that set_has_surface() is called in the instance init function, which is executed before your constructor. If you call it in the constructor, GTK+ may issue a warning message, but at the time of writing (2018-05-07) it works as intended. Adding code to the instance init function is more complicated for a gtkmm programmer. The custom widget example shows how it can be done.

By overriding forall_vfunc() you can allow applications to operate on all of the container's child widgets. For instance, get_children() uses this to find all the child widgets.

Although your container might have its own method to set the child widgets, you should still provide an implementation for the virtual on_add() and on_remove() methods from the base class, so that the add() and remove() methods will do something appropriate if they are called.

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

This example implements a container with two child widgets, one above the other. Of course, in this case it would be far simpler just to use a vertical Gtk::Box or Gtk::Grid.

Conteneur personnalisé

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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;
      Gtk::Button m_Button_One;
      Gtk::Label m_Label_Two;
      // A restriction with MyContainer is that it must be deleted before
      // its children, meaning that it must be declared after its children.
      MyContainer m_MyContainer;
      Gtk::Box m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `mycontainer.h` (For use with gtkmm 4)

    #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:
      Gtk::SizeRequestMode get_request_mode_vfunc() const override;
      void measure_vfunc(Gtk::Orientation orientation, int for_size, int& minimum, int& natural,
        int& minimum_baseline, int& natural_baseline) const override;
      void on_size_allocate(int width, int height, int baseline) override;

      void forall_vfunc(const ForeachSlot& slot) override;

      void on_add(Gtk::Widget* child) override;
      void on_remove(Gtk::Widget* child) override;
      GType child_type_vfunc() const override;

      Gtk::Widget* m_child_one;
      Gtk::Widget* m_child_two;
    };

    #endif //GTKMM_CUSTOM_CONTAINER_MYCONTAINER_H

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::Orientation::VERTICAL),
      m_Button_One("Child One"),
      m_Label_Two("Child 2", Gtk::Align::END, Gtk::Align::CENTER),
      m_Button_Quit("Quit")
    {
      set_title("Custom Container example");
      set_default_size(400, 200);

      m_VBox.set_margin(6);
      add(m_VBox);

      //Add the child widgets to the custom container:
      m_MyContainer.set_child_widgets(m_Button_One, m_Label_Two);
      m_MyContainer.set_expand();

      m_VBox.add(m_MyContainer);
      m_VBox.add(m_ButtonBox);

      m_ButtonBox.add(m_Button_Quit);
      m_ButtonBox.set_margin(6);
      m_Button_Quit.set_hexpand(true);
      m_Button_Quit.set_halign(Gtk::Align::END);
      m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );
    }

    ExampleWindow::~ExampleWindow()
    {
    }

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

File: `mycontainer.cc` (For use with gtkmm 4)

    #include <iostream>
    #include <algorithm> // std::max
    #include "mycontainer.h"

    MyContainer::MyContainer()
    : m_child_one(nullptr), m_child_two(nullptr)
    {
      set_has_surface(false);
    }

    MyContainer::~MyContainer()
    {
      if (m_child_one)
        m_child_one->unparent();

      if (m_child_two)
        m_child_two->unparent();
    }

    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 vertical Box with at most two children.
    Gtk::SizeRequestMode MyContainer::get_request_mode_vfunc() const
    {
      return Gtk::SizeRequestMode::HEIGHT_FOR_WIDTH;
    }

    // Discover the total amount of minimum space and natural space needed by
    // this container and its children.
    void MyContainer::measure_vfunc(Gtk::Orientation orientation, int for_size,
      int& minimum, int& natural, int& minimum_baseline, int& natural_baseline) const
    {
      // Don't use baseline alignment.
      minimum_baseline = -1;
      natural_baseline = -1;

      int dummy_minimum_baseline = 0;
      int dummy_natural_baseline = 0;

      if (orientation == Gtk::Orientation::HORIZONTAL)
      {
        int height_per_child = for_size;

        if (for_size >= 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;

          // Divide the height equally among the visible children.
          if (nvis_children > 0)
            height_per_child = for_size / nvis_children;
        }

        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->measure(orientation, height_per_child, child_minimum_width[0],
            child_natural_width[0], dummy_minimum_baseline, dummy_natural_baseline);

        if (m_child_two && m_child_two->get_visible())
          m_child_two->measure(orientation, height_per_child, child_minimum_width[1],
            child_natural_width[1], dummy_minimum_baseline, dummy_natural_baseline);

        // Request a width equal to the width of the widest visible child.
        minimum = std::max(child_minimum_width[0], child_minimum_width[1]);
        natural = std::max(child_natural_width[0], child_natural_width[1]);
      }
      else // Gtk::Orientation::VERTICAL
      {
        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->measure(orientation, for_size, child_minimum_height[0],
            child_natural_height[0], dummy_minimum_baseline, dummy_natural_baseline);
        }

        if (m_child_two && m_child_two->get_visible())
        {
          ++nvis_children;
          m_child_two->measure(orientation, for_size, child_minimum_height[1],
            child_natural_height[1], dummy_minimum_baseline, dummy_natural_baseline);
        }

        // 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 = nvis_children * std::max(child_minimum_height[0],
                                           child_minimum_height[1]);
        natural = nvis_children * std::max(child_natural_height[0],
                                           child_natural_height[1]);
      }
    }

    void MyContainer::on_size_allocate(int width, int height, int  baseline)
    {
      //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.)

      //Get number of visible children.
      const bool visible_one = m_child_one && m_child_one->get_visible();
      const bool visible_two = m_child_two && m_child_two->get_visible();
      int nvis_children = 0;
      if (visible_one)
        ++nvis_children;
      if (visible_two)
        ++nvis_children;

      if (nvis_children <= 0)
      {
        // No visible child.
        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(0);
      child_allocation_one.set_y(0);

      //Make it take up the full width available:
      child_allocation_one.set_width(width);

      if (visible_one)
      {
        //Divide the height equally among the visible children.
        child_allocation_one.set_height(height / nvis_children);
        m_child_one->size_allocate(child_allocation_one, baseline);
      }
      else
        child_allocation_one.set_height(0);

      //Place the second child below the first child:
      child_allocation_two.set_x(0);
      child_allocation_two.set_y(child_allocation_one.get_height());

      //Make it take up the full width available:
      child_allocation_two.set_width(width);

      //Make it take up the remaining height:
      child_allocation_two.set_height(height - child_allocation_one.get_height());

      if (visible_two)
      {
        m_child_two->size_allocate(child_allocation_two, baseline);
      }
    }

    void MyContainer::forall_vfunc(const ForeachSlot& slot)
    {
      if (m_child_one)
        slot(*m_child_one);

      if (m_child_two)
        slot(*m_child_two);
    }

    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 = nullptr;
          found = true;
        }
        else if(child == m_child_two)
        {
          m_child_two = nullptr;
          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.

When deriving from Gtk::Widget, you should override the following virtual methods. The methods marked (optional) need not be overridden in all custom widgets. The base class's methods may be appropriate.

- get_request_mode_vfunc(): (optional) Return what `Gtk::SizeRequestMode` is preferred by the widget.

- measure_vfunc(): Calculate the minimum and natural width or height of the widget.

- on_size_allocate(): Position the widget, given the height and width that it has actually been given.

- on_realize(): Associate a Gdk::Surface with the widget.

- on_unrealize(): (optional) Break the association with the Gdk::Surface.

- on_map(): (optional)

- on_unmap(): (optional)

- snapshot_vfunc(): Create a render node, e.g. a Cairo::Context node, and draw on it.

The first 3 methods in the previous table are also overridden in custom containers. They are briefly described in the Custom Containers section.

Most custom widgets need their own Gdk::Surface to draw on. Then you can call Gtk::Widget::set_has_surface(true) in your constructor, or (better) call `gtk_widget_set_has_surface(widget, true)` in the instance init function. If you do not call set_has_surface(false), you must override on_realize() and call Gtk::Widget::set_surface() and the base class's on_realize() from there.

#### Class Init and Instance Init Functions

Some GTK+ functions, if called at all, must be called from the class init function. Some other GTK+ functions, if called, must be called from the instance init function. If your custom widget must call any of those functions, you can derive a class from Glib::ExtraClassInit and derive your custom class from that class. The following example shows how that's done.

#### Custom Style Information

Your widget class, whether it's derived directly from Gtk::Widget or from another widget class, can read some style information from a CSS (Cascading Style Sheets) file. The users of your widget, or the users of an application program with your widget, can then modify the style of your widget without modifying the source code. Useful classes are Gtk::StyleContext and Gtk::CssProvider. With the methods of Gtk::StyleContext you can read the values of your widget's style information. CSS files are described in the documentation of GTK+. The following example shows a simple use of Gtk::StyleContext::get_padding().

#### Exemple

This example implements a widget which draws Penrose triangles.

Élément graphique personnalisé

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #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::Grid m_Grid;
      MyWidget m_MyWidgetS1;
      MyWidget m_MyWidgetS2;
      Gtk::Box m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `mywidget.h` (For use with gtkmm 4)

    #ifndef GTKMM_CUSTOM_WIDGET_MYWIDGET_H
    #define GTKMM_CUSTOM_WIDGET_MYWIDGET_H

    #include <gtkmm/widget.h>
    #include <gtkmm/cssprovider.h>
    #include "myextrainit.h"

    class MyWidget
    :
    public MyExtraInit,
    public Gtk::Widget
    {
    public:
      MyWidget();
      virtual ~MyWidget();

    protected:

      //Overrides:
      Gtk::SizeRequestMode get_request_mode_vfunc() const override;
      void measure_vfunc(Gtk::Orientation orientation, int for_size, int& minimum, int& natural,
        int& minimum_baseline, int& natural_baseline) const override;
      void on_size_allocate(int width, int height, int baseline) override;
      void on_map() override;
      void on_unmap() override;
      void on_realize() override;
      void on_unrealize() override;
      void snapshot_vfunc(const Glib::RefPtr<Gtk::Snapshot>& snapshot) override;

      //Signal handler:
      void on_parsing_error(const Glib::RefPtr<const Gtk::CssSection>& section, const Glib::Error& error);

      Gtk::Border m_padding;
      Glib::RefPtr<Gdk::Surface> m_refGdkSurface;
      Glib::RefPtr<Gtk::CssProvider> m_refCssProvider;
    };

    #endif //GTKMM_CUSTOM_WIDGET_MYWIDGET_H

File: `myextrainit.h` (For use with gtkmm 4)

    #ifndef GTKMM_CUSTOM_WIDGET_MYEXTRAINIT_H
    #define GTKMM_CUSTOM_WIDGET_MYEXTRAINIT_H

    #include <glibmm/extraclassinit.h>
    #include <glibmm/ustring.h>

    // Calls gtk_widget_class_set_css_name() in the class init function
    // and gtk_set_has_window() in the instance init function.
    class MyExtraInit : public Glib::ExtraClassInit
    {
    public:
      MyExtraInit(const Glib::ustring& css_name);

    private:
      Glib::ustring m_css_name;
    };

    #endif //GTKMM_CUSTOM_WIDGET_MYEXTRAINIT_H

File: `mywidget.cc` (For use with gtkmm 4)

    #include "mywidget.h"
    #include <gdkmm/general.h>  // for cairo helper functions
    #include <gtkmm/container.h>
    #include <gtkmm/snapshot.h>
    #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"),
      MyExtraInit("my-widget"), // CSS node name, which must be used in the CSS file.
      Gtk::Widget(),
      m_padding()
    {
      // Expand, if there is extra space.
      set_hexpand(true);
      set_vexpand(true);

      //This shows the GType name.
      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;

      // The CSS name can be set either
      // - for a GType (in this case for your custom class) with gtk_widget_class_set_css_name(), or
      // - for a widget instance with gtk_widget_set_name() (Gtk::Widget::set_name()).
      //
      // gtk_widget_class_set_css_name(), if used, must be called in the class init function.
      // It has not been wrapped in a C++ function.
      // Gtk::Widget::set_name() can be called in a C++ constructor.
      //
      // Another alternative: The custom widget inherits the CSS name "widget" from
      // GtkWidget. That name can be used in the CSS file. This is not a very good
      // alternative. GtkWidget's CSS name is not documented. It can probably be
      // changed or removed in the future.

      m_refCssProvider = Gtk::CssProvider::create();
      auto refStyleContext = get_style_context();
      refStyleContext->add_provider(m_refCssProvider,
        GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
      m_refCssProvider->signal_parsing_error().connect(
        sigc::mem_fun(*this, &MyWidget::on_parsing_error));

      m_refCssProvider->load_from_path("custom_gtk.css");
    }

    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::measure_vfunc(Gtk::Orientation orientation, int /* for_size */,
      int& minimum, int& natural, int& minimum_baseline, int& natural_baseline) const
    {
      if (orientation == Gtk::Orientation::HORIZONTAL)
      {
        minimum = 60;
        natural = 100;
      }
      else
      {
        minimum = 50;
        natural = 70;
      }

      // Don't use baseline alignment.
      minimum_baseline = -1;
      natural_baseline = -1;
    }

    void MyWidget::on_size_allocate(int width, int height, int /* baseline */)
    {
      //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)

      if(m_refGdkSurface)
      {
        m_refGdkSurface->move_resize(0, 0, width, 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()
    {
      //Get the themed padding from the CSS file:
      m_padding = get_style_context()->get_padding();
      std::cout << "m_padding from the theme/css-file is"
        << ": top=" << m_padding.get_top()
        << ", right=" << m_padding.get_right()
        << ", bottom=" << m_padding.get_bottom()
        << ", left=" << m_padding.get_left() << std::endl;

      if(!m_refGdkSurface)
      {
        //Create the GdkSurface:
        m_refGdkSurface = Gdk::Surface::create_child(get_parent()->get_surface(), get_allocation());
        set_surface(m_refGdkSurface);

        // Make the widget receive expose events
        register_surface(m_refGdkSurface);
      }

      //Call base class:
      Gtk::Widget::on_realize();
    }

    void MyWidget::on_unrealize()
    {
      m_refGdkSurface.reset();

      //Call base class:
      Gtk::Widget::on_unrealize();
    }

    void MyWidget::snapshot_vfunc(const Glib::RefPtr<Gtk::Snapshot>& snapshot)
    {
      const auto allocation = get_allocation();
      const Gdk::Rectangle rect(0, 0, allocation.get_width(), allocation.get_height());
      auto refStyleContext = get_style_context();

      // Create a cairo context to draw on.
      auto cr = snapshot->append_cairo(rect);

      // paint the background
      refStyleContext->render_background(cr,
        -m_padding.get_left(), -m_padding.get_top(), allocation.get_width(), allocation.get_height());

      // draw the foreground
      const double scale_x = 0.001 * (allocation.get_width() - m_padding.get_left() - m_padding.get_right());
      const double scale_y = 0.001 * (allocation.get_height() - m_padding.get_top() - m_padding.get_bottom());
      Gdk::Cairo::set_source_rgba(cr, refStyleContext->get_color());
      cr->rectangle(0.0, 0.0, 1000.0*scale_x, 1000.0*scale_y);
      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();
    }

    void MyWidget::on_parsing_error(const Glib::RefPtr<const Gtk::CssSection>& section, const Glib::Error& error)
    {
      std::cerr << "on_parsing_error(): " << error.what() << std::endl;
      if (section)
      {
        const auto file = section->get_file();
        if (file)
        {
          std::cerr << "  URI = " << file->get_uri() << std::endl;
        }

        auto start_location = section->get_start_location();
        auto end_location = section->get_end_location();
        std::cerr << "  start_line = " << start_location.get_lines()+1
                  << ", end_line = " << end_location.get_lines()+1 << std::endl;
        std::cerr << "  start_position = " << start_location.get_line_chars()
                  << ", end_position = " << end_location.get_line_chars() << std::endl;
      }
    }

File: `main.cc` (For use with gtkmm 4)

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

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `myextrainit.cc` (For use with gtkmm 4)

    #include "myextrainit.h"
    #include <gtkmm/widget.h>
    #include <gtk/gtk.h>

    namespace
    {
    using BaseObjectType = GtkWidget;
    using BaseClassType = GtkWidgetClass;

    // Extra class init function.
    void class_init_function(void* g_class, void* class_data)
    {
      g_return_if_fail(GTK_IS_WIDGET_CLASS(g_class));

      const auto klass = static_cast<BaseClassType*>(g_class);
      const auto css_name = static_cast<Glib::ustring*>(class_data);

      gtk_widget_class_set_css_name(klass, css_name->c_str());
    }

    // Extra instance init function.
    void instance_init_function(GTypeInstance* instance, void* /* g_class */)
    {
      g_return_if_fail(GTK_IS_WIDGET(instance));

      gtk_widget_set_has_surface(GTK_WIDGET(instance), true);
    }

    } // anonymous namespace

    MyExtraInit::MyExtraInit(const Glib::ustring& css_name)
    :
    Glib::ExtraClassInit(class_init_function, &m_css_name, instance_init_function),
    m_css_name(css_name)
    {
    }

File: `examplewindow.cc` (For use with gtkmm 4)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_Button_Quit("Quit")
    {
      set_title("Custom Widget example");
      set_default_size(600, 400);

      m_Grid.set_margin(6);
      m_Grid.set_row_spacing(10);
      m_Grid.set_column_spacing(10);

      add(m_Grid);

      m_Grid.attach(m_MyWidgetS1, 0, 0);
      m_Grid.attach(m_MyWidgetS2, 1, 1);

      m_Grid.attach(m_ButtonBox, 0, 2, 2, 1);

      m_ButtonBox.add(m_Button_Quit);
      m_ButtonBox.set_margin(6);
      m_Button_Quit.set_hexpand(true);
      m_Button_Quit.set_halign(Gtk::Align::END);
      m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this, &ExampleWindow::on_button_quit) );
    }

    ExampleWindow::~ExampleWindow()
    {
    }

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

File: `custom_gtk.css` (For use with gtkmm 4)

    /* Example of a CSS style sheet. */

    my-widget {
      background-color: rgb(255,0,0);
      color:            rgb(0,0,255);
      padding:          10px 15px 20px 5px; /* top right bottom left */
    }

## Multi-threaded programs

### The constraints

Care is required when writing programs based on gtkmm using multiple threads of execution, arising from the fact that libsigc++, and in particular sigc::trackable, are not thread-safe. That's because none of the complex interactions that occur behind the scenes when using libsigc++ are protected by a mutex or other means of synchronization.

These interactions arise from the fact that, amongst other things, a class inheriting from sigc::trackable will, via that inheritance, have a std::list object keeping track of slots created by calls to `sigc::mem_fun()` representing any of its non-static methods (more particularly it keeps a list of callbacks which will null the connected slots on its destruction). Each sigc::slot object also keeps, via sigc::slot_rep, its own sigc::trackable object to track any sigc::connection objects which it needs to inform about its demise, and also has a function to deregister itself from any sigc::trackable on disconnection or destruction. sigc::signal objects also keep lists of slots, which will be updated by a call to their connect() method or calls to any sigc::connection object relating to such a connection.

#### The rules

This requires a number of rules to be observed when writing multi-threaded programs using gtkmm. These are set out below, but one point to note is that extra care is required when deriving classes from sigc::trackable, because the effects are unintuitive (see particularly points 4 and 5 below).

1. Use Glib::Dispatcher to invoke gtkmm functions from worker threads (this is dealt with in more detail in the next section).

2. A sigc::signal object should be regarded as owned by the thread which created it. Only that thread should connect a sigc::slot object to the signal object, and only that thread should emit() or call operator()() on the signal, or null any connected sigc::slot object. It follows (amongst other things) that any signal object provided by a gtkmm widget should only be operated on in the main GUI thread and any object deriving from sigc::trackable having its non-static methods referenced by slots connected to the signal object should only be destroyed in that thread.

3. Any sigc::connection object should be regarded as owned by the thread in which the method returning the sigc::connection object was called. Only that thread should call sigc::connection methods on the object.

4. A sigc::slot object created by a call to `sigc::mem_fun()` which references a method of a class deriving from sigc::trackable should never be copied to another thread, nor destroyed by a different thread than the one which created it.

5. If a particular class object derives from sigc::trackable, only one thread should create sigc::slot objects representing any of the class's non-static methods by calling `sigc::mem_fun()`. The first thread to create such a slot should be regarded as owning the relevant object for the purpose of creating further slots referencing any of its non-static methods using that function, or nulling those slots by disconnecting them or destroying the trackable object.

6. Although glib is itself thread-safe, any glibmm wrappers which use libsigc++ will not be. So for example, only the thread in which a main loop runs should call Glib::SignalIdle::connect(), Glib::SignalIO::connect(), Glib::SignalTimeout::connect(), Glib::SignalTimeout::connect_seconds for that main loop, or manipulate any sigc::connection object returned by them.

   The connect*_once() variants, Glib::SignalIdle::connect_once(), Glib::SignalTimeout::connect_once(), Glib::SignalTimeout::connect_seconds_once(), are thread-safe for any case where the slot is not created by a call to `sigc::mem_fun()` which represents a method of a class deriving from sigc::trackable.

### Using Glib::Dispatcher

The slots connected to sigc::signal objects execute in the thread which calls emit() or operator()() on the signal. Glib::Dispatcher does not behave this way: instead its connected slots execute in the thread in which the Glib::Dispatcher object was constructed (which must have a glib main loop). If a Glib::Dispatcher object is constructed in the main GUI thread (which will therefore be the receiver thread), any worker thread can emit on it and have the connected slots safely execute gtkmm functions.

Some thread safety rules on the use of Glib::Dispatcher still apply. As mentioned, a Glib::Dispatcher object must be constructed in the receiver thread (the thread in whose main loop it will execute its connected slots). By default this is the main program thread, although there is a Glib::Dispatcher constructor which can take the Glib::MainContext object of any thread which has a main loop. Only the receiver thread should call connect() on the Glib::Dispatcher object, or manipulate any related sigc::connection object, unless additional synchronization is employed. However, any worker thread can safely emit on the Glib::Dispatcher object without any locking once the receiver thread has connected the slots, provided that it is constructed before the worker thread is started (if it is constructed after the thread has started, additional synchronization will normally be required to ensure visibility).

Aside from the fact that connected slots always execute in the receiver thread, Glib::Dispatcher objects are similar to sigc::signal<void()> objects. They therefore cannot pass unbound arguments nor return a value. The best way to pass unbound arguments is with a thread-safe (asynchronous) queue. At the time of writing glibmm does not have one, although most people writing multi-threaded code will have one available to them (they are relatively easy to write although there are subtleties in combining thread safety with strong exception safety).

A Glib::Dispatcher object can be emitted on by the receiver thread as well as by a worker thread, although this should be done within reasonable bounds. On unix-like systems Glib::Dispatcher objects share a single common pipe, which could in theory at least fill up on a very heavily loaded system running a program with a very large number of Dispatcher objects in use. Were the pipe to fill up before the receiver thread's main loop has had an opportunity to read from it to empty it, and the receiver thread attempt to emit and so write to it when it is in that condition, the receiver thread would block on the write, so deadlocking. Where the receiver thread is to emit, a normal sigc::signal<void()> object could of course be used instead.

### Exemple

This is an example program with two threads, one GUI thread, like in all gtkmm programs, and one worker thread. The worker thread is created when you press the `Start work` button. It is deleted when the work is finished, when you press the `Stop work` button, or when you press the `Quit` button.

A Glib::Dispatcher is used for sending notifications from the worker thread to the GUI thread. The ExampleWorker class contains data which is accessed by both threads. This data is protected by a std::mutex. Only the GUI thread updates the GUI.

Multi-Threaded Program

Source Code

File: `examplewindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

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

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

      // Called from the worker thread.
      void notify();

    private:
      // Signal handlers.
      void on_start_button_clicked();
      void on_stop_button_clicked();
      void on_quit_button_clicked();

      void update_start_stop_buttons();
      void update_widgets();

      // Dispatcher handler.
      void on_notification_from_worker_thread();

      // Member data.
      Gtk::Box m_VBox;
      Gtk::Box m_ButtonBox;
      Gtk::Button m_ButtonStart;
      Gtk::Button m_ButtonStop;
      Gtk::Button m_ButtonQuit;
      Gtk::ProgressBar m_ProgressBar;
      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TextView m_TextView;

      Glib::Dispatcher m_Dispatcher;
      ExampleWorker m_Worker;
      std::thread* m_WorkerThread;
    };

    #endif // GTKMM_EXAMPLEWINDOW_H

File: `exampleworker.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEWORKER_H
    #define GTKMM_EXAMPLEWORKER_H

    #include <gtkmm.h>
    #include <thread>
    #include <mutex>

    class ExampleWindow;

    class ExampleWorker
    {
    public:
      ExampleWorker();

      // Thread function.
      void do_work(ExampleWindow* caller);

      void get_data(double* fraction_done, Glib::ustring* message) const;
      void stop_work();
      bool has_stopped() const;

    private:
      // Synchronizes access to member data.
      mutable std::mutex m_Mutex;

      // Data used by both GUI thread and worker thread.
      bool m_shall_stop;
      bool m_has_stopped;
      double m_fraction_done;
      Glib::ustring m_message;
    };

    #endif // GTKMM_EXAMPLEWORKER_H

File: `main.cc` (For use with gtkmm 4)

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

    int main (int argc, char* argv[])
    {
      auto app = Gtk::Application::create("org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window, argc, argv);
    }

File: `examplewindow.cc` (For use with gtkmm 4)

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

    ExampleWindow::ExampleWindow() :
      m_VBox(Gtk::Orientation::VERTICAL, 5),
      m_ButtonBox(Gtk::Orientation::HORIZONTAL),
      m_ButtonStart("Start work"),
      m_ButtonStop("Stop work"),
      m_ButtonQuit("_Quit", /* mnemonic= */ true),
      m_ProgressBar(),
      m_ScrolledWindow(),
      m_TextView(),
      m_Dispatcher(),
      m_Worker(),
      m_WorkerThread(nullptr)
    {
      set_title("Multi-threaded example");
      set_default_size(300, 300);

      m_VBox.set_margin(5);
      add(m_VBox);

      // Add the ProgressBar.
      m_VBox.add(m_ProgressBar);

      m_ProgressBar.set_text("Fraction done");
      m_ProgressBar.set_show_text();

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

      // Only show the scrollbars when they are necessary.
      m_ScrolledWindow.set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
      m_ScrolledWindow.set_expand();

      m_VBox.add(m_ScrolledWindow);

      m_TextView.set_editable(false);

      // Add the buttons to the ButtonBox.
      m_VBox.add(m_ButtonBox);

      m_ButtonBox.add(m_ButtonStart);
      m_ButtonBox.add(m_ButtonStop);
      m_ButtonBox.add(m_ButtonQuit);
      m_ButtonBox.set_margin(5);
      m_ButtonBox.set_spacing(5);
      m_ButtonStart.set_hexpand(true);
      m_ButtonStart.set_halign(Gtk::Align::END);

      // Connect the signal handlers to the buttons.
      m_ButtonStart.signal_clicked().connect(sigc::mem_fun(*this, &ExampleWindow::on_start_button_clicked));
      m_ButtonStop.signal_clicked().connect(sigc::mem_fun(*this, &ExampleWindow::on_stop_button_clicked));
      m_ButtonQuit.signal_clicked().connect(sigc::mem_fun(*this, &ExampleWindow::on_quit_button_clicked));

      // Connect the handler to the dispatcher.
      m_Dispatcher.connect(sigc::mem_fun(*this, &ExampleWindow::on_notification_from_worker_thread));

      // Create a text buffer mark for use in update_widgets().
      auto buffer = m_TextView.get_buffer();
      buffer->create_mark("last_line", buffer->end(), /* left_gravity= */ true);

      update_start_stop_buttons();
    }

    void ExampleWindow::on_start_button_clicked()
    {
      if (m_WorkerThread)
      {
        std::cout << "Can't start a worker thread while another one is running." << std::endl;
      }
      else
      {
        // Start a new worker thread.
        m_WorkerThread = new std::thread(
          [this]
          {
            m_Worker.do_work(this);
          });
      }
      update_start_stop_buttons();
    }

    void ExampleWindow::on_stop_button_clicked()
    {
      if (!m_WorkerThread)
      {
        std::cout << "Can't stop a worker thread. None is running." << std::endl;
      }
      else
      {
       // Order the worker thread to stop.
        m_Worker.stop_work();
        m_ButtonStop.set_sensitive(false);
      }
    }

    void ExampleWindow::update_start_stop_buttons()
    {
      const bool thread_is_running = m_WorkerThread != nullptr;

      m_ButtonStart.set_sensitive(!thread_is_running);
      m_ButtonStop.set_sensitive(thread_is_running);
    }

    void ExampleWindow::update_widgets()
    {
      double fraction_done;
      Glib::ustring message_from_worker_thread;
      m_Worker.get_data(&fraction_done, &message_from_worker_thread);

      m_ProgressBar.set_fraction(fraction_done);

      if (message_from_worker_thread != m_TextView.get_buffer()->get_text())
      {
        auto buffer = m_TextView.get_buffer();
        buffer->set_text(message_from_worker_thread);

        // Scroll the last inserted line into view. That's somewhat complicated.
        auto iter = buffer->end();
        iter.set_line_offset(0); // Beginning of last line
        auto mark = buffer->get_mark("last_line");
        buffer->move_mark(mark, iter);
        m_TextView.scroll_to(mark);
        // TextView::scroll_to(iter) is not perfect.
        // We do need a TextMark to always get the last line into view.
      }
    }

    void ExampleWindow::on_quit_button_clicked()
    {
      if (m_WorkerThread)
      {
        // Order the worker thread to stop and wait for it to stop.
        m_Worker.stop_work();
        if (m_WorkerThread->joinable())
          m_WorkerThread->join();
      }
      hide();
    }

    // notify() is called from ExampleWorker::do_work(). It is executed in the worker
    // thread. It triggers a call to on_notification_from_worker_thread(), which is
    // executed in the GUI thread.
    void ExampleWindow::notify()
    {
      m_Dispatcher.emit();
    }

    void ExampleWindow::on_notification_from_worker_thread()
    {
      if (m_WorkerThread && m_Worker.has_stopped())
      {
        // Work is done.
        if (m_WorkerThread->joinable())
          m_WorkerThread->join();
        delete m_WorkerThread;
        m_WorkerThread = nullptr;
        update_start_stop_buttons();
      }
      update_widgets();
    }

File: `exampleworker.cc` (For use with gtkmm 4)

    #include "exampleworker.h"
    #include "examplewindow.h"
    #include <sstream>
    #include <chrono>

    ExampleWorker::ExampleWorker() :
      m_Mutex(),
      m_shall_stop(false),
      m_has_stopped(false),
      m_fraction_done(0.0),
      m_message()
    {
    }

    // Accesses to these data are synchronized by a mutex.
    // Some microseconds can be saved by getting all data at once, instead of having
    // separate get_fraction_done() and get_message() methods.
    void ExampleWorker::get_data(double* fraction_done, Glib::ustring* message) const
    {
      std::lock_guard<std::mutex> lock(m_Mutex);

      if (fraction_done)
        *fraction_done = m_fraction_done;

      if (message)
        *message = m_message;
    }

    void ExampleWorker::stop_work()
    {
      std::lock_guard<std::mutex> lock(m_Mutex);
      m_shall_stop = true;
    }

    bool ExampleWorker::has_stopped() const
    {
      std::lock_guard<std::mutex> lock(m_Mutex);
      return m_has_stopped;
    }

    void ExampleWorker::do_work(ExampleWindow* caller)
    {
      {
        std::lock_guard<std::mutex> lock(m_Mutex);
        m_has_stopped = false;
        m_fraction_done = 0.0;
        m_message = "";
      } // The mutex is unlocked here by lock's destructor.

      // Simulate a long calculation.
      for (int i = 0; ; ++i) // do until break
      {
        std::this_thread::sleep_for(std::chrono::milliseconds(250));

        {
          std::lock_guard<std::mutex> lock(m_Mutex);

          m_fraction_done += 0.01;

          if (i % 4 == 3)
          {
            std::ostringstream ostr;
            ostr << (m_fraction_done * 100.0) << "% done\n";
            m_message += ostr.str();
          }

          if (m_fraction_done >= 1.0)
          {
            m_message += "Finished";
            break;
          }
          if (m_shall_stop)
          {
            m_message += "Stopped";
            break;
          }
        }

        caller->notify();
      }

      {
        std::lock_guard<std::mutex> lock(m_Mutex);
        m_shall_stop = false;
        m_has_stopped = true;
      }

      caller->notify();
    }

## 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.

Use GNU autoconf and automake! They are your friends :) Automake examines C files, determines how they depend on each other, and generates a `Makefile` so the files can be compiled in the correct order. Autoconf permits automatic configuration of software installation, handling a large number of system quirks to increase portability.

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

Most applications will have only one Window, or only one main window. These applications can use the Gtk::Application::run(Gtk::Window& window) or Gtk::Application::run(Gtk::Window& window, int argc, char** argv) overloads. They show the window and return when the window has been hidden. This might happen when the user closes the window, or when your code decides to hide() the window. You can prevent the user from closing the window (for instance, if there are unsaved changes) by overriding 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. Pack the widget into a container using the appropriate call, e.g. Gtk::Container::add().

If you don't want all widgets to be shown, call Gtk::Widget::hide() on the widgets that you don't want to show. If a container widget is hidden, all of its child widgets are also hidden, even if hide() is not called on the child widgets.

## Building applications

This chapter is similar to the "Building applications" chapter in the GTK+ 4 Reference Manual. The same application is built, but gtkmm is used instead of GTK+.

An application consists of a number of files:

The binary file

  This gets installed in `/usr/bin`.

A desktop file

  The desktop file provides important information about the application to the desktop shell, such as its name, icon, D-Bus name, commandline to launch it, etc. It is installed in `/usr/share/applications`.

An icon

  The icon gets installed in `/usr/share/icons/hicolor/48x48/apps`, where it will be found regardless of the current theme.

A settings schema

  If the application uses Gio::Settings, it will install its schema in `/usr/share/glib-2.0/schemas`, so that tools like dconf-editor can find it.

Other resources

  Other files, such as Gtk::Builder ui files, are best loaded from resources stored in the application binary itself. This eliminates the need for most of the files that would traditionally be installed in an application-specific location in `/usr/share`.

gtkmm includes application support that is built on top of Gio::Application. In this chapter we'll build a simple application by starting from scratch, adding more and more pieces over time. Along the way, we'll learn about Gtk::Application, Gtk::Builder, resources, application menus, settings, Gtk::HeaderBar, Gtk::Stack, Gtk::SearchBar, Gtk::ListBox, and more.

The full, buildable sources for these examples can be found in the `examples/book/buildapp` directory of the gtkmm-documentation source distribution, or online in the gtkmm-documentation git repository. You can build each example separately by using make with the `Makefile.example` file. For more information, see the `README` included in the `buildapp` directory.

### A trivial application

When using Gtk::Application, the `main()` function can be very simple. We just call Gtk::Application::run() on an instance of our application class.

All the application logic is in the application class, which is a subclass of Gtk::Application. Our example does not yet have any interesting functionality. All it does is open a window when it is activated without arguments, and open the files it is given, if it is started with arguments. (Or rather, our application class tries to open the files, but our subclassed application window does not yet do what it's told to do.)

To handle these two cases, we override signal_activate()'s default handler, which gets called when the application is launched without commandline arguments, and signal_open()'s default handler, which gets called when the application is launched with commandline arguments.

Gio::Application Reference

Gtk::Application Reference

Another important class that is part of the application support in gtkmm is Gtk::ApplicationWindow. It is typically subclassed as well. Our subclass does not do anything yet, so we will just get an empty window.

As part of the initial setup of our application, we also create an icon and a desktop file. Note that @bindir@ in the desktop file needs to be replaced with the actual path to the binary before this desktop file can be used.

Here is what we've achieved so far:

A trivial application

This does not look very impressive yet, but our application is already presenting itself on the session bus, it has single-instance semantics, and it accepts files as commandline arguments.

Source Code

File: `exampleappwindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEAPPWINDOW_H_
    #define GTKMM_EXAMPLEAPPWINDOW_H_

    #include <gtkmm.h>

    class ExampleAppWindow : public Gtk::ApplicationWindow
    {
    public:
      ExampleAppWindow();

      void open_file_view(const Glib::RefPtr<Gio::File>& file);
    };

    #endif /* GTKMM_EXAMPLEAPPWINDOW_H */

File: `exampleapplication.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEAPPLICATION_H
    #define GTKMM_EXAMPLEAPPLICATION_H

    #include <gtkmm.h>

    class ExampleAppWindow;

    class ExampleApplication: public Gtk::Application
    {
    protected:
      ExampleApplication();

    public:
      static Glib::RefPtr<ExampleApplication> create();

    protected:
      // Override default signal handlers:
      void on_activate() override;
      void on_open(const Gio::Application::type_vec_files& files,
        const Glib::ustring& hint) override;

    private:
      ExampleAppWindow* create_appwindow();
      void on_hide_window(Gtk::Window* window);
    };

    #endif /* GTKMM_EXAMPLEAPPLICATION_H */

File: `exampleapplication.cc` (For use with gtkmm 4)

    #include "exampleapplication.h"
    #include "exampleappwindow.h"

    ExampleApplication::ExampleApplication()
    : Gtk::Application("org.gtkmm.examples.application", Gio::Application::Flags::HANDLES_OPEN)
    {
    }

    Glib::RefPtr<ExampleApplication> ExampleApplication::create()
    {
      return Glib::RefPtr<ExampleApplication>(new ExampleApplication());
    }

    ExampleAppWindow* ExampleApplication::create_appwindow()
    {
      auto appwindow = new ExampleAppWindow();

      // Make sure that the application runs for as long this window is still open.
      add_window(*appwindow);

      // Gtk::Application::add_window() connects a signal handler to the window's
      // signal_hide(). That handler removes the window from the application.
      // If it's the last window to be removed, the application stops running.
      // Gtk::Window::set_application() does not connect a signal handler, but is
      // otherwise equivalent to Gtk::Application::add_window().

      // Delete the window when it is hidden.
      appwindow->signal_hide().connect(sigc::bind(sigc::mem_fun(*this,
        &ExampleApplication::on_hide_window), appwindow));

      return appwindow;
    }

    void ExampleApplication::on_activate()
    {
      // The application has been started, so let's show a window.
      auto appwindow = create_appwindow();
      appwindow->present();
    }

    void ExampleApplication::on_open(const Gio::Application::type_vec_files& files,
      const Glib::ustring& /* hint */)
    {
      // The application has been asked to open some files,
      // so let's open a new view for each one.
      ExampleAppWindow* appwindow = nullptr;
      auto windows = get_windows();
      if (windows.size() > 0)
        appwindow = dynamic_cast<ExampleAppWindow*>(windows[0]);

      if (!appwindow)
        appwindow = create_appwindow();

      for (const auto& file : files)
        appwindow->open_file_view(file);

      appwindow->present();
    }

    void ExampleApplication::on_hide_window(Gtk::Window* window)
    {
      delete window;
    }

File: `main.cc` (For use with gtkmm 4)

    #include "exampleapplication.h"

    int main(int argc, char* argv[])
    {
      auto application = ExampleApplication::create();

      // Start the application, showing the initial window,
      // and opening extra views for any files that it is asked to open,
      // for instance as a command-line parameter.
      // run() will return when the last window has been closed.
      return application->run(argc, argv);
    }

File: `exampleappwindow.cc` (For use with gtkmm 4)

    #include "exampleappwindow.h"

    ExampleAppWindow::ExampleAppWindow()
    : Gtk::ApplicationWindow()
    {
    }

    void ExampleAppWindow::open_file_view(const Glib::RefPtr<Gio::File>& /* file */)
    {
    }

File: `exampleapp.desktop` (For use with gtkmm 4)

    [Desktop Entry]
    Type=Application
    Name=Gtkmm example
    GenericName=Example
    Comment=From the "Programming with gtkmm 4" tutorial
    Icon=exampleapp
    StartupNotify=true
    Exec=@bindir@/exampleapp %U
    Categories=GNOME;GTK;Utility

### Populating the window

In this step, we use a Gtk::Builder instance to associate a Gtk::Builder ui file with our application window class.

Our simple ui file puts a Gtk::HeaderBar on top of a Gtk::Stack widget. The header bar contains a Gtk::StackSwitcher, which is a standalone widget to show a row of 'tabs' for the pages of a Gtk::Stack.

To make use of this file in our application, we revisit our Gtk::ApplicationWindow subclass, and call Gtk::Builder::create_from_resource() and Gtk::Builder::get_widget_derived() from the ExampleAppWindow::create() method to get an instance of our subclassed Gtk::ApplicationWindow. See the Using derived widgets section for more information about get_widget_derived().

You may have noticed that we use the _from_resource() variant of the method that reads the ui file. Now we need to use GLib's resource functionality to include the ui file in the binary. This is commonly done by listing all resources in a .gresource.xml file. This file has to be converted into a C source file that will be compiled and linked into the application together with the other source files. To do so, we use the glib-compile-resources utility:

    $ glib-compile-resources --target=resources.c --generate-source exampleapp.gresource.xml

The Gio::Resource and glib-compile-resources section contains more information about resource files.

Our application now looks like this:

Populating the window

Source Code

File: `exampleappwindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEAPPWINDOW_H_
    #define GTKMM_EXAMPLEAPPWINDOW_H_

    #include <gtkmm.h>

    class ExampleAppWindow : public Gtk::ApplicationWindow
    {
    public:
      ExampleAppWindow(BaseObjectType* cobject,
        const Glib::RefPtr<Gtk::Builder>& refBuilder);

      static ExampleAppWindow* create();

      void open_file_view(const Glib::RefPtr<Gio::File>& file);

    protected:
      Glib::RefPtr<Gtk::Builder> m_refBuilder;
    };

    #endif /* GTKMM_EXAMPLEAPPWINDOW_H */

File: `exampleapplication.h` (For use with gtkmm 4)

    #include "../step1/exampleapplication.h"
    // Equal to the corresponding file in step1

File: `exampleapplication.cc` (For use with gtkmm 4)

    #include "exampleapplication.h"
    #include "exampleappwindow.h"
    #include <iostream>
    #include <exception>

    ExampleApplication::ExampleApplication()
    : Gtk::Application("org.gtkmm.examples.application", Gio::Application::Flags::HANDLES_OPEN)
    {
    }

    Glib::RefPtr<ExampleApplication> ExampleApplication::create()
    {
      return Glib::RefPtr<ExampleApplication>(new ExampleApplication());
    }

    ExampleAppWindow* ExampleApplication::create_appwindow()
    {
      auto appwindow = ExampleAppWindow::create();

      // Make sure that the application runs for as long this window is still open.
      add_window(*appwindow);

      // Gtk::Application::add_window() connects a signal handler to the window's
      // signal_hide(). That handler removes the window from the application.
      // If it's the last window to be removed, the application stops running.
      // Gtk::Window::set_application() does not connect a signal handler, but is
      // otherwise equivalent to Gtk::Application::add_window().

      // Delete the window when it is hidden.
      appwindow->signal_hide().connect(sigc::bind(sigc::mem_fun(*this,
        &ExampleApplication::on_hide_window), appwindow));

      return appwindow;
    }

    void ExampleApplication::on_activate()
    {
      try
      {
        // The application has been started, so let's show a window.
        auto appwindow = create_appwindow();
        appwindow->present();
      }
      // If create_appwindow() throws an exception (perhaps from Gtk::Builder),
      // no window has been created, no window has been added to the application,
      // and therefore the application will stop running.
      catch (const Glib::Error& ex)
      {
        std::cerr << "ExampleApplication::on_activate(): " << ex.what() << std::endl;
      }
      catch (const std::exception& ex)
      {
        std::cerr << "ExampleApplication::on_activate(): " << ex.what() << std::endl;
      }
    }

    void ExampleApplication::on_open(const Gio::Application::type_vec_files& files,
      const Glib::ustring& /* hint */)
    {
      // The application has been asked to open some files,
      // so let's open a new view for each one.
      ExampleAppWindow* appwindow = nullptr;
      auto windows = get_windows();
      if (windows.size() > 0)
        appwindow = dynamic_cast<ExampleAppWindow*>(windows[0]);

      try
      {
        if (!appwindow)
          appwindow = create_appwindow();

        for (const auto& file : files)
          appwindow->open_file_view(file);

        appwindow->present();
      }
      catch (const Glib::Error& ex)
      {
        std::cerr << "ExampleApplication::on_open(): " << ex.what() << std::endl;
      }
      catch (const std::exception& ex)
      {
        std::cerr << "ExampleApplication::on_open(): " << ex.what() << std::endl;
      }
    }

    void ExampleApplication::on_hide_window(Gtk::Window* window)
    {
      delete window;
    }

File: `main.cc` (For use with gtkmm 4)

    #include "../step1/main.cc"
    // Equal to the corresponding file in step1

File: `exampleappwindow.cc` (For use with gtkmm 4)

    #include "exampleappwindow.h"
    #include <stdexcept>

    ExampleAppWindow::ExampleAppWindow(BaseObjectType* cobject,
      const Glib::RefPtr<Gtk::Builder>& refBuilder)
    : Gtk::ApplicationWindow(cobject),
      m_refBuilder(refBuilder)
    {
    }

    //static
    ExampleAppWindow* ExampleAppWindow::create()
    {
      // Load the Builder file and instantiate its widgets.
      auto refBuilder = Gtk::Builder::create_from_resource("/org/gtkmm/exampleapp/window.ui");

      ExampleAppWindow* window = nullptr;
      Gtk::Builder::get_widget_derived(refBuilder, "app_window", window);
      if (!window)
        throw std::runtime_error("No \"app_window\" object in window.ui");

      return window;
    }

    void ExampleAppWindow::open_file_view(const Glib::RefPtr<Gio::File>& /* file */)
    {
    }

File: `exampleapp.gresource.xml` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <gresources>
      <gresource prefix="/org/gtkmm/exampleapp">
        <file preprocess="xml-stripblanks">window.ui</file>
      </gresource>
    </gresources>

File: `window.ui` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <interface>
      <object class="GtkApplicationWindow" id="app_window">
        <property name="title" translatable="yes">Example Application</property>
        <property name="default-width">600</property>
        <property name="default-height">400</property>
        <child>
          <object class="GtkBox" id="content_box">
            <property name="orientation">vertical</property>
            <child>
              <object class="GtkHeaderBar" id="header">
                <child type="title">
                  <object class="GtkStackSwitcher" id="tabs">
                    <property name="stack">stack</property>
                  </object>
                </child>
              </object>
            </child>
            <child>
              <object class="GtkStack" id="stack"/>
            </child>
          </object>
        </child>
      </object>
    </interface>

### Opening files

In this step, we make our application show the contents of all the files that it is given on the commandline.

To this end, we add a data member to our application window and keep a pointer to the Gtk::Stack there. We get the pointer with a call to Gtk::Builder::get_widget() in the application window's constructor.

Now we revisit the ExampleAppWindow::open_file_view() method that is called for each commandline argument, and construct a Gtk::TextView that we then add as a page to the stack.

Note that we do not have to touch the stack switcher at all. It gets all its information from the stack that it belongs to. Here, we are passing the label to show for each file as the last argument to the Gtk::Stack::add() method.

Our application is beginning to take shape:

Opening files

Source Code

File: `exampleappwindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEAPPWINDOW_H_
    #define GTKMM_EXAMPLEAPPWINDOW_H_

    #include <gtkmm.h>

    class ExampleAppWindow : public Gtk::ApplicationWindow
    {
    public:
      ExampleAppWindow(BaseObjectType* cobject,
        const Glib::RefPtr<Gtk::Builder>& refBuilder);

      static ExampleAppWindow* create();

      void open_file_view(const Glib::RefPtr<Gio::File>& file);

    protected:
      Glib::RefPtr<Gtk::Builder> m_refBuilder;
      Gtk::Stack* m_stack;
    };

    #endif /* GTKMM_EXAMPLEAPPWINDOW_H */

File: `exampleapplication.h` (For use with gtkmm 4)

    #include "../step1/exampleapplication.h"
    // Equal to the corresponding file in step1

File: `exampleapplication.cc` (For use with gtkmm 4)

    #include "../step2/exampleapplication.cc"
    // Equal to the corresponding file in step2

File: `main.cc` (For use with gtkmm 4)

    #include "../step1/main.cc"
    // Equal to the corresponding file in step1

File: `exampleappwindow.cc` (For use with gtkmm 4)

    #include "exampleappwindow.h"
    #include <iostream>
    #include <stdexcept>

    ExampleAppWindow::ExampleAppWindow(BaseObjectType* cobject,
      const Glib::RefPtr<Gtk::Builder>& refBuilder)
    : Gtk::ApplicationWindow(cobject),
      m_refBuilder(refBuilder),
      m_stack(nullptr)
    {
      m_refBuilder->get_widget("stack", m_stack);
      if (!m_stack)
        throw std::runtime_error("No \"stack\" object in window.ui");
    }

    //static
    ExampleAppWindow* ExampleAppWindow::create()
    {
      // Load the Builder file and instantiate its widgets.
      auto refBuilder = Gtk::Builder::create_from_resource("/org/gtkmm/exampleapp/window.ui");

      ExampleAppWindow* window = nullptr;
      Gtk::Builder::get_widget_derived(refBuilder, "app_window", window);
      if (!window)
        throw std::runtime_error("No \"app_window\" object in window.ui");

      return window;
    }

    void ExampleAppWindow::open_file_view(const Glib::RefPtr<Gio::File>& file)
    {
      const auto basename = file->get_basename();

      auto scrolled = Gtk::make_managed<Gtk::ScrolledWindow>();
      scrolled->set_hexpand(true);
      scrolled->set_vexpand(true);
      scrolled->show();
      auto view = Gtk::make_managed<Gtk::TextView>();
      view->set_editable(false);
      view->set_cursor_visible(false);
      view->show();
      scrolled->add(*view);
      m_stack->add(*scrolled, basename, basename);

      try
      {
        char* contents = nullptr;
        gsize length = 0;

        file->load_contents(contents, length);
        view->get_buffer()->set_text(contents, contents+length);
        g_free(contents);
      }
      catch (const Glib::Error& ex)
      {
        std::cout << "ExampleAppWindow::open_file_view(\"" << file->get_parse_name()
          << "\"):\n  " << ex.what() << std::endl;
      }
    }

### An application menu

An application menu is shown by GNOME shell at the top of the screen. It is meant to collect infrequently used actions that affect the whole application. The application menu is shown either at the top of the screen, or at the top of the application's window, depending on which desktop shell you use.

Just like the application window, we specify our application menu in a ui file, and add it as a resource to our binary.

To associate the app menu with the application, we have to call Gtk::Application::set_app_menu(). Since app menus work by activating Gio::Actions, we also have to add a suitable set of actions to our application.

Both of these tasks are best done in the on_startup() default signal handler, which is guaranteed to be called once for each primary application instance.

Our preferences menu item does not do anything yet, but the Quit menu item is fully functional. It can also be activated by the usual Ctrl-Q shortcut. The shortcut is added with Gtk::Application::set_accel_for_action().

The application menu looks like this:

An application menu

Source Code

File: `exampleappwindow.h` (For use with gtkmm 4)

    #include "../step3/exampleappwindow.h"
    // Equal to the corresponding file in step3

File: `exampleapplication.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEAPPLICATION_H
    #define GTKMM_EXAMPLEAPPLICATION_H

    #include <gtkmm.h>

    class ExampleAppWindow;

    class ExampleApplication: public Gtk::Application
    {
    protected:
      ExampleApplication();

    public:
      static Glib::RefPtr<ExampleApplication> create();

    protected:
      // Override default signal handlers:
      void on_startup() override;
      void on_activate() override;
      void on_open(const Gio::Application::type_vec_files& files,
        const Glib::ustring& hint) override;

    private:
      ExampleAppWindow* create_appwindow();
      void on_hide_window(Gtk::Window* window);
      void on_action_preferences();
      void on_action_quit();
    };

    #endif /* GTKMM_EXAMPLEAPPLICATION_H */

File: `exampleapplication.cc` (For use with gtkmm 4)

    #include "exampleapplication.h"
    #include "exampleappwindow.h"
    #include <iostream>
    #include <exception>

    ExampleApplication::ExampleApplication()
    : Gtk::Application("org.gtkmm.examples.application", Gio::Application::Flags::HANDLES_OPEN)
    {
    }

    Glib::RefPtr<ExampleApplication> ExampleApplication::create()
    {
      return Glib::RefPtr<ExampleApplication>(new ExampleApplication());
    }

    ExampleAppWindow* ExampleApplication::create_appwindow()
    {
      auto appwindow = ExampleAppWindow::create();

      // Make sure that the application runs for as long this window is still open.
      add_window(*appwindow);

      // Gtk::Application::add_window() connects a signal handler to the window's
      // signal_hide(). That handler removes the window from the application.
      // If it's the last window to be removed, the application stops running.
      // Gtk::Window::set_application() does not connect a signal handler, but is
      // otherwise equivalent to Gtk::Application::add_window().

      // Delete the window when it is hidden.
      appwindow->signal_hide().connect(sigc::bind(sigc::mem_fun(*this,
        &ExampleApplication::on_hide_window), appwindow));

      return appwindow;
    }

    void ExampleApplication::on_startup()
    {
      // Call the base class's implementation.
      Gtk::Application::on_startup();

      // Add actions and keyboard accelerators for the application menu.
      add_action("preferences", sigc::mem_fun(*this, &ExampleApplication::on_action_preferences));
      add_action("quit", sigc::mem_fun(*this, &ExampleApplication::on_action_quit));
      set_accel_for_action("app.quit", "<Ctrl>Q");

      auto refBuilder = Gtk::Builder::create();
      try
      {
        refBuilder->add_from_resource("/org/gtkmm/exampleapp/app_menu.ui");
      }
      catch (const Glib::Error& ex)
      {
        std::cerr << "ExampleApplication::on_startup(): " << ex.what() << std::endl;
        return;
      }

      auto object = refBuilder->get_object("appmenu");
      auto app_menu = std::dynamic_pointer_cast<Gio::MenuModel>(object);
      if (app_menu)
        set_app_menu(app_menu);
      else
        std::cerr << "ExampleApplication::on_startup(): No \"appmenu\" object in app_menu.ui"
                  << std::endl;
    }

    void ExampleApplication::on_activate()
    {
      try
      {
        // The application has been started, so let's show a window.
        auto appwindow = create_appwindow();
        appwindow->present();
      }
      // If create_appwindow() throws an exception (perhaps from Gtk::Builder),
      // no window has been created, no window has been added to the application,
      // and therefore the application will stop running.
      catch (const Glib::Error& ex)
      {
        std::cerr << "ExampleApplication::on_activate(): " << ex.what() << std::endl;
      }
      catch (const std::exception& ex)
      {
        std::cerr << "ExampleApplication::on_activate(): " << ex.what() << std::endl;
      }
    }

    void ExampleApplication::on_open(const Gio::Application::type_vec_files& files,
      const Glib::ustring& /* hint */)
    {
      // The application has been asked to open some files,
      // so let's open a new view for each one.
      ExampleAppWindow* appwindow = nullptr;
      auto windows = get_windows();
      if (windows.size() > 0)
        appwindow = dynamic_cast<ExampleAppWindow*>(windows[0]);

      try
      {
        if (!appwindow)
          appwindow = create_appwindow();

        for (const auto& file : files)
          appwindow->open_file_view(file);

        appwindow->present();
      }
      catch (const Glib::Error& ex)
      {
        std::cerr << "ExampleApplication::on_open(): " << ex.what() << std::endl;
      }
      catch (const std::exception& ex)
      {
        std::cerr << "ExampleApplication::on_open(): " << ex.what() << std::endl;
      }
    }

    void ExampleApplication::on_hide_window(Gtk::Window* window)
    {
      delete window;
    }

    void ExampleApplication::on_action_preferences()
    {

    }

    void ExampleApplication::on_action_quit()
    {
      // Gio::Application::quit() will make Gio::Application::run() return,
      // but it's a crude way of ending the program. The window is not removed
      // from the application. Neither the window's nor the application's
      // destructors will be called, because there will be remaining reference
      // counts in both of them. If we want the destructors to be called, we
      // must remove the window from the application. One way of doing this
      // is to hide the window. See comment in create_appwindow().
      auto windows = get_windows();
      for (auto window : windows)
        window->hide();

      // Not really necessary, when Gtk::Widget::hide() is called, unless
      // Gio::Application::hold() has been called without a corresponding call
      // to Gio::Application::release().
      quit();
    }

File: `main.cc` (For use with gtkmm 4)

    #include "../step1/main.cc"
    // Equal to the corresponding file in step1

File: `exampleappwindow.cc` (For use with gtkmm 4)

    #include "../step3/exampleappwindow.cc"
    // Equal to the corresponding file in step3

File: `exampleapp.gresource.xml` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <gresources>
      <gresource prefix="/org/gtkmm/exampleapp">
        <file preprocess="xml-stripblanks">window.ui</file>
        <file preprocess="xml-stripblanks">app_menu.ui</file>
      </gresource>
    </gresources>

File: `app_menu.ui` (For use with gtkmm 4)

    <?xml version="1.0"?>
    <interface>
      <!-- interface-requires gtk+ 3.0 -->
      <menu id="appmenu">
        <section>
          <item>
            <attribute name="label" translatable="yes">_Preferences</attribute>
            <attribute name="action">app.preferences</attribute>
          </item>
        </section>
        <section>
          <item>
            <attribute name="label" translatable="yes">_Quit</attribute>
            <attribute name="action">app.quit</attribute>
          </item>
        </section>
      </menu>
    </interface>

### A preference dialog

A typical application will have some preferences that should be remembered from one run to the next. Even for our simple example application, we may want to change the font that is used for the content.

We are going to use Gio::Settings to store our preferences. Gio::Settings requires a schema that describes our settings, in our case the `org.gtkmm.exampleapp.gschema.xml` file.

Before we can make use of this schema in our application, we need to compile it into the binary form that Gio::Settings expects. GIO provides macros to do this in autotools-based projects. See the description of GSettings.

Next, we need to connect our settings to the widgets that they are supposed to control. One convenient way to do this is to use Gio::Settings::bind() to bind settings keys to object properties, as we do for the transition setting in ExampleAppWindow's constructor.

    m_settings = Gio::Settings::create("org.gtkmm.exampleapp");
    m_settings->bind("transition", m_stack->property_transition_type());

The code to connect the font setting is a little more involved, since it corresponds to an object property in a Gtk::TextTag that we must first create. The code is in ExampleAppWindow::open_file_view().

    auto tag = buffer->create_tag();
    m_settings->bind("font", tag->property_font());
    buffer->apply_tag(tag, buffer->begin(), buffer->end());

At this point, the application will already react if you change one of the settings, e.g. using the `gsettings` commandline tool. Of course, we expect the application to provide a preference dialog for these. So lets do that now. Our preference dialog will be a subclass of Gtk::Dialog, and we'll use the same techniques that we've already seen in ExampleAppWindow: a Gtk::Builder ui file and settings bindings.

When we've created the `prefs.ui` file and the ExampleAppPrefs class, we revisit the ExampleApplication::on_action_preferences() method in our application class, and make it open a new preference dialog.

    auto prefs_dialog = ExampleAppPrefs::create(*get_active_window());
    prefs_dialog->present();

After all this work, our application can now show a preference dialog like this:

An preference dialog

Source Code

File: `exampleappwindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEAPPWINDOW_H_
    #define GTKMM_EXAMPLEAPPWINDOW_H_

    #include <gtkmm.h>

    class ExampleAppWindow : public Gtk::ApplicationWindow
    {
    public:
      ExampleAppWindow(BaseObjectType* cobject,
        const Glib::RefPtr<Gtk::Builder>& refBuilder);

      static ExampleAppWindow* create();

      void open_file_view(const Glib::RefPtr<Gio::File>& file);

    protected:
      Glib::RefPtr<Gtk::Builder> m_refBuilder;
      Glib::RefPtr<Gio::Settings> m_settings;
      Gtk::Stack* m_stack;
    };

    #endif /* GTKMM_EXAMPLEAPPWINDOW_H */

File: `exampleapplication.h` (For use with gtkmm 4)

    #include "../step4/exampleapplication.h"
    // Equal to the corresponding file in step4

File: `exampleappprefs.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEAPPPREFS_H_
    #define GTKMM_EXAMPLEAPPPREFS_H_

    #include <gtkmm.h>

    class ExampleAppPrefs : public Gtk::Dialog
    {
    public:
      ExampleAppPrefs(BaseObjectType* cobject,
        const Glib::RefPtr<Gtk::Builder>& refBuilder);

      static ExampleAppPrefs* create(Gtk::Window& parent);

    protected:
      Glib::RefPtr<Gtk::Builder> m_refBuilder;
      Glib::RefPtr<Gio::Settings> m_settings;
      Gtk::FontButton* m_font;
      Gtk::ComboBoxText* m_transition;
    };

    #endif /* GTKMM_EXAMPLEAPPPREFS_H_ */

File: `exampleappprefs.cc` (For use with gtkmm 4)

    #include "exampleappprefs.h"
    #include "exampleappwindow.h"
    #include <stdexcept>

    ExampleAppPrefs::ExampleAppPrefs(BaseObjectType* cobject,
      const Glib::RefPtr<Gtk::Builder>& refBuilder)
    : Gtk::Dialog(cobject),
      m_refBuilder(refBuilder),
      m_settings(),
      m_font(nullptr),
      m_transition(nullptr)
    {
      m_refBuilder->get_widget("font", m_font);
      if (!m_font)
        throw std::runtime_error("No \"font\" object in prefs.ui");

      m_refBuilder->get_widget("transition", m_transition);
      if (!m_transition)
        throw std::runtime_error("No \"transition\" object in prefs.ui");

      m_settings = Gio::Settings::create("org.gtkmm.exampleapp");
      m_settings->bind("font", m_font->property_font());
      m_settings->bind("transition", m_transition->property_active_id());
    }

    //static
    ExampleAppPrefs* ExampleAppPrefs::create(Gtk::Window& parent)
    {
      // Load the Builder file and instantiate its widgets.
      auto refBuilder = Gtk::Builder::create_from_resource("/org/gtkmm/exampleapp/prefs.ui");

      ExampleAppPrefs* dialog = nullptr;
      Gtk::Builder::get_widget_derived(refBuilder, "prefs_dialog", dialog);
      if (!dialog)
        throw std::runtime_error("No \"prefs_dialog\" object in prefs.ui");

      dialog->set_transient_for(parent);

      return dialog;
    }

File: `exampleapplication.cc` (For use with gtkmm 4)

    #include "exampleapplication.h"
    #include "exampleappwindow.h"
    #include "exampleappprefs.h"
    #include <iostream>
    #include <exception>

    ExampleApplication::ExampleApplication()
    : Gtk::Application("org.gtkmm.examples.application", Gio::Application::Flags::HANDLES_OPEN)
    {
    }

    Glib::RefPtr<ExampleApplication> ExampleApplication::create()
    {
      return Glib::RefPtr<ExampleApplication>(new ExampleApplication());
    }

    ExampleAppWindow* ExampleApplication::create_appwindow()
    {
      auto appwindow = ExampleAppWindow::create();

      // Make sure that the application runs for as long this window is still open.
      add_window(*appwindow);

      // Gtk::Application::add_window() connects a signal handler to the window's
      // signal_hide(). That handler removes the window from the application.
      // If it's the last window to be removed, the application stops running.
      // Gtk::Window::set_application() does not connect a signal handler, but is
      // otherwise equivalent to Gtk::Application::add_window().

      // Delete the window when it is hidden.
      appwindow->signal_hide().connect(sigc::bind(sigc::mem_fun(*this,
        &ExampleApplication::on_hide_window), appwindow));

      return appwindow;
    }

    void ExampleApplication::on_startup()
    {
      // Call the base class's implementation.
      Gtk::Application::on_startup();

      // Add actions and keyboard accelerators for the application menu.
      add_action("preferences", sigc::mem_fun(*this, &ExampleApplication::on_action_preferences));
      add_action("quit", sigc::mem_fun(*this, &ExampleApplication::on_action_quit));
      set_accel_for_action("app.quit", "<Ctrl>Q");

      auto refBuilder = Gtk::Builder::create();
      try
      {
        refBuilder->add_from_resource("/org/gtkmm/exampleapp/app_menu.ui");
      }
      catch (const Glib::Error& ex)
      {
        std::cerr << "ExampleApplication::on_startup(): " << ex.what() << std::endl;
        return;
      }

      auto object = refBuilder->get_object("appmenu");
      auto app_menu = std::dynamic_pointer_cast<Gio::MenuModel>(object);
      if (app_menu)
        set_app_menu(app_menu);
      else
        std::cerr << "ExampleApplication::on_startup(): No \"appmenu\" object in app_menu.ui"
                  << std::endl;
    }

    void ExampleApplication::on_activate()
    {
      try
      {
        // The application has been started, so let's show a window.
        auto appwindow = create_appwindow();
        appwindow->present();
      }
      // If create_appwindow() throws an exception (perhaps from Gtk::Builder),
      // no window has been created, no window has been added to the application,
      // and therefore the application will stop running.
      catch (const Glib::Error& ex)
      {
        std::cerr << "ExampleApplication::on_activate(): " << ex.what() << std::endl;
      }
      catch (const std::exception& ex)
      {
        std::cerr << "ExampleApplication::on_activate(): " << ex.what() << std::endl;
      }
    }

    void ExampleApplication::on_open(const Gio::Application::type_vec_files& files,
      const Glib::ustring& /* hint */)
    {
      // The application has been asked to open some files,
      // so let's open a new view for each one.
      ExampleAppWindow* appwindow = nullptr;
      auto windows = get_windows();
      if (windows.size() > 0)
        appwindow = dynamic_cast<ExampleAppWindow*>(windows[0]);

      try
      {
        if (!appwindow)
          appwindow = create_appwindow();

        for (const auto& file : files)
          appwindow->open_file_view(file);

        appwindow->present();
      }
      catch (const Glib::Error& ex)
      {
        std::cerr << "ExampleApplication::on_open(): " << ex.what() << std::endl;
      }
      catch (const std::exception& ex)
      {
        std::cerr << "ExampleApplication::on_open(): " << ex.what() << std::endl;
      }
    }

    void ExampleApplication::on_hide_window(Gtk::Window* window)
    {
      delete window;
    }

    void ExampleApplication::on_action_preferences()
    {
      try
      {
        auto prefs_dialog = ExampleAppPrefs::create(*get_active_window());
        prefs_dialog->present();

        // Delete the dialog when it is hidden.
        prefs_dialog->signal_hide().connect(sigc::bind(sigc::mem_fun(*this,
          &ExampleApplication::on_hide_window), prefs_dialog));
      }
      catch (const Glib::Error& ex)
      {
        std::cerr << "ExampleApplication::on_action_preferences(): " << ex.what() << std::endl;
      }
      catch (const std::exception& ex)
      {
        std::cerr << "ExampleApplication::on_action_preferences(): " << ex.what() << std::endl;
      }
    }

    void ExampleApplication::on_action_quit()
    {
      // Gio::Application::quit() will make Gio::Application::run() return,
      // but it's a crude way of ending the program. The window is not removed
      // from the application. Neither the window's nor the application's
      // destructors will be called, because there will be remaining reference
      // counts in both of them. If we want the destructors to be called, we
      // must remove the window from the application. One way of doing this
      // is to hide the window. See comment in create_appwindow().
      auto windows = get_windows();
      for (auto window : windows)
        window->hide();

      // Not really necessary, when Gtk::Widget::hide() is called, unless
      // Gio::Application::hold() has been called without a corresponding call
      // to Gio::Application::release().
      quit();
    }

File: `main.cc` (For use with gtkmm 4)

    #include "exampleapplication.h"

    int main(int argc, char* argv[])
    {
      // Since this example is running uninstalled, we have to help it find its
      // schema. This is *not* necessary in a properly installed application.
      Glib::setenv ("GSETTINGS_SCHEMA_DIR", ".", false);

      auto application = ExampleApplication::create();

      // Start the application, showing the initial window,
      // and opening extra views for any files that it is asked to open,
      // for instance as a command-line parameter.
      // run() will return when the last window has been closed.
      return application->run(argc, argv);
    }

File: `exampleappwindow.cc` (For use with gtkmm 4)

    #include "exampleappwindow.h"
    #include <iostream>
    #include <stdexcept>

    ExampleAppWindow::ExampleAppWindow(BaseObjectType* cobject,
      const Glib::RefPtr<Gtk::Builder>& refBuilder)
    : Gtk::ApplicationWindow(cobject),
      m_refBuilder(refBuilder),
      m_settings(),
      m_stack(nullptr)
    {
      m_refBuilder->get_widget("stack", m_stack);
      if (!m_stack)
        throw std::runtime_error("No \"stack\" object in window.ui");

      m_settings = Gio::Settings::create("org.gtkmm.exampleapp");
      m_settings->bind("transition", m_stack->property_transition_type());
    }

    //static
    ExampleAppWindow* ExampleAppWindow::create()
    {
      // Load the Builder file and instantiate its widgets.
      auto refBuilder = Gtk::Builder::create_from_resource("/org/gtkmm/exampleapp/window.ui");

      ExampleAppWindow* window = nullptr;
      Gtk::Builder::get_widget_derived(refBuilder, "app_window", window);
      if (!window)
        throw std::runtime_error("No \"app_window\" object in window.ui");

      return window;
    }

    void ExampleAppWindow::open_file_view(const Glib::RefPtr<Gio::File>& file)
    {
      const auto basename = file->get_basename();

      auto scrolled = Gtk::make_managed<Gtk::ScrolledWindow>();
      scrolled->set_hexpand(true);
      scrolled->set_vexpand(true);
      scrolled->show();
      auto view = Gtk::make_managed<Gtk::TextView>();
      view->set_editable(false);
      view->set_cursor_visible(false);
      view->show();
      scrolled->add(*view);
      m_stack->add(*scrolled, basename, basename);

      auto buffer = view->get_buffer();
      try
      {
        char* contents = nullptr;
        gsize length = 0;

        file->load_contents(contents, length);
        buffer->set_text(contents, contents+length);
        g_free(contents);
      }
      catch (const Glib::Error& ex)
      {
        std::cout << "ExampleAppWindow::open_file_view(\"" << file->get_parse_name()
          << "\"):\n  " << ex.what() << std::endl;
      }

      auto tag = buffer->create_tag();
      m_settings->bind("font", tag->property_font());
      buffer->apply_tag(tag, buffer->begin(), buffer->end());
    }

File: `exampleapp.gresource.xml` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <gresources>
      <gresource prefix="/org/gtkmm/exampleapp">
        <file preprocess="xml-stripblanks">window.ui</file>
        <file preprocess="xml-stripblanks">app_menu.ui</file>
        <file preprocess="xml-stripblanks">prefs.ui</file>
      </gresource>
    </gresources>

File: `prefs.ui` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <interface>
      <object class="GtkDialog" id="prefs_dialog">
        <property name="title" translatable="yes">Preferences</property>
        <property name="resizable">False</property>
        <property name="modal">True</property>
        <property name="use-header-bar">1</property>
        <child internal-child="content_area">
          <object class="GtkBox" id="content_area">
            <child>
              <object class="GtkGrid" id="grid">
                <property name="margin">6</property>
                <property name="row-spacing">12</property>
                <property name="column-spacing">6</property>
                <child>
                  <object class="GtkLabel" id="fontlabel">
                    <property name="label">_Font:</property>
                    <property name="use-underline">True</property>
                    <property name="mnemonic-widget">font</property>
                    <property name="xalign">1</property>
                    <layout>
                      <property name="left-attach">0</property>
                      <property name="top-attach">0</property>
                    </layout>
                  </object>
                </child>
                <child>
                  <object class="GtkFontButton" id="font">
                    <layout>
                      <property name="left-attach">1</property>
                      <property name="top-attach">0</property>
                    </layout>
                  </object>
                </child>
                <child>
                  <object class="GtkLabel" id="transitionlabel">
                    <property name="label">_Transition:</property>
                    <property name="use-underline">True</property>
                    <property name="mnemonic-widget">transition</property>
                    <property name="xalign">1</property>
                    <layout>
                      <property name="left-attach">0</property>
                      <property name="top-attach">1</property>
                    </layout>
                  </object>
                </child>
                <child>
                  <object class="GtkComboBoxText" id="transition">
                    <items>
                      <item translatable="yes" id="none">None</item>
                      <item translatable="yes" id="crossfade">Fade</item>
                      <item translatable="yes" id="slide-left-right">Slide</item>
                    </items>
                    <layout>
                      <property name="left-attach">1</property>
                      <property name="top-attach">1</property>
                    </layout>
                  </object>
                </child>
              </object>
            </child>
          </object>
        </child>
      </object>
    </interface>

File: `org.gtkmm.exampleapp.gschema.xml` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <schemalist>
      <schema path="/org/gtkmm/exampleapp/" id="org.gtkmm.exampleapp">
        <key name="font" type="s">
          <default>'Monospace 12'</default>
          <summary>Font</summary>
          <description>The font to be used for content.</description>
        </key>
        <key name="transition" type="s">
          <choices>
            <choice value='none'/>
            <choice value='crossfade'/>
            <choice value='slide-left-right'/>
          </choices>
          <default>'none'</default>
          <summary>Transition</summary>
          <description>The transition to use when switching tabs.</description>
        </key>
      </schema>
    </schemalist>

### Adding a search bar

We continue to flesh out the functionality of our application. For now, we add search. gtkmm supports this with Gtk::SearchEntry and Gtk::SearchBar. The search bar is a widget that can slide in from the top to present a search entry.

We add a toggle button to the header bar, which can be used to slide out the search bar below the header bar. The new widgets are added in the `window.ui` file.

Implementing the search needs quite a few code changes that we are not going to completely go over here. The central piece of the search implementation is a signal handler that listens for text changes in the search entry, shown here without error handling.

    void ExampleAppWindow::on_search_text_changed()
    {
      const auto text = m_searchentry->get_text();
      auto tab = dynamic_cast<Gtk::ScrolledWindow*>(m_stack->get_visible_child());
      auto view = dynamic_cast<Gtk::TextView*>(tab->get_child());

      // Very simple-minded search implementation.
      auto buffer = view->get_buffer();
      Gtk::TextIter match_start;
      Gtk::TextIter match_end;
      if (buffer->begin().forward_search(text, Gtk::TEXT_SEARCH_CASE_INSENSITIVE,
          match_start, match_end))
      {
        buffer->select_range(match_start, match_end);
        view->scroll_to(match_start);
      }
    }

With the search bar, our application now looks like this:

Adding a search bar

Source Code

File: `exampleappwindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEAPPWINDOW_H_
    #define GTKMM_EXAMPLEAPPWINDOW_H_

    #include <gtkmm.h>

    class ExampleAppWindow : public Gtk::ApplicationWindow
    {
    public:
      ExampleAppWindow(BaseObjectType* cobject,
        const Glib::RefPtr<Gtk::Builder>& refBuilder);

      static ExampleAppWindow* create();

      void open_file_view(const Glib::RefPtr<Gio::File>& file);

    protected:
      // Signal handlers
      void on_search_text_changed();
      void on_visible_child_changed();

      Glib::RefPtr<Gtk::Builder> m_refBuilder;
      Glib::RefPtr<Gio::Settings> m_settings;
      Gtk::Stack* m_stack;
      Gtk::ToggleButton* m_search;
      Gtk::SearchBar* m_searchbar;
      Gtk::SearchEntry* m_searchentry;
      Glib::RefPtr<Glib::Binding> m_prop_binding;
    };

    #endif /* GTKMM_EXAMPLEAPPWINDOW_H */

File: `exampleapplication.h` (For use with gtkmm 4)

    #include "../step4/exampleapplication.h"
    // Equal to the corresponding file in step4

File: `exampleappprefs.h` (For use with gtkmm 4)

    #include "../step5/exampleappprefs.h"
    // Equal to the corresponding file in step5

File: `exampleappprefs.cc` (For use with gtkmm 4)

    #include "../step5/exampleappprefs.cc"
    // Equal to the corresponding file in step5

File: `exampleapplication.cc` (For use with gtkmm 4)

    #include "../step5/exampleapplication.cc"
    // Equal to the corresponding file in step5

File: `main.cc` (For use with gtkmm 4)

    #include "../step5/main.cc"
    // Equal to the corresponding file in step5

File: `exampleappwindow.cc` (For use with gtkmm 4)

    #include "exampleappwindow.h"
    #include <iostream>
    #include <stdexcept>

    ExampleAppWindow::ExampleAppWindow(BaseObjectType* cobject,
      const Glib::RefPtr<Gtk::Builder>& refBuilder)
    : Gtk::ApplicationWindow(cobject),
      m_refBuilder(refBuilder),
      m_settings(),
      m_stack(nullptr),
      m_search(nullptr),
      m_searchbar(nullptr),
      m_searchentry(nullptr),
      m_prop_binding()
    {
      m_refBuilder->get_widget("stack", m_stack);
      if (!m_stack)
        throw std::runtime_error("No \"stack\" object in window.ui");

      m_refBuilder->get_widget("search", m_search);
      if (!m_search)
        throw std::runtime_error("No \"search\" object in window.ui");

      m_refBuilder->get_widget("searchbar", m_searchbar);
      if (!m_searchbar)
        throw std::runtime_error("No \"searchbar\" object in window.ui");

      m_refBuilder->get_widget("searchentry", m_searchentry);
      if (!m_searchentry)
        throw std::runtime_error("No \"searchentry\" object in window.ui");

      m_settings = Gio::Settings::create("org.gtkmm.exampleapp");
      m_settings->bind("transition", m_stack->property_transition_type());

      m_prop_binding = Glib::Binding::bind_property(m_search->property_active(),
        m_searchbar->property_search_mode_enabled(), Glib::Binding::Flags::BIDIRECTIONAL);

      // Connect signal handlers.
      m_searchentry->signal_search_changed().connect(
        sigc::mem_fun(*this, &ExampleAppWindow::on_search_text_changed));
      m_stack->property_visible_child().signal_changed().connect(
        sigc::mem_fun(*this, &ExampleAppWindow::on_visible_child_changed));
    }

    //static
    ExampleAppWindow* ExampleAppWindow::create()
    {
      // Load the Builder file and instantiate its widgets.
      auto refBuilder = Gtk::Builder::create_from_resource("/org/gtkmm/exampleapp/window.ui");

      ExampleAppWindow* window = nullptr;
      Gtk::Builder::get_widget_derived(refBuilder, "app_window", window);
      if (!window)
        throw std::runtime_error("No \"app_window\" object in window.ui");

      return window;
    }

    void ExampleAppWindow::open_file_view(const Glib::RefPtr<Gio::File>& file)
    {
      const auto basename = file->get_basename();

      auto scrolled = Gtk::make_managed<Gtk::ScrolledWindow>();
      scrolled->set_hexpand(true);
      scrolled->set_vexpand(true);
      scrolled->show();
      auto view = Gtk::make_managed<Gtk::TextView>();
      view->set_editable(false);
      view->set_cursor_visible(false);
      view->show();
      scrolled->add(*view);
      m_stack->add(*scrolled, basename, basename);

      auto buffer = view->get_buffer();
      try
      {
        char* contents = nullptr;
        gsize length = 0;

        file->load_contents(contents, length);
        buffer->set_text(contents, contents+length);
        g_free(contents);
      }
      catch (const Glib::Error& ex)
      {
        std::cout << "ExampleAppWindow::open_file_view(\"" << file->get_parse_name()
          << "\"):\n  " << ex.what() << std::endl;
        return;
      }

      auto tag = buffer->create_tag();
      m_settings->bind("font", tag->property_font());
      buffer->apply_tag(tag, buffer->begin(), buffer->end());

      m_search->set_sensitive(true);
    }

    void ExampleAppWindow::on_search_text_changed()
    {
      const auto text = m_searchentry->get_text();
      if (text.empty())
        return;

      auto tab = dynamic_cast<Gtk::ScrolledWindow*>(m_stack->get_visible_child());
      if (!tab)
      {
        std::cout << "ExampleAppWindow::on_search_text_changed(): No visible child." << std::endl;
        return;
      }

      auto view = dynamic_cast<Gtk::TextView*>(tab->get_child());
      if (!view)
      {
        std::cout << "ExampleAppWindow::on_search_text_changed(): No visible text view." << std::endl;
        return;
      }

      // Very simple-minded search implementation.
      auto buffer = view->get_buffer();
      Gtk::TextIter match_start;
      Gtk::TextIter match_end;
      if (buffer->begin().forward_search(text, Gtk::TextSearchFlags::CASE_INSENSITIVE,
          match_start, match_end))
      {
        buffer->select_range(match_start, match_end);
        view->scroll_to(match_start);
      }
    }

    void ExampleAppWindow::on_visible_child_changed()
    {
      m_searchbar->set_search_mode(false);
    }

File: `window.ui` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <interface>
      <object class="GtkApplicationWindow" id="app_window">
        <property name="title" translatable="yes">Example Application</property>
        <property name="default-width">600</property>
        <property name="default-height">400</property>
        <child>
          <object class="GtkBox" id="content_box">
            <property name="orientation">vertical</property>
            <child>
              <object class="GtkHeaderBar" id="header">
                <child type="title">
                  <object class="GtkStackSwitcher" id="tabs">
                    <property name="stack">stack</property>
                  </object>
                </child>
                <child type="end">
                  <object class="GtkToggleButton" id="search">
                    <property name="sensitive">False</property>
                    <property name="icon-name">edit-find-symbolic</property>
                  </object>
                </child>
              </object>
            </child>
            <child>
              <object class="GtkSearchBar" id="searchbar">
                <child>
                  <object class="GtkSearchEntry" id="searchentry">
                  </object>
                </child>
              </object>
            </child>
            <child>
              <object class="GtkStack" id="stack">
                <property name="transition-duration">500</property>
              </object>
            </child>
          </object>
        </child>
      </object>
    </interface>

### Adding a side bar

As another piece of functionality, we are adding a sidebar, which demonstrates Gtk::MenuButton, Gtk::Revealer and Gtk::ListBox. The new widgets are added in the `window.ui` file.

The code to populate the sidebar with buttons for the words found in each file is a little too involved to go into here. But we'll look at the code to add the gears menu. As expected by now, the gears menu is specified in a Gtk::Builder ui file, `gears_menu.ui`

To connect the menu item to the new `show-words` setting, we use a Gio::Action corresponding to the given Gio::Settings key. In ExampleAppWindow's constructor:

    // Connect the menu to the MenuButton m_gears, and bind the show-words setting
    // to the win.show-words action and the "Words" menu item.
    // (The connection between action and menu item is specified in gears_menu.ui.)
    auto menu_builder = Gtk::Builder::create_from_resource("/org/gtkmm/exampleapp/gears_menu.ui");
    auto object = menu_builder->get_object("menu");
    auto menu = Glib::RefPtr<Gio::MenuModel>::cast_dynamic(object);
    m_gears->set_menu_model(menu);
    add_action(m_settings->create_action("show-words"));

What our application looks like now:

Adding a side bar

Source Code

File: `exampleappwindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEAPPWINDOW_H_
    #define GTKMM_EXAMPLEAPPWINDOW_H_

    #include <gtkmm.h>

    class ExampleAppWindow : public Gtk::ApplicationWindow
    {
    public:
      ExampleAppWindow(BaseObjectType* cobject,
        const Glib::RefPtr<Gtk::Builder>& refBuilder);

      static ExampleAppWindow* create();

      void open_file_view(const Glib::RefPtr<Gio::File>& file);

    protected:
      // Signal handlers
      void on_search_text_changed();
      void on_visible_child_changed();
      void on_find_word(const Gtk::Button* button);
      void on_reveal_child_changed();

      void update_words();

      Glib::RefPtr<Gtk::Builder> m_refBuilder;
      Glib::RefPtr<Gio::Settings> m_settings;
      Gtk::Stack* m_stack;
      Gtk::ToggleButton* m_search;
      Gtk::SearchBar* m_searchbar;
      Gtk::SearchEntry* m_searchentry;
      Gtk::MenuButton* m_gears;
      Gtk::Revealer* m_sidebar;
      Gtk::ListBox* m_words;
      Glib::RefPtr<Glib::Binding> m_prop_binding;
    };

    #endif /* GTKMM_EXAMPLEAPPWINDOW_H */

File: `exampleapplication.h` (For use with gtkmm 4)

    #include "../step4/exampleapplication.h"
    // Equal to the corresponding file in step4

File: `exampleappprefs.h` (For use with gtkmm 4)

    #include "../step5/exampleappprefs.h"
    // Equal to the corresponding file in step5

File: `exampleappprefs.cc` (For use with gtkmm 4)

    #include "../step5/exampleappprefs.cc"
    // Equal to the corresponding file in step5

File: `exampleapplication.cc` (For use with gtkmm 4)

    #include "../step5/exampleapplication.cc"
    // Equal to the corresponding file in step5

File: `main.cc` (For use with gtkmm 4)

    #include "../step5/main.cc"
    // Equal to the corresponding file in step5

File: `exampleappwindow.cc` (For use with gtkmm 4)

    #include "exampleappwindow.h"
    #include <iostream>
    #include <stdexcept>
    #include <set>

    ExampleAppWindow::ExampleAppWindow(BaseObjectType* cobject,
      const Glib::RefPtr<Gtk::Builder>& refBuilder)
    : Gtk::ApplicationWindow(cobject),
      m_refBuilder(refBuilder),
      m_settings(),
      m_stack(nullptr),
      m_search(nullptr),
      m_searchbar(nullptr),
      m_searchentry(nullptr),
      m_gears(nullptr),
      m_sidebar(nullptr),
      m_words(nullptr),
      m_prop_binding()
    {
      // Get widgets from the Gtk::Builder file.
      m_refBuilder->get_widget("stack", m_stack);
      if (!m_stack)
        throw std::runtime_error("No \"stack\" object in window.ui");

      m_refBuilder->get_widget("search", m_search);
      if (!m_search)
        throw std::runtime_error("No \"search\" object in window.ui");

      m_refBuilder->get_widget("searchbar", m_searchbar);
      if (!m_searchbar)
        throw std::runtime_error("No \"searchbar\" object in window.ui");

      m_refBuilder->get_widget("searchentry", m_searchentry);
      if (!m_searchentry)
        throw std::runtime_error("No \"searchentry\" object in window.ui");

      m_refBuilder->get_widget("gears", m_gears);
      if (!m_gears)
        throw std::runtime_error("No \"gears\" object in window.ui");

      m_refBuilder->get_widget("sidebar", m_sidebar);
      if (!m_sidebar)
        throw std::runtime_error("No \"sidebar\" object in window.ui");

      m_refBuilder->get_widget("words", m_words);
      if (!m_words)
        throw std::runtime_error("No \"words\" object in window.ui");

      // Bind settings.
      m_settings = Gio::Settings::create("org.gtkmm.exampleapp");
      m_settings->bind("transition", m_stack->property_transition_type());
      m_settings->bind("show-words", m_sidebar->property_reveal_child());

      // Bind properties.
      m_prop_binding = Glib::Binding::bind_property(m_search->property_active(),
        m_searchbar->property_search_mode_enabled(), Glib::Binding::Flags::BIDIRECTIONAL);

      // Connect signal handlers.
      m_searchentry->signal_search_changed().connect(
        sigc::mem_fun(*this, &ExampleAppWindow::on_search_text_changed));
      m_stack->property_visible_child().signal_changed().connect(
        sigc::mem_fun(*this, &ExampleAppWindow::on_visible_child_changed));
      m_sidebar->property_reveal_child().signal_changed().connect(
        sigc::mem_fun(*this, &ExampleAppWindow::on_reveal_child_changed));

      // Connect the menu to the MenuButton m_gears, and bind the show-words setting
      // to the win.show-words action and the "Words" menu item.
      // (The connection between action and menu item is specified in gears_menu.ui.)
      auto menu_builder = Gtk::Builder::create_from_resource("/org/gtkmm/exampleapp/gears_menu.ui");
      auto object = menu_builder->get_object("menu");
      auto menu = std::dynamic_pointer_cast<Gio::MenuModel>(object);
      if (!menu)
        throw std::runtime_error("No \"menu\" object in gears_menu.ui");

      m_gears->set_menu_model(menu);
      add_action(m_settings->create_action("show-words"));
    }

    //static
    ExampleAppWindow* ExampleAppWindow::create()
    {
      // Load the Builder file and instantiate its widgets.
      auto refBuilder = Gtk::Builder::create_from_resource("/org/gtkmm/exampleapp/window.ui");

      ExampleAppWindow* window = nullptr;
      Gtk::Builder::get_widget_derived(refBuilder, "app_window", window);
      if (!window)
        throw std::runtime_error("No \"app_window\" object in window.ui");

      return window;
    }

    void ExampleAppWindow::open_file_view(const Glib::RefPtr<Gio::File>& file)
    {
      const auto basename = file->get_basename();

      auto scrolled = Gtk::make_managed<Gtk::ScrolledWindow>();
      scrolled->set_hexpand(true);
      scrolled->set_vexpand(true);
      scrolled->show();
      auto view = Gtk::make_managed<Gtk::TextView>();
      view->set_editable(false);
      view->set_cursor_visible(false);
      view->show();
      scrolled->add(*view);
      m_stack->add(*scrolled, basename, basename);

      auto buffer = view->get_buffer();
      try
      {
        char* contents = nullptr;
        gsize length = 0;

        file->load_contents(contents, length);
        buffer->set_text(contents, contents+length);
        g_free(contents);
      }
      catch (const Glib::Error& ex)
      {
        std::cout << "ExampleAppWindow::open_file_view(\"" << file->get_parse_name()
          << "\"):\n  " << ex.what() << std::endl;
        return;
      }

      auto tag = buffer->create_tag();
      m_settings->bind("font", tag->property_font());
      buffer->apply_tag(tag, buffer->begin(), buffer->end());

      m_search->set_sensitive(true);
      update_words();
    }

    void ExampleAppWindow::on_search_text_changed()
    {
      const auto text = m_searchentry->get_text();
      if (text.empty())
        return;

      auto tab = dynamic_cast<Gtk::ScrolledWindow*>(m_stack->get_visible_child());
      if (!tab)
      {
        std::cout << "ExampleAppWindow::on_search_text_changed(): No visible child." << std::endl;
        return;
      }

      auto view = dynamic_cast<Gtk::TextView*>(tab->get_child());
      if (!view)
      {
        std::cout << "ExampleAppWindow::on_search_text_changed(): No visible text view." << std::endl;
        return;
      }

      // Very simple-minded search implementation.
      auto buffer = view->get_buffer();
      Gtk::TextIter match_start;
      Gtk::TextIter match_end;
      if (buffer->begin().forward_search(text, Gtk::TextSearchFlags::CASE_INSENSITIVE,
          match_start, match_end))
      {
        buffer->select_range(match_start, match_end);
        view->scroll_to(match_start);
      }
    }

    void ExampleAppWindow::on_visible_child_changed()
    {
      m_searchbar->set_search_mode(false);
      update_words();
    }

    void ExampleAppWindow::on_find_word(const Gtk::Button* button)
    {
      m_searchentry->set_text(button->get_label());
    }

    void ExampleAppWindow::on_reveal_child_changed()
    {
      update_words();
    }

    void ExampleAppWindow::update_words()
    {
      auto tab = dynamic_cast<Gtk::ScrolledWindow*>(m_stack->get_visible_child());
      if (!tab)
        return;

      auto view = dynamic_cast<Gtk::TextView*>(tab->get_child());
      if (!view)
      {
        std::cout << "ExampleAppWindow::update_words(): No visible text view." << std::endl;
        return;
      }
      auto buffer = view->get_buffer();

      // Find all words in the text buffer.
      std::set<Glib::ustring> words;
      auto start = buffer->begin();
      Gtk::TextIter end;
      while (start)
      {
        while (start && !start.starts_word())
          ++start;

        if (!start)
          break;

        end = start;
        end.forward_word_end();
        if (start == end)
          break;

        auto word = buffer->get_text(start, end, false);
        words.insert(word.lowercase());
        start = end;
      }

      // Remove old children from the ListBox.
      auto old_children = m_words->get_children();
      for (auto child : old_children)
      {
        m_words->remove(*child);
        delete child;
      }

      // Add new child buttons, one per unique word.
      for (const auto& word : words)
      {
        auto row = Gtk::make_managed<Gtk::Button>(word);
        row->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,
          &ExampleAppWindow::on_find_word), row));
        row->show();
        m_words->add(*row);
      }
    }

File: `exampleapp.gresource.xml` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <gresources>
      <gresource prefix="/org/gtkmm/exampleapp">
        <file preprocess="xml-stripblanks">window.ui</file>
        <file preprocess="xml-stripblanks">app_menu.ui</file>
        <file preprocess="xml-stripblanks">gears_menu.ui</file>
        <file preprocess="xml-stripblanks">prefs.ui</file>
      </gresource>
    </gresources>

File: `gears_menu.ui` (For use with gtkmm 4)

    <?xml version="1.0"?>
    <interface>
      <!-- interface-requires gtk+ 3.0 -->
      <menu id="menu">
        <section>
          <item>
            <attribute name="label" translatable="yes">_Words</attribute>
            <attribute name="action">win.show-words</attribute>
          </item>
        </section>
      </menu>
    </interface>

File: `window.ui` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <interface>
      <object class="GtkApplicationWindow" id="app_window">
        <property name="title" translatable="yes">Example Application</property>
        <property name="default-width">600</property>
        <property name="default-height">400</property>
        <child>
          <object class="GtkBox" id="content_box">
            <property name="orientation">vertical</property>
            <child>
              <object class="GtkHeaderBar" id="header">
                <child type="title">
                  <object class="GtkStackSwitcher" id="tabs">
                    <property name="stack">stack</property>
                  </object>
                </child>
                <child type="end">
                  <object class="GtkToggleButton" id="search">
                    <property name="sensitive">False</property>
                    <property name="icon-name">edit-find-symbolic</property>
                  </object>
                </child>
                <child type="end">
                  <object class="GtkMenuButton" id="gears">
                    <property name="direction">none</property>
                    <property name="use-popover">True</property>
                    <style>
                      <class name="image-button"/>
                    </style>
                  </object>
                </child>
              </object>
            </child>
            <child>
              <object class="GtkSearchBar" id="searchbar">
                <child>
                  <object class="GtkSearchEntry" id="searchentry">
                  </object>
                </child>
              </object>
            </child>
            <child>
              <object class="GtkBox" id="hbox">
                <child>
                  <object class="GtkRevealer" id="sidebar">
                    <property name="transition-type">slide-right</property>
                    <child>
                     <object class="GtkScrolledWindow" id="sidebar-sw">
                       <property name="hscrollbar-policy">never</property>
                       <property name="vscrollbar-policy">automatic</property>
                       <child>
                         <object class="GtkListBox" id="words">
                           <property name="selection-mode">none</property>
                         </object>
                       </child>
                     </object>
                    </child>
                  </object>
                </child>
                <child>
                  <object class="GtkStack" id="stack">
                    <property name="transition-duration">500</property>
                  </object>
                </child>
              </object>
            </child>
          </object>
        </child>
      </object>
    </interface>

File: `org.gtkmm.exampleapp.gschema.xml` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <schemalist>
      <schema path="/org/gtkmm/exampleapp/" id="org.gtkmm.exampleapp">
        <key name="font" type="s">
          <default>'Monospace 12'</default>
          <summary>Font</summary>
          <description>The font to be used for content.</description>
        </key>
        <key name="transition" type="s">
          <choices>
            <choice value='none'/>
            <choice value='crossfade'/>
            <choice value='slide-left-right'/>
          </choices>
          <default>'none'</default>
          <summary>Transition</summary>
          <description>The transition to use when switching tabs.</description>
        </key>
        <key name="show-words" type="b">
          <default>false</default>
          <summary>Show words</summary>
          <description>Whether to show a word list in the sidebar.</description>
        </key>
      </schema>
    </schemalist>

### Properties

Widgets and other objects have many useful properties. Here we show some ways to use them in new and flexible ways, by wrapping them in actions with Gio::PropertyAction or by binding them with Glib::Binding.

To set this up, we add two labels to the header bar in our `window.ui` file, named `lines_label` and `lines`, and get pointers to them in the application window's constructor, as we've seen a couple of times by now. We add a new "Lines" menu item to the gears menu, which triggers the `show-lines` action.

To make this menu item do something, we create a property action for the `visible` property of the `lines` label, and add it to the actions of the window. The effect of this is that the visibility of the label gets toggled every time the action is activated. Since we want both labels to appear and disappear together, we bind the `visible` property of the `lines_label` widget to the same property of the `lines` widget. In ExampleAppWindow's constructor:

    add_action(Gio::PropertyAction::create("show-lines", m_lines->property_visible()));
    m_binding_lines_visible = Glib::Binding::bind_property(m_lines->property_visible(),
      m_lines_label->property_visible());

We also need a function that counts the lines of the currently active tab, and updates the `lines` label. See the full source if you are interested in the details.

This brings our example application to this appearance:

Properties

Source Code

File: `exampleappwindow.h` (For use with gtkmm 4)

    #ifndef GTKMM_EXAMPLEAPPWINDOW_H_
    #define GTKMM_EXAMPLEAPPWINDOW_H_

    #include <gtkmm.h>

    class ExampleAppWindow : public Gtk::ApplicationWindow
    {
    public:
      ExampleAppWindow(BaseObjectType* cobject,
        const Glib::RefPtr<Gtk::Builder>& refBuilder);

      static ExampleAppWindow* create();

      void open_file_view(const Glib::RefPtr<Gio::File>& file);

    protected:
      // Signal handlers
      void on_search_text_changed();
      void on_visible_child_changed();
      void on_find_word(const Gtk::Button* button);
      void on_reveal_child_changed();

      void update_words();
      void update_lines();

      Glib::RefPtr<Gtk::Builder> m_refBuilder;
      Glib::RefPtr<Gio::Settings> m_settings;
      Gtk::Stack* m_stack;
      Gtk::ToggleButton* m_search;
      Gtk::SearchBar* m_searchbar;
      Gtk::SearchEntry* m_searchentry;
      Gtk::MenuButton* m_gears;
      Gtk::Revealer* m_sidebar;
      Gtk::ListBox* m_words;
      Gtk::Label* m_lines;
      Gtk::Label* m_lines_label;
      Glib::RefPtr<Glib::Binding> m_binding_search_enabled;
      Glib::RefPtr<Glib::Binding> m_binding_lines_visible;
    };

    #endif /* GTKMM_EXAMPLEAPPWINDOW_H */

File: `exampleapplication.h` (For use with gtkmm 4)

    #include "../step4/exampleapplication.h"
    // Equal to the corresponding file in step4

File: `exampleappprefs.h` (For use with gtkmm 4)

    #include "../step5/exampleappprefs.h"
    // Equal to the corresponding file in step5

File: `exampleappprefs.cc` (For use with gtkmm 4)

    #include "../step5/exampleappprefs.cc"
    // Equal to the corresponding file in step5

File: `exampleapplication.cc` (For use with gtkmm 4)

    #include "../step5/exampleapplication.cc"
    // Equal to the corresponding file in step5

File: `main.cc` (For use with gtkmm 4)

    #include "../step5/main.cc"
    // Equal to the corresponding file in step5

File: `exampleappwindow.cc` (For use with gtkmm 4)

    #include "exampleappwindow.h"
    #include <iostream>
    #include <stdexcept>
    #include <set>

    ExampleAppWindow::ExampleAppWindow(BaseObjectType* cobject,
      const Glib::RefPtr<Gtk::Builder>& refBuilder)
    : Gtk::ApplicationWindow(cobject),
      m_refBuilder(refBuilder),
      m_settings(),
      m_stack(nullptr),
      m_search(nullptr),
      m_searchbar(nullptr),
      m_searchentry(nullptr),
      m_gears(nullptr),
      m_sidebar(nullptr),
      m_words(nullptr),
      m_lines(nullptr),
      m_lines_label(nullptr),
      m_binding_search_enabled(),
      m_binding_lines_visible()
    {
      // Get widgets from the Gtk::Builder file.
      m_refBuilder->get_widget("stack", m_stack);
      if (!m_stack)
        throw std::runtime_error("No \"stack\" object in window.ui");

      m_refBuilder->get_widget("search", m_search);
      if (!m_search)
        throw std::runtime_error("No \"search\" object in window.ui");

      m_refBuilder->get_widget("searchbar", m_searchbar);
      if (!m_searchbar)
        throw std::runtime_error("No \"searchbar\" object in window.ui");

      m_refBuilder->get_widget("searchentry", m_searchentry);
      if (!m_searchentry)
        throw std::runtime_error("No \"searchentry\" object in window.ui");

      m_refBuilder->get_widget("gears", m_gears);
      if (!m_gears)
        throw std::runtime_error("No \"gears\" object in window.ui");

      m_refBuilder->get_widget("sidebar", m_sidebar);
      if (!m_sidebar)
        throw std::runtime_error("No \"sidebar\" object in window.ui");

      m_refBuilder->get_widget("words", m_words);
      if (!m_words)
        throw std::runtime_error("No \"words\" object in window.ui");

      m_refBuilder->get_widget("lines", m_lines);
      if (!m_lines)
        throw std::runtime_error("No \"lines\" object in window.ui");

      m_refBuilder->get_widget("lines_label", m_lines_label);
      if (!m_lines_label)
        throw std::runtime_error("No \"lines_label\" object in window.ui");

      // Bind settings.
      m_settings = Gio::Settings::create("org.gtkmm.exampleapp");
      m_settings->bind("transition", m_stack->property_transition_type());
      m_settings->bind("show-words", m_sidebar->property_reveal_child());

      // Bind properties of the search button to the search bar.
      m_binding_search_enabled = Glib::Binding::bind_property(m_search->property_active(),
        m_searchbar->property_search_mode_enabled(), Glib::Binding::Flags::BIDIRECTIONAL);

      // Connect signal handlers.
      m_searchentry->signal_search_changed().connect(
        sigc::mem_fun(*this, &ExampleAppWindow::on_search_text_changed));
      m_stack->property_visible_child().signal_changed().connect(
        sigc::mem_fun(*this, &ExampleAppWindow::on_visible_child_changed));
      m_sidebar->property_reveal_child().signal_changed().connect(
        sigc::mem_fun(*this, &ExampleAppWindow::on_reveal_child_changed));

      // Connect the menu to the MenuButton m_gears, and bind the show-words setting
      // to the win.show-words action and the "Words" menu item.
      // (The connection between action and menu item is specified in gears_menu.ui.)
      auto menu_builder = Gtk::Builder::create_from_resource("/org/gtkmm/exampleapp/gears_menu.ui");
      auto object = menu_builder->get_object("menu");
      auto menu = std::dynamic_pointer_cast<Gio::MenuModel>(object);
      if (!menu)
        throw std::runtime_error("No \"menu\" object in gears_menu.ui");

      m_gears->set_menu_model(menu);
      add_action(m_settings->create_action("show-words"));

      // Bind the "visible" property of m_lines to the win.show-lines action, to
      // the "Lines" menu item and to the "visible" property of m_lines_label.
      add_action(Gio::PropertyAction::create("show-lines", m_lines->property_visible()));
      m_binding_lines_visible = Glib::Binding::bind_property(m_lines->property_visible(),
        m_lines_label->property_visible());
    }

    //static
    ExampleAppWindow* ExampleAppWindow::create()
    {
      // Load the Builder file and instantiate its widgets.
      auto refBuilder = Gtk::Builder::create_from_resource("/org/gtkmm/exampleapp/window.ui");

      ExampleAppWindow* window = nullptr;
      Gtk::Builder::get_widget_derived(refBuilder, "app_window", window);
      if (!window)
        throw std::runtime_error("No \"app_window\" object in window.ui");

      return window;
    }

    void ExampleAppWindow::open_file_view(const Glib::RefPtr<Gio::File>& file)
    {
      const auto basename = file->get_basename();

      auto scrolled = Gtk::make_managed<Gtk::ScrolledWindow>();
      scrolled->set_hexpand(true);
      scrolled->set_vexpand(true);
      scrolled->show();
      auto view = Gtk::make_managed<Gtk::TextView>();
      view->set_editable(false);
      view->set_cursor_visible(false);
      view->show();
      scrolled->add(*view);
      m_stack->add(*scrolled, basename, basename);

      auto buffer = view->get_buffer();
      try
      {
        char* contents = nullptr;
        gsize length = 0;

        file->load_contents(contents, length);
        buffer->set_text(contents, contents+length);
        g_free(contents);
      }
      catch (const Glib::Error& ex)
      {
        std::cout << "ExampleAppWindow::open_file_view(\"" << file->get_parse_name()
          << "\"):\n  " << ex.what() << std::endl;
        return;
      }

      auto tag = buffer->create_tag();
      m_settings->bind("font", tag->property_font());
      buffer->apply_tag(tag, buffer->begin(), buffer->end());

      m_search->set_sensitive(true);
      update_words();
      update_lines();
    }

    void ExampleAppWindow::on_search_text_changed()
    {
      const auto text = m_searchentry->get_text();
      if (text.empty())
        return;

      auto tab = dynamic_cast<Gtk::ScrolledWindow*>(m_stack->get_visible_child());
      if (!tab)
      {
        std::cout << "ExampleAppWindow::on_search_text_changed(): No visible child." << std::endl;
        return;
      }

      auto view = dynamic_cast<Gtk::TextView*>(tab->get_child());
      if (!view)
      {
        std::cout << "ExampleAppWindow::on_search_text_changed(): No visible text view." << std::endl;
        return;
      }

      // Very simple-minded search implementation.
      auto buffer = view->get_buffer();
      Gtk::TextIter match_start;
      Gtk::TextIter match_end;
      if (buffer->begin().forward_search(text, Gtk::TextSearchFlags::CASE_INSENSITIVE,
          match_start, match_end))
      {
        buffer->select_range(match_start, match_end);
        view->scroll_to(match_start);
      }
    }

    void ExampleAppWindow::on_visible_child_changed()
    {
      m_searchbar->set_search_mode(false);
      update_words();
      update_lines();
    }

    void ExampleAppWindow::on_find_word(const Gtk::Button* button)
    {
      m_searchentry->set_text(button->get_label());
    }

    void ExampleAppWindow::on_reveal_child_changed()
    {
      update_words();
    }

    void ExampleAppWindow::update_words()
    {
      auto tab = dynamic_cast<Gtk::ScrolledWindow*>(m_stack->get_visible_child());
      if (!tab)
        return;

      auto view = dynamic_cast<Gtk::TextView*>(tab->get_child());
      if (!view)
      {
        std::cout << "ExampleAppWindow::update_words(): No visible text view." << std::endl;
        return;
      }
      auto buffer = view->get_buffer();

      // Find all words in the text buffer.
      std::set<Glib::ustring> words;
      auto start = buffer->begin();
      Gtk::TextIter end;
      while (start)
      {
        while (start && !start.starts_word())
          ++start;

        if (!start)
          break;

        end = start;
        end.forward_word_end();
        if (start == end)
          break;

        auto word = buffer->get_text(start, end, false);
        words.insert(word.lowercase());
        start = end;
      }

      // Remove old children from the ListBox.
      auto old_children = m_words->get_children();
      for (auto child : old_children)
      {
        m_words->remove(*child);
        delete child;
      }

      // Add new child buttons, one per unique word.
      for (const auto& word : words)
      {
        auto row = Gtk::make_managed<Gtk::Button>(word);
        row->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,
          &ExampleAppWindow::on_find_word), row));
        row->show();
        m_words->add(*row);
      }
    }

    void ExampleAppWindow::update_lines()
    {
      auto tab = dynamic_cast<Gtk::ScrolledWindow*>(m_stack->get_visible_child());
      if (!tab)
        return;

      auto view = dynamic_cast<Gtk::TextView*>(tab->get_child());
      if (!view)
      {
        std::cout << "ExampleAppWindow::update_lines(): No visible text view." << std::endl;
        return;
      }
      auto buffer = view->get_buffer();

      int count = 0;
      auto iter = buffer->begin();
      while (iter)
      {
        ++count;
        if (!iter.forward_line())
          break;
      }
      m_lines->set_text(Glib::ustring::format(count));
    }

File: `gears_menu.ui` (For use with gtkmm 4)

    <?xml version="1.0"?>
    <interface>
      <!-- interface-requires gtk+ 3.0 -->
      <menu id="menu">
        <section>
          <item>
            <attribute name="label" translatable="yes">_Words</attribute>
            <attribute name="action">win.show-words</attribute>
          </item>
          <item>
            <attribute name="label" translatable="yes">_Lines</attribute>
            <attribute name="action">win.show-lines</attribute>
          </item>
        </section>
      </menu>
    </interface>

File: `window.ui` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <interface>
      <object class="GtkApplicationWindow" id="app_window">
        <property name="title" translatable="yes">Example Application</property>
        <property name="default-width">600</property>
        <property name="default-height">400</property>
        <child>
          <object class="GtkBox" id="content_box">
            <property name="orientation">vertical</property>
            <child>
              <object class="GtkHeaderBar" id="header">
                <child>
                  <object class="GtkLabel" id="lines_label">
                    <property name="visible">False</property>
                    <property name="label" translatable="yes">Lines:</property>
                  </object>
                </child>
                <child>
                  <object class="GtkLabel" id="lines">
                    <property name="visible">False</property>
                  </object>
                </child>
                <child type="title">
                  <object class="GtkStackSwitcher" id="tabs">
                    <property name="stack">stack</property>
                  </object>
                </child>
                <child type="end">
                  <object class="GtkToggleButton" id="search">
                    <property name="sensitive">False</property>
                    <property name="icon-name">edit-find-symbolic</property>
                  </object>
                </child>
                <child type="end">
                  <object class="GtkMenuButton" id="gears">
                    <property name="direction">none</property>
                    <property name="use-popover">True</property>
                    <style>
                      <class name="image-button"/>
                    </style>
                  </object>
                </child>
              </object>
            </child>
            <child>
              <object class="GtkSearchBar" id="searchbar">
                <child>
                  <object class="GtkSearchEntry" id="searchentry">
                  </object>
                </child>
              </object>
            </child>
            <child>
              <object class="GtkBox" id="hbox">
                <child>
                  <object class="GtkRevealer" id="sidebar">
                    <property name="transition-type">slide-right</property>
                    <child>
                     <object class="GtkScrolledWindow" id="sidebar-sw">
                       <property name="hscrollbar-policy">never</property>
                       <property name="vscrollbar-policy">automatic</property>
                       <child>
                         <object class="GtkListBox" id="words">
                           <property name="selection-mode">none</property>
                         </object>
                       </child>
                     </object>
                    </child>
                  </object>
                </child>
                <child>
                  <object class="GtkStack" id="stack">
                    <property name="transition-duration">500</property>
                  </object>
                </child>
              </object>
            </child>
          </object>
        </child>
      </object>
    </interface>

### Header bar

Our application already uses a Gtk::HeaderBar, but so far it still gets a 'normal' window titlebar on top of that. This is a bit redundant, and we will now tell gtkmm to use the header bar as replacement for the titlebar. To do so, we move it around to be a direct child of the window, and set its type to be `titlebar`. This is done in the `window.ui` file.

A small extra bonus of using a header bar is that we get a fallback application menu button for free. We include an icon in the resource file, and set up this icon as the window icon. Then it is displayed in the menu button.

Here is how the application now looks, if the fallback menu is used:

Header bar

The `window.ui` file sets a header bar title, but this title is not shown. That's because the stack switcher is a child of type `title`. The stack switcher becomes a custom title that hides the title label, as if it had been set with Gtk::HeaderBar::set_custom_title().

Source Code

File: `exampleappwindow.h` (For use with gtkmm 4)

    #include "../step8/exampleappwindow.h"
    // Equal to the corresponding file in step8

File: `exampleapplication.h` (For use with gtkmm 4)

    #include "../step4/exampleapplication.h"
    // Equal to the corresponding file in step4

File: `exampleappprefs.h` (For use with gtkmm 4)

    #include "../step5/exampleappprefs.h"
    // Equal to the corresponding file in step5

File: `exampleappprefs.cc` (For use with gtkmm 4)

    #include "../step5/exampleappprefs.cc"
    // Equal to the corresponding file in step5

File: `exampleapplication.cc` (For use with gtkmm 4)

    #include "../step5/exampleapplication.cc"
    // Equal to the corresponding file in step5

File: `main.cc` (For use with gtkmm 4)

    #include "../step5/main.cc"
    // Equal to the corresponding file in step5

File: `exampleappwindow.cc` (For use with gtkmm 4)

    #include "exampleappwindow.h"
    #include <iostream>
    #include <stdexcept>
    #include <set>

    ExampleAppWindow::ExampleAppWindow(BaseObjectType* cobject,
      const Glib::RefPtr<Gtk::Builder>& refBuilder)
    : Gtk::ApplicationWindow(cobject),
      m_refBuilder(refBuilder),
      m_settings(),
      m_stack(nullptr),
      m_search(nullptr),
      m_searchbar(nullptr),
      m_searchentry(nullptr),
      m_gears(nullptr),
      m_sidebar(nullptr),
      m_words(nullptr),
      m_lines(nullptr),
      m_lines_label(nullptr),
      m_binding_search_enabled(),
      m_binding_lines_visible()
    {
      // Get widgets from the Gtk::Builder file.
      m_refBuilder->get_widget("stack", m_stack);
      if (!m_stack)
        throw std::runtime_error("No \"stack\" object in window.ui");

      m_refBuilder->get_widget("search", m_search);
      if (!m_search)
        throw std::runtime_error("No \"search\" object in window.ui");

      m_refBuilder->get_widget("searchbar", m_searchbar);
      if (!m_searchbar)
        throw std::runtime_error("No \"searchbar\" object in window.ui");

      m_refBuilder->get_widget("searchentry", m_searchentry);
      if (!m_searchentry)
        throw std::runtime_error("No \"searchentry\" object in window.ui");

      m_refBuilder->get_widget("gears", m_gears);
      if (!m_gears)
        throw std::runtime_error("No \"gears\" object in window.ui");

      m_refBuilder->get_widget("sidebar", m_sidebar);
      if (!m_sidebar)
        throw std::runtime_error("No \"sidebar\" object in window.ui");

      m_refBuilder->get_widget("words", m_words);
      if (!m_words)
        throw std::runtime_error("No \"words\" object in window.ui");

      m_refBuilder->get_widget("lines", m_lines);
      if (!m_lines)
        throw std::runtime_error("No \"lines\" object in window.ui");

      m_refBuilder->get_widget("lines_label", m_lines_label);
      if (!m_lines_label)
        throw std::runtime_error("No \"lines_label\" object in window.ui");

      // Bind settings.
      m_settings = Gio::Settings::create("org.gtkmm.exampleapp");
      m_settings->bind("transition", m_stack->property_transition_type());
      m_settings->bind("show-words", m_sidebar->property_reveal_child());

      // Bind properties of the search button to the search bar.
      m_binding_search_enabled = Glib::Binding::bind_property(m_search->property_active(),
        m_searchbar->property_search_mode_enabled(), Glib::Binding::Flags::BIDIRECTIONAL);

      // Connect signal handlers.
      m_searchentry->signal_search_changed().connect(
        sigc::mem_fun(*this, &ExampleAppWindow::on_search_text_changed));
      m_stack->property_visible_child().signal_changed().connect(
        sigc::mem_fun(*this, &ExampleAppWindow::on_visible_child_changed));
      m_sidebar->property_reveal_child().signal_changed().connect(
        sigc::mem_fun(*this, &ExampleAppWindow::on_reveal_child_changed));

      // Connect the menu to the MenuButton m_gears, and bind the show-words setting
      // to the win.show-words action and the "Words" menu item.
      // (The connection between action and menu item is specified in gears_menu.ui.)
      auto menu_builder = Gtk::Builder::create_from_resource("/org/gtkmm/exampleapp/gears_menu.ui");
      auto object = menu_builder->get_object("menu");
      auto menu = std::dynamic_pointer_cast<Gio::MenuModel>(object);
      if (!menu)
        throw std::runtime_error("No \"menu\" object in gears_menu.ui");

      m_gears->set_menu_model(menu);
      add_action(m_settings->create_action("show-words"));

      // Bind the "visible" property of m_lines to the win.show-lines action, to
      // the "Lines" menu item and to the "visible" property of m_lines_label.
      add_action(Gio::PropertyAction::create("show-lines", m_lines->property_visible()));
      m_binding_lines_visible = Glib::Binding::bind_property(m_lines->property_visible(),
        m_lines_label->property_visible());

      // Display the application menu in the application, not in the desktop environment.
      auto gtk_settings = Gtk::Settings::get_default();
      if (gtk_settings)
        gtk_settings->property_gtk_shell_shows_app_menu() = false;
      set_show_menubar(true);

      // Set the window icon.
      Gtk::IconTheme::get_default()->add_resource_path("/org/gtkmm/exampleapp");
      set_icon_name("exampleapp");
    }

    //static
    ExampleAppWindow* ExampleAppWindow::create()
    {
      // Load the Builder file and instantiate its widgets.
      auto refBuilder = Gtk::Builder::create_from_resource("/org/gtkmm/exampleapp/window.ui");

      ExampleAppWindow* window = nullptr;
      Gtk::Builder::get_widget_derived(refBuilder, "app_window", window);
      if (!window)
        throw std::runtime_error("No \"app_window\" object in window.ui");

      return window;
    }

    void ExampleAppWindow::open_file_view(const Glib::RefPtr<Gio::File>& file)
    {
      const auto basename = file->get_basename();

      auto scrolled = Gtk::make_managed<Gtk::ScrolledWindow>();
      scrolled->set_hexpand(true);
      scrolled->set_vexpand(true);
      scrolled->show();
      auto view = Gtk::make_managed<Gtk::TextView>();
      view->set_editable(false);
      view->set_cursor_visible(false);
      view->show();
      scrolled->add(*view);
      m_stack->add(*scrolled, basename, basename);

      auto buffer = view->get_buffer();
      try
      {
        char* contents = nullptr;
        gsize length = 0;

        file->load_contents(contents, length);
        buffer->set_text(contents, contents+length);
        g_free(contents);
      }
      catch (const Glib::Error& ex)
      {
        std::cout << "ExampleAppWindow::open_file_view(\"" << file->get_parse_name()
          << "\"):\n  " << ex.what() << std::endl;
        return;
      }

      auto tag = buffer->create_tag();
      m_settings->bind("font", tag->property_font());
      buffer->apply_tag(tag, buffer->begin(), buffer->end());

      m_search->set_sensitive(true);
      update_words();
      update_lines();
    }

    void ExampleAppWindow::on_search_text_changed()
    {
      const auto text = m_searchentry->get_text();
      if (text.empty())
        return;

      auto tab = dynamic_cast<Gtk::ScrolledWindow*>(m_stack->get_visible_child());
      if (!tab)
      {
        std::cout << "ExampleAppWindow::on_search_text_changed(): No visible child." << std::endl;
        return;
      }

      auto view = dynamic_cast<Gtk::TextView*>(tab->get_child());
      if (!view)
      {
        std::cout << "ExampleAppWindow::on_search_text_changed(): No visible text view." << std::endl;
        return;
      }

      // Very simple-minded search implementation.
      auto buffer = view->get_buffer();
      Gtk::TextIter match_start;
      Gtk::TextIter match_end;
      if (buffer->begin().forward_search(text, Gtk::TextSearchFlags::CASE_INSENSITIVE,
          match_start, match_end))
      {
        buffer->select_range(match_start, match_end);
        view->scroll_to(match_start);
      }
    }

    void ExampleAppWindow::on_visible_child_changed()
    {
      m_searchbar->set_search_mode(false);
      update_words();
      update_lines();
    }

    void ExampleAppWindow::on_find_word(const Gtk::Button* button)
    {
      m_searchentry->set_text(button->get_label());
    }

    void ExampleAppWindow::on_reveal_child_changed()
    {
      update_words();
    }

    void ExampleAppWindow::update_words()
    {
      auto tab = dynamic_cast<Gtk::ScrolledWindow*>(m_stack->get_visible_child());
      if (!tab)
        return;

      auto view = dynamic_cast<Gtk::TextView*>(tab->get_child());
      if (!view)
      {
        std::cout << "ExampleAppWindow::update_words(): No visible text view." << std::endl;
        return;
      }
      auto buffer = view->get_buffer();

      // Find all words in the text buffer.
      std::set<Glib::ustring> words;
      auto start = buffer->begin();
      Gtk::TextIter end;
      while (start)
      {
        while (start && !start.starts_word())
          ++start;

        if (!start)
          break;

        end = start;
        end.forward_word_end();
        if (start == end)
          break;

        auto word = buffer->get_text(start, end, false);
        words.insert(word.lowercase());
        start = end;
      }

      // Remove old children from the ListBox.
      auto old_children = m_words->get_children();
      for (auto child : old_children)
      {
        m_words->remove(*child);
        delete child;
      }

      // Add new child buttons, one per unique word.
      for (const auto& word : words)
      {
        auto row = Gtk::make_managed<Gtk::Button>(word);
        row->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,
          &ExampleAppWindow::on_find_word), row));
        row->show();
        m_words->add(*row);
      }
    }

    void ExampleAppWindow::update_lines()
    {
      auto tab = dynamic_cast<Gtk::ScrolledWindow*>(m_stack->get_visible_child());
      if (!tab)
        return;

      auto view = dynamic_cast<Gtk::TextView*>(tab->get_child());
      if (!view)
      {
        std::cout << "ExampleAppWindow::update_lines(): No visible text view." << std::endl;
        return;
      }
      auto buffer = view->get_buffer();

      int count = 0;
      auto iter = buffer->begin();
      while (iter)
      {
        ++count;
        if (!iter.forward_line())
          break;
      }
      m_lines->set_text(Glib::ustring::format(count));
    }

File: `exampleapp.gresource.xml` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <gresources>
      <gresource prefix="/org/gtkmm/exampleapp">
        <file preprocess="xml-stripblanks">window.ui</file>
        <file preprocess="xml-stripblanks">app_menu.ui</file>
        <file preprocess="xml-stripblanks">gears_menu.ui</file>
        <file preprocess="xml-stripblanks">prefs.ui</file>
        <file>exampleapp.png</file>
      </gresource>
    </gresources>

File: `window.ui` (For use with gtkmm 4)

    <?xml version="1.0" encoding="UTF-8"?>
    <interface>
      <object class="GtkApplicationWindow" id="app_window">
        <property name="default-width">600</property>
        <property name="default-height">400</property>
        <child type="titlebar">
          <object class="GtkHeaderBar" id="header">
            <property name="title" translatable="yes">Example Application</property>
            <property name="show-title-buttons">True</property>
            <property name="decoration-layout">menu:close</property>
            <child>
              <object class="GtkLabel" id="lines_label">
                <property name="visible">False</property>
                <property name="label" translatable="yes">Lines:</property>
              </object>
            </child>
            <child>
              <object class="GtkLabel" id="lines">
                <property name="visible">False</property>
              </object>
            </child>
            <child type="title">
              <object class="GtkStackSwitcher" id="tabs">
                <property name="stack">stack</property>
              </object>
            </child>
            <child type="end">
              <object class="GtkToggleButton" id="search">
                <property name="sensitive">False</property>
                <property name="icon-name">edit-find-symbolic</property>
              </object>
            </child>
            <child type="end">
              <object class="GtkMenuButton" id="gears">
                <property name="direction">none</property>
                <property name="use-popover">True</property>
                <style>
                  <class name="image-button"/>
                </style>
              </object>
            </child>
          </object>
        </child>
        <child>
          <object class="GtkBox" id="content_box">
            <property name="orientation">vertical</property>
            <child>
              <object class="GtkSearchBar" id="searchbar">
                <child>
                  <object class="GtkSearchEntry" id="searchentry">
                  </object>
                </child>
              </object>
            </child>
            <child>
              <object class="GtkBox" id="hbox">
                <child>
                  <object class="GtkRevealer" id="sidebar">
                    <property name="transition-type">slide-right</property>
                    <child>
                      <object class="GtkScrolledWindow" id="sidebar-sw">
                        <property name="hscrollbar-policy">never</property>
                        <property name="vscrollbar-policy">automatic</property>
                        <child>
                          <object class="GtkListBox" id="words">
                            <property name="selection-mode">none</property>
                          </object>
                        </child>
                      </object>
                    </child>
                  </object>
                </child>
                <child>
                  <object class="GtkStack" id="stack">
                    <property name="transition-duration">500</property>
                  </object>
                </child>
              </object>
            </child>
          </object>
        </child>
      </object>
    </interface>

## 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.

Ideally, we would like you to provide a patch to the `docs/tutorial/C/index-in.docbook` file. This file is currently in the `gtkmm-documentation` module in GNOME git.

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 is a smartpointer. Specifically, it is a reference-counting smartpointer. You might be familiar with std::unique_ptr<> and std::shared_ptr<>, which are also smartpointers. In gtkmm-4.0 Glib::RefPtr<> is an alias for std::shared_ptr<>, which is reference-counting. Glib::RefPtr<> was introduced long before there was a reference-counting smartpointer in the C++ Standard Library.

Reference

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.

    auto refPixbuf = Gdk::Pixbuf::create_from_file(filename);
    auto 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;
    auto 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.

    auto refPixbuf = Gdk::Pixbuf::create_from_file(filename);
    auto width = refPixbuf->get_width();

You can also use the * operator and the get() method to access the underlying instance, but it's usually a bad idea to do so. Unless you are careful, you can end up with a pointer or a reference which is not included in the reference count.

    auto refPixbuf = Gdk::Pixbuf::create_from_file(filename);
    auto& underlying = *refPixbuf; // Possible, but not recommended

### Forçage de type

You can cast RefPtrs to base types, just like normal pointers.

    auto refStore = Gtk::TreeStore::create(columns);
    Glib::RefPtr<Gtk::TreeModel> refModel = refStore;

This means that any method which takes a const Glib::RefPtr<BaseType>& argument can also take a const Glib::RefPtr<DerivedType>&. The cast is implicit, just as it would be for a normal pointer.

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.

    auto refStore = std::dynamic_pointer_cast<Gtk::TreeStore>(refModel);
    auto refStore2 = std::static_pointer_cast<Gtk::TreeStore>(refModel);

### Checking for nullptr

Comme pour les pointeurs normaux, vous pouvez vérifier si un pointeur RefPtr ne pointe sur rien.

    auto refModel = m_TreeView.get_model();
    if (refModel)
    {
      auto cols_count = refModel->get_n_columns();
      ...
    }

But unlike normal pointers, RefPtrs are automatically initialized to `nullptr` so you don't need to remember to do that yourself.

### Constance

The use of the `const` keyword in C++ is not always clear. You might not realise that const Something* declares a pointer to a const Something. The pointer can be changed, but not the Something that it points to.

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;
    }

    int 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;

    int 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::SignalProxy<bool(Gtk::DirectionType)> signal_focus()

Other than the signal's name (`focus`), the template arguments are important to note here. The first argument, bool, is the type that the signal handler should return; and the type within parentheses, Gtk::DirectionType, is the type of this signal's first, and only, argument. By looking at the reference documentation, you can see the names of the arguments too.

The same principles apply for signals which have more arguments. Here's one with three (taken from `<gtkmm/textbuffer.h>`):

    Glib::SignalProxy<void(TextBuffer::iterator&, const Glib::ustrin&, int)> signal_insert();

It follows the same form. The first type is void, so that should be our signal handler's return type. The following three types are the argument types, in order. Our signal handler's prototype could look like this:

    void on_insert(TextBuffer::iterator& pos, const Glib::ustring& text, int bytes)

### Déconnexion des gestionnaires de signal

Examinons à nouveau la fonction membre `connect` d'un signal :

    sigc::connection signal<void(int)>::connect(const sigc::slot<void(int)>&);

The returned sigc::connection can be used to control the connection. By keeping a connection object you can disconnect its associated signal handler using the sigc::connection::disconnect() method.

### 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:
      void on_clicked() override;
    }

    void OverriddenButton::on_clicked()
    {
      std::cout << "Hello World" << std::endl;

      // call the base class's version of the method:
      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.

You don't always need to call the parent's method; there are times when you might not want to. Note that we called the parent method after writing "Hello World", but we could have called it before. In this simple example, it hardly matters much, but there are times when it will. With connected signal handlers, it's not quite so easy to change details like this, and you can do something here which you can't do at all with connected signal handlers: you can call the parent method in the middle of your custom code.

### Liaison avec des paramètres supplémentaires

If you use one signal handler to catch the same signal from several widgets, you might like that signal handler to receive some extra information. For instance, you might want to know which button was clicked. You can do this with `sigc::bind()`. Here's some code from the helloworld2 example.

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

This says that we want the signal to send an extra Glib::ustring argument to the signal handler, and that the value of that argument should be "button 1". Of course we will need to add that extra argument to the declaration of our signal handler:

    void on_button_clicked(const Glib::ustring& data);

Of course, a normal "clicked" signal handler would have no arguments.

`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

The Widget class has some special signals which correspond to the underlying X-Windows events. These are suffixed by `_event`; for instance, Widget::signal_button_press_event().

You might occasionally find it useful to handle X events when there's something you can't accomplish with normal signals. Gtk::Button, for example, does not send mouse-pointer coordinates with its `clicked` signal, but you could handle `button_press_event` if you needed this information. X events are also often used to handle key-presses.

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é.

Handling an X event doesn't affect the Widget's other signals. If you handle `button_press_event` for Gtk::Button, you'll still be able to get the `clicked` signal. They are emitted at (nearly) the same time.

Here's a simple example:

    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.

### Exceptions in signal handlers

When a program is aborted because of an unhandled C++ exception, it's sometimes possible to use a debugger to find the location where the exception was thrown. This is more difficult than usual if the exception was thrown from a signal handler.

This section describes primarily what you can expect on a Linux system, when you use the gdb debugger.

First, let's look at a simple example where an exception is thrown from a normal function (no signal handler).

    // without_signal.cc
    #include <gtkmm.h>

    bool throwSomething()
    {
      throw "Something";
      return true;
    }

    int main(int argc, char** argv)
    {
      throwSomething();
      auto app = Gtk::Application::create("org.gtkmm.without_signal");
      return app->run();
    }

Here is an excerpt from a gdb session. Only the most interesting parts of the output are shown.

    > gdb without_signal
    (gdb) run
    terminate called after throwing an instance of 'char const*'

    Program received signal SIGABRT, Aborted.
    (gdb) backtrace
    #7  0x08048864 in throwSomething () at without_signal.cc:6
    #8  0x0804887d in main (argc=1, argv=0xbfffecd4) at without_signal.cc:12

You can see that the exception was thrown from `without_signal.cc`, line 6 (`throw "Something";`).

Now let's see what happens when an exception is thrown from a signal handler. Here's the source code.

    // with_signal.cc
    #include <gtkmm.h>

    bool throwSomething()
    {
      throw "Something";
      return true;
    }

    int main(int argc, char** argv)
    {
      Glib::signal_timeout().connect(sigc::ptr_fun(throwSomething), 500);
      auto app = Gtk::Application::create("org.gtkmm.with_signal");
      app->hold();
      return app->run();
    }

And here's an excerpt from a gdb session.

    > gdb with_signal
    (gdb) run
    (with_signal:2703): glibmm-ERROR **:
    unhandled exception (type unknown) in signal handler

    Program received signal SIGTRAP, Trace/breakpoint trap.
    (gdb) backtrace
    #2  0x0063c6ab in glibmm_unexpected_exception () at exceptionhandler.cc:77
    #3  Glib::exception_handlers_invoke () at exceptionhandler.cc:150
    #4  0x0063d370 in glibmm_source_callback (data=0x804d620) at main.cc:212
    #13 0x002e1b31 in Gtk::Application::run (this=0x804f300) at application.cc:178
    #14 0x08048ccc in main (argc=1, argv=0xbfffecd4) at with_signal.cc:16

The exception is caught in glibmm, and the program ends with a call to `g_error()`. Other exceptions may result in different behaviour, but in any case the exception from a signal handler is caught in glibmm or gtkmm, and gdb can't see where it was thrown.

To see where the exception is thrown, you can use the gdb command `catch throw`.

    > gdb with_signal
    (gdb) catch throw
    Catchpoint 1 (throw)
    (gdb) run
    Catchpoint 1 (exception thrown), 0x00714ff0 in __cxa_throw ()
    (gdb) backtrace
    #0  0x00714ff0 in __cxa_throw () from /usr/lib/i386-linux-gnu/libstdc++.so.6
    #1  0x08048bd4 in throwSomething () at with_signal.cc:6
    (gdb) continue
    Continuing.
    (with_signal:2375): glibmm-ERROR **
    unhandled exception (type unknown) in signal handler

    Program received signal SIGTRAP, Trace/breakpoint trap.

If there are many caught exceptions before the interesting uncaught one, this method can be tedious. It can be automated with the following gdb commands.

    (gdb) catch throw
    (gdb) commands
    (gdb)   backtrace
    (gdb)   continue
    (gdb)   end
    (gdb) set pagination off
    (gdb) run

These commands will print a backtrace from each `throw` and continue. The backtrace from the last (or possibly the last but one) `throw` before the program stops, is the interesting one.

## 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<>.

For instance, to create a signal that sends 2 parameters, a bool and an int, just declare a sigc::signal, like so:

    sigc::signal<void(bool, int)> signal_something;

You could just declare that signal as a public member variable, but some people find that distasteful and prefer to make it available via an accessor method, like so:

    class Server
    {
    public:
      //signal accessor:
      using type_signal_something = sigc::signal<void(bool, int)>;
      type_signal_something signal_something();

    protected:
      type_signal_something m_signal_something;
    };

    Server::type_signal_something Server::signal_something()
    {
      return m_signal_something;
    }

You can then connect to the signal using the same syntax used when connecting to gtkmm signals. For instance,

    server.signal_something().connect(
      sigc::mem_fun(client, &Client::on_server_something) );

### Exemple

This is a full working example that defines and uses custom signals.

Source Code

File: `server.h` (For use with gtkmm 4)

    #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:
      using type_signal_something = sigc::signal<void(bool, int)>;
      type_signal_something signal_something();

    protected:
      type_signal_something m_signal_something;
    };

    #endif //GTKMM_EXAMPLE_SERVER_H

File: `client.h` (For use with gtkmm 4)

    #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: `main.cc` (For use with gtkmm 4)

    #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: `server.cc` (For use with gtkmm 4)

    #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: `client.cc` (For use with gtkmm 4)

    #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 currently works with the MingW/GCC compiler with a compiler version that supports C++14, such as gcc 6.2. It also works with Microsoft Visual C++ 2017 or later (including the freely available express editions) on the Windows platform. There is an installer available for gtkmm on Microsoft Windows, but as of this writing (February 2017) it has not been updated for a long time.

Refer to https://wiki.gnome.org/Projects/gtkmm/MSWindows for instructions on how to build gtkmm on 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.

Note that to build gtkmm from git, you'll often need to build many of its dependencies from git as well. jhbuild makes this easier than it would normally be, but it will take quite a while to build and install them all. You will probably encounter build problems, though these will usually be corrected quickly if you report them.

### 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 ~/.config/jhbuildrc

The gtkmm module is defined in the `gnome-suites-core-deps-x.y.modules` moduleset, but if you are interested in the latest version, it's easier to let jhbuild read from `gnome-world.modules`. It always includes the latest version of other `.modules` files. So edit your `jhbuildrc` file and set your moduleset setting like so:

    moduleset = 'gnome-world'

After setting the correct moduleset, you need to tell jhbuild which module or modules to build. To build gtkmm and all of its dependencies, set `modules` like so:

    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 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

Once you've configured jhbuild as described above, building gtkmm should be relatively straightforward. The first time you run jhbuild, you should run the following sequence of commands to ensure that jhbuild has the required tools and verify that it is set up correctly:

    $ 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.

This involves a variety of tools, some of them crufty, but at least they work, and has been used successfully by several projects.

### La structure de construction

Generation of the source code for a gtkmm-style wrapper API requires use of tools such as `gmmproc` and `generate_wrap_init.pl`. In theory you could write your own build files to use these appropriately, but a much better option is to make use of the build infrastructure provided by the mm-common module. To get started, it helps a lot to pick an existing binding module as an example to look at.

For instance, let's pretend that we are wrapping a C library called libsomething. It provides a GObject-based API with types named, for instance, SomeWidget and SomeStuff.

#### Copie du squelette du projet

Typically our wrapper library would be called libsomethingmm. We can start by copying the skeleton source tree from the mm-common module.

      $ git clone git://git.gnome.org/mm-common
      $ cp -a mm-common/skeletonmm libsomethingmm

This provides a directory structure for the source .hg and .ccg files and the generated .h and .cc files, with `filelist.am` Automake include files that can specify the various files in use, in terms of generic Automake variables. The directory structure usually looks like this, after we have renamed the directories appropriately:

- `libsomethingmm`: The top-level directory.

  - `libsomething`: Contains the main include file and the pkg-config .pc file.

    - `src`: Contains .hg and .ccg source files.

    - `libsomethingmm`: Contains generated and hand-written .h and .cc files.

      - `private`: Contains generated `*_p.h` files.

As well as renaming the directories, we should rename some of the source files. For instance:

    $ for f in $(find libsomethingmm -depth -name '*skeleton*'); do \
        d="${f%/*}"; b="${f##*/}"; mv "$f" "$d/${b//skeleton/libsomething}"; \
      done

A number of the skeleton files must still be filled in with project-specific content later.

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

In `configure.ac`,

- The `AC_CONFIG_SRCDIR()` line must mention a file in our source tree. We can edit this later if we don't yet know the names of any of the files that we will create.

- It is common for binding modules to track the version number of the library they are wrapping. So, for instance, if the C library is at version 1.23.4, then the initial version of the binding module would be 1.23.0. However, avoid starting with an even minor version number as that usually indicates a stable release.

- The `AC_CONFIG_HEADERS()` line is used to generate two or more configuration header files. The first header file in the list contains all configuration macros which are set during the configure run. The remaining headers in the list contain only a subset of configuration macros and their corresponding `config.h.in` file will not be autogenerated. The reason for this separation is that the namespaced configuration headers are installed with your library and define publically visible macros.

- The `AC_SUBST([SOMETHINGMM_MODULES], ['...'])` line may need to be modified to check for the correct dependencies.

- The `AC_CONFIG_FILES()` block must mention the correct directory names, as described above.

##### Fichiers Makefile.am

Next we must adapt the various `Makefile.am` files:

- In `skeleton/src/Makefile.am` we must mention the correct values for the generic variables that are used elsewhere in the build system:

  `binding_name`

    The name of the library, such as libsomethingmm.

  `wrap_init_flags`

    Additional command-line flags passed to the `generate_wrap_init.pl` script, such as the C++ namespace and the parent directory prefix of include files.

- In `skeleton/skeletonmm/Makefile.am` we must mention the correct values for the generic variables that are used elsewhere in the build system:

  `lib_LTLIBRARIES`

    This variable must mention the correct library name, and this library name must be used to form the `_SOURCES`, `_LDFLAGS`, and `_LIBADD` variable names. It is permissible to use variables substituted by `configure` like `@SOMETHINGMM_API_VERSION@` as part of the variable names.

  `AM_CPPFLAGS`

    The command line options passed to the C preprocessor.

  `AM_CXXFLAGS`

    The command line options passed to the C++ compiler.

##### 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

- objects (GObjects, widgets, interfaces, boxed-types and plain structs)

- functions

- enums

- signals

- properties

- vfuncs

At the moment, we have separate tools for generating different parts of these `.defs`, so we split them up into separate files. For instance, in the `gtk/src` directory of the gtkmm sources, you will find these files:

`gtk.defs`

  Includes the other files.

`gtk_methods.defs`

  Objects and functions.

`gtk_enums.defs`

  Enumerations.

`gtk_signals.defs`

  Signals and properties.

`gtk_vfuncs.defs`

  vfuncs (function pointer member fields in structs), written by hand.

The `skeletonmm/codegen/generate_defs_and_docs.sh` script generates all `.defs` files and the `*_docs.xml` file, described in the Documentation section.

#### 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-4.0/gtk/*.h > gtk_methods.defs

#### Génération des .defs pour les énumérations

This `.defs` file describes enum types and their possible values. It is generated by the `enum.pl` script which you can find in glibmm's `tools` directory. For instance,

    $ ./enum.pl /usr/include/gtk-4.0/gtk/*.h > gtk_enums.defs

#### Génération des .defs pour les signaux et les propriétés

This `.defs` file describes signals and properties. It is generated by the special `generate_extra_defs` utility that is in every wrapping project, such as `gtkmm/tools/extra_defs_gen/`. For instance

    $ 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.

Then edit the `.cc` file to specify the correct types. For instance, your `main()` function might look like this:

    #include <libsomething.h>

    int main(int, char**)
    {
      something_init();

      std::cout << get_defs(SOME_TYPE_WIDGET)
                << get_defs(SOME_TYPE_STUFF);
      return 0;
    }

#### Écriture des .defs pour les fonctions virtuelles

This `.defs` file describes virtual functions (vfuncs). It must be written by hand. There is the skeleton file `skeleton/src/skeleton_vfunc.defs` to start from. You can also 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.

A .hg file will typically include some headers and then declare a class, using some macros to add API or behaviour to this class. For instance, gtkmm's `button.hg` looks roughly like this:

    #include <gtkmm/bin.h>
    #include <gtkmm/actionable.h>
    _DEFS(gtkmm,gtk)
    _PINCLUDE(gtkmm/private/bin_p.h)

    namespace Gtk
    {

    class Button
      : public Bin,
        public Actionable
    {
      _CLASS_GTKOBJECT(Button,GtkButton,GTK_BUTTON,Gtk::Bin,GtkBin)
      _IMPLEMENTS_INTERFACE(Actionable)
    public:

      _CTOR_DEFAULT
      explicit Button(const Glib::ustring& label, bool mnemonic = false);

      _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

The macros in this example do the following:

`_DEFS()`

  Specifies the destination directory for generated sources, and the name of the main .defs file that `gmmproc` should parse.

`_PINCLUDE()`

  Tells `gmmproc` to include a header in the generated `private/button_p.h` file.

`_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`

  Adds a default constructor.

`_WRAP_METHOD()`, `_WRAP_SIGNAL()`, and `_WRAP_PROPERTY()`

  Add methods to wrap parts of the C API.

The .h and .cc files will be generated from the .hg and .ccg files by processing them with `gmmproc` like so, though this happens automatically when using the above build structure:

    $ cd gtk/src
    $ /usr/lib/glibmm-2.60/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

The macros that you use in the .hg and .ccg files often need to know how to convert a C++ type to a C type, or vice-versa. `gmmproc` takes this information from an .m4 file in your `tools/m4/` or `codegen/m4/` directory. This allows it to call a C function in the implementation of your C++ method, passing the appropriate parameters to that C functon. For instance, this tells `gmmproc` how to convert a GtkTreeView pointer to a Gtk::TreeView pointer:

    _CONVERSION(`GtkTreeView*',`TreeView*',`Glib::wrap($3)')

`$3` will be replaced by the parameter name when this conversion is used by `gmmproc`.

Some extra macros make this easier and consistent. Look in gtkmm's .m4 files for examples. For instance:

    _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 initialization 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 )`

For instance, from `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 )`

For instance, from `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 instance, they could then be instantiated with `Gtk::make_managed()` 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 )`

For instance, from Gdk::RGBA:

    _CLASS_BOXEDTYPE(RGBA, GdkRGBA, NONE, gdk_rgba_copy, gdk_rgba_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 )`

For instance, for 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 Glib::Checksum:

    _CLASS_OPAQUE_COPYABLE(Checksum, GChecksum, NONE, g_checksum_copy, g_checksum_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 )`

For instance, for 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 )`

For instance, for 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) )`

For instance, from `celleditable.hg`:

    _CLASS_INTERFACE(CellEditable, GtkCellEditable, GTK_CELL_EDITABLE, GtkCellEditableIface)

Two extra parameters are optional, for the case that the interface derives from another interface, which should be the case when the GInterface has another GInterface as a prerequisite. For instance, from `loadableicon.hg`:

    _CLASS_INTERFACE(LoadableIcon, GLoadableIcon, G_LOADABLE_ICON, GLoadableIconIface, Icon, GIcon)

#### Macros de constructeurs

The `_CTOR_DEFAULT()` and `_WRAP_CTOR()` macros add constructors, wrapping the specified `*_new()` C functions. These macros assume that the C object has properties with the same names as the function parameters, as is usually the case, so that it can supply the parameters directly to a `g_object_new()` call. These constructors never actually call the `*_new()` C functions, because gtkmm must actually instantiate derived GTypes, and the `*_new()` C functions are meant only as convenience functions for C programmers.

When using `_CLASS_GOBJECT()`, the constructors should be protected (rather than public) and each constructor should have a corresponding `_WRAP_CREATE()` in the public section. This prevents the class from being instantiated without using a RefPtr. For instance:

    class TextMark : public Glib::Object
    {
      _CLASS_GOBJECT(TextMark, GtkTextMark, GTK_TEXT_MARK, Glib::Object, GObject)

    protected:
      _WRAP_CTOR(TextMark(const Glib::ustring& name, bool left_gravity = true), gtk_text_mark_new)

    public:
      _WRAP_CREATE(const Glib::ustring& name, bool left_gravity = true)

##### _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.

It also takes an optional extra argument:

errthrow

  This tells `gmmproc` that the C `*_new()` has a final GError** parameter which should be ignored.

##### Constructeurs codés à la main

When a constructor must be partly hand written because, for instance, the `*_new()` C function's parameters do not correspond directly to object properties, or because the `*_new()` C function does more than call `g_object_new()`, the `_CONSTRUCT()` macro may be used in the .ccg file to save some work. The `_CONSTRUCT` macro takes a series of property names and values. For instance, from `button.ccg`:

    Button::Button(const Glib::ustring& label, bool mnemonic)
    :
      _CONSTRUCT("label", label.c_str(), "use_underline", gboolean(mnemonic))
    {}

#### Macros that suppress generation of some code

Some macros suppress the generation of some code when they are used after a `_CLASS_*` macro. Some suppress the definition in the generated .cc file, others suppress both the declaration in the .h file and the definition in the .cc file.

##### _CUSTOM_DEFAULT_CTOR

Suppresses declaration and definition of default constructor in `_CLASS_BOXEDTYPE`, `_CLASS_BOXEDTYPE_STATIC` and `_CLASS_OPAQUE_COPYABLE`.

##### _CUSTOM_CTOR_CAST

Suppresses declaration and definition of the constructor that takes a pointer to the wrapped C object in `_CLASS_BOXEDTYPE` and `_CLASS_BOXEDTYPE_STATIC`.

Suppresses definition of the constructor that takes a pointer to the wrapped C object in `_CLASS_GOBJECT`, `_CLASS_GTKOBJECT`, `_CLASS_INTERFACE` and `_CLASS_OPAQUE_COPYABLE`.

##### _CUSTOM_DTOR

Suppresses definition of destructor in `_CLASS_GOBJECT` and `_CLASS_GTKOBJECT`.

##### _CUSTOM_MOVE_OPERATIONS

Suppresses declaration and definition of move constructor and move assignment operator in `_CLASS_GOBJECT`.

For example:

    class Derived : public Glib::Object
    {
      _CLASS_GOBJECT(Derived, GDerived, G_DERIVED, Glib::Object, GObject)

      _CUSTOM_MOVE_OPERATIONS

    public:
      Derived(Derived&& src) noexcept;
      Derived& operator=(Derived&& src) noexcept;
      // ...
    };

##### _CUSTOM_WRAP_NEW

Suppresses definition of `Glib::wrap_new()` function in `_CLASS_GOBJECT`.

##### _CUSTOM_WRAP_FUNCTION

Suppresses definition of `Glib::wrap()` function in `_CLASS_GOBJECT` and `_CLASS_GTKOBJECT`.

##### _NO_WRAP_FUNCTION

Suppresses declaration and definition of `Glib::wrap()` function in `_CLASS_GOBJECT`, `_CLASS_BOXEDTYPE`, `_CLASS_BOXEDTYPE_STATIC`, `_CLASS_OPAQUE_COPYABLE`, `_CLASS_INTERFACE` and `_CLASS_GTKOBJECT`.

#### 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)`

For instance, from `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`.

There are some optional extra arguments:

refreturn

  Do an extra `reference()` on the return value, in case the C function does not provide a reference.

errthrow ["<exceptions>"]

  Use the last GError** parameter of the C function to throw an exception. The optional "<exceptions>" is a comma-separated list of exceptions that can be thrown. It determines which @throws Doxygen commands are added to the documentation. Default value is Glib::Error. If you want a comma in the description of an exception, precede it by a backslash. Example: `errthrow "Glib::OptionError Hello\, world, Glib::ConvertError"`

deprecated ["<text>"]

  Puts the generated code in #ifdef blocks. Text about the deprecation can be specified as an optional parameter.

constversion

  Just call the non-const version of the same function, instead of generating almost duplicate code.

newin "<version>"

  Adds a @newin Doxygen command to the documentation, or replaces the @newin command generated from the C documentation.

ifdef <identifier>

  Puts the generated code in #ifdef blocks.

slot_name <parameter_name>

  Specifies the name of the slot parameter of the method, if it has one. This enables `gmmproc` to generate code to copy the slot and pass the copy on to the C function in its final `gpointer user_data` parameter. The `slot_callback` option must also be used to specify the name of the glue callback function to also pass on to the C function.

slot_callback <function_name>

  Used in conjunction with the `slot_name` option to specify the name of the glue callback function that handles extracting the slot and then calling it. The address of this callback is also passed on to the C function that the method wraps.

no_slot_copy

  Tells `gmmproc` not to pass a copy of the slot to the C function, if the method has one. Instead the slot itself is passed. The slot parameter name and the glue callback function must have been specified with the `slot_name` and `slot_callback` options respectively.

Selecting which C++ types should be used is also important when wrapping C API. Though it's usually obvious what C++ types should be used in the C++ method, here are some hints:

- Objects used via RefPtr: Pass the RefPtr as a const reference. For instance, `const Glib::RefPtr<Gtk::FileFilter>& filter`.

- Const Objects used via RefPtr: If the object should not be changed by the function, then make sure that the object is const, even if the RefPtr is already const. For instance, `const Glib::RefPtr<const Gtk::FileFilter>& filter`.

- 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<Gdk::Pixbuf>>`. You may need to define a Traits type to specify how the C and C++ types should be converted.

- Wrapping GList* and GSList* return types: You must discover whether the caller should free the list and whether it should release the items in the list, again by reading the documentation of the C function. With this information you can choose the ownership (none, shallow or deep) for the m4 conversion rule, which you should probably put directly into the .hg file because the ownership depends on the function rather than the type. For instance:

      #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)`

For instance, from `container.hg`:

    _WRAP_METHOD_DOCS_ONLY(gtk_container_add)

There are some optional extra arguments:

errthrow ["<exceptions>"]

  Excludes documentation of the last GError** parameter of the C function. The optional "<exceptions>" is a comma-separated list of exceptions that can be thrown. It determines which @throws Doxygen commands are added to the documentation. Default value is Glib::Error. If you want a comma in the description of an exception, precede it by a backslash. Example: `errthrow "Glib::OptionError Hello\, world, Glib::ConvertError"`

newin "<version>"

  Adds a @newin Doxygen command to the documentation, or replaces the @newin command generated from the C documentation.

voidreturn

  Don't include a @return Doxygen command in the documentation. Useful if the wrapped C function returns a value, but the corresponding C++ method returns void.

##### _IGNORE, _IGNORE_SIGNAL, _IGNORE_PROPERTY, _IGNORE_CHILD_PROPERTY

`gmmproc` will warn you on stdout about functions, signals, properties and child properties 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, signals, properties or child properties, or if you chose to hand-code some methods then you can use the _IGNORE(), _IGNORE_SIGNAL(), _IGNORE_PROPERTY() or _IGNORE_CHILD_PROPERTY() macro to make `gmmproc` stop complaining.

    _IGNORE(C function name 1, C function name 2, etc)
    _IGNORE_SIGNAL(C signal name 1, C signal name 2, etc)
    _IGNORE_PROPERTY(C property name 1, C property name 2, etc)
    _IGNORE_CHILD_PROPERTY(C child property name 1, C child property name 2, etc)

For instance, from `flowbox.hg`:

    _IGNORE(gtk_flow_box_set_filter_func, gtk_flow_box_set_sort_func)
    _IGNORE_SIGNAL(activate-cursor-child, toggle-cursor-child, move-cursor)

##### _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)`

For instance, from `button.hg`:

    _WRAP_SIGNAL(void clicked(),"clicked")

Signals usually have function pointers in the GTK struct, with a corresponding enum value and a `g_signal_new()` in the .c file.

There are some optional extra arguments:

no_default_handler

  Do not generate an `on_something()` virtual method to allow easy overriding of the default signal handler. Use this when adding a signal with a default signal handler would break the ABI by increasing the size of the class's virtual function table, and when adding a signal without a public C default handler.

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.

deprecated ["<text>"]

  Puts the generated code in #ifdef blocks. Text about the deprecation can be specified as an optional parameter.

newin "<version>"

  Adds a @newin Doxygen command to the documentation, or replaces the @newin command generated from the C documentation.

ifdef <identifier>

  Puts the generated code in #ifdef blocks.

exception_handler <method_name>

  Allows to use custom exception handler instead of default one. Exception might be rethrown by user-defined handler, and it will be caught by default handler.

detail_name <parameter_name>

  Adds a const Glib::ustring& parameter to the signal_something() method. Use it, if the signal accepts a detailed signal name, i.e. if the underlying C code registers the signal with the `G_SIGNAL_DETAILED` flag.

two_signal_methods

  Used in conjunction with the `detail_name` option to generate two signal_something() methods, one without a parameter and one with a parameter without a default value. With only the `detail_name` option one method is generated, with a parameter with default value. Use the `two_signal_methods` option, if it's necessary in order to preserve ABI.

##### _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)`

For instance, from `button.hg`:

    _WRAP_PROPERTY("label", Glib::ustring)

There are some optional extra arguments:

deprecated ["<text>"]

  Puts the generated code in #ifdef blocks. Text about the deprecation can be specified as an optional parameter.

newin "<version>"

  Adds a @newin Doxygen command to the documentation, or replaces the @newin command generated from the C documentation.

##### _WRAP_VFUNC

This macro generates the C++ method to wrap a virtual C function.

`_WRAP_VFUNC( C++ method signature, C function name)`

For instance, from `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. Conversions can also be written in the .hg file. Virtual functions often require special conversions that are best kept local to the .hg file where they are used.

There are some optional extra arguments:

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.

keep_return

  Keep a copy of the return value in the C callback function, in case the calling C function does not expect to get its own reference.

errthrow

  Use the last GError** parameter of the C virtual function (if there is one) to throw an exception.

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 <identifier>

  Puts the generated code in #ifdef blocks.

slot_name <parameter_name>

  Specifies the name of the slot parameter of the method, if it has one. This enables `gmmproc` to generate code to copy the slot and pass the copy on to the C function in its final `gpointer user_data` parameter. The `slot_callback` option must also be used to specify the name of the glue callback function to also pass on to the C function.

slot_callback <function_name>

  Used in conjunction with the `slot_name` option to specify the name of the glue callback function that handles extracting the slot and then calling it. The address of this callback is also passed on to the C function that the method wraps.

no_slot_copy

  Tells `gmmproc` not to pass a copy of the slot to the C function, if the method has one. Instead the slot itself is passed. The slot parameter name and the glue callback function must have been specified with the `slot_name` and `slot_callback` options respectively.

return_value <value>

  Defines a non-default return value.

err_return_value <value>

  Defines a non-default return value, used only if the C++ `something_vfunc()` function throws an exception which is propagated to the C callback function. If return_value is specified, but err_return_value is not, then return_value is used also when an exception is propagated.

exception_handler <method_name>

  Allows to use custom exception handler instead of default one. Exception might be rethrown by user-defined handler, and it will be caught by default handler.

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.

##### _WRAP_CHILD_PROPERTY

This macro generates the C++ method to wrap a GtkContainer child property. (See GtkContainer for more information about child properties). Similarly to _WRAP_PROPERTY, you must specify the property name and the wanted C++ type for the property. `gmmproc` uses the .defs file to discover the C type and the .m4 convert files to discover appropriate type conversions.

`_WRAP_CHILD_PROPERTY(C child property name, C++ type)`

For instance, from `notebook.hg`:

    _WRAP_CHILD_PROPERTY("tab-expand", bool)

_WRAP_CHILD_PROPERTY() accepts the same optional arguments as _WRAP_PROPERTY().

#### Autres macros :

##### _IMPLEMENTS_INTERFACE

This macro generates initialization code for the interface.

`_IMPLEMENTS_INTERFACE(C++ interface name)`

For instance, from `grid.hg`:

    _IMPLEMENTS_INTERFACE(Orientable)

There is one optional extra argument:

ifdef <identifier>

  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.

For instance, from `enums.hg`:

    _WRAP_ENUM(WindowType, GtkWindowType)

There are some optional extra arguments:

NO_GTYPE

  Use this option, if the enum is not a GType. This is the case when there is no `*_get_type()` function for the C enum, but be careful that you don't just need to include an extra header for that function. You should also file a bug against the C API, because all enums should be registered as GTypes.

  If you specify `NO_GTYPE`, don't use that enum as the type in _WRAP_PROPERTY or _WRAP_CHILD_PROPERTY. It would cause a runtime error, when the generated property_*() method is called.

  For example, from `icontheme.hg`:

      _WRAP_ENUM(IconLookupFlags, GtkIconLookupFlags, NO_GTYPE)

gtype_func <function_name>

  Specifies the name of the `*_get_type()` function for the C enum. Use this parameter if `gmmproc` can't deduce the correct function name from the name of the C enum type.

  For example, from `dbusproxy.hg` in glibmm:

      _WRAP_ENUM(ProxyFlags, GDBusProxyFlags, gtype_func g_dbus_proxy_flags_get_type)

CONV_TO_INT

  "Convertible to int." Generates a plain enum (not an enum class) within a class. Such an enum is scoped like an enum class, but unlike an enum class, it can be implicitly converted to int.

  For example, from `dialog.hg`:

      _WRAP_ENUM(ResponseType, GtkResponseType, CONV_TO_INT)

s#<from>#<to>#

  Substitutes (part of) the name of one or more enum constants. You can add any number of substitutions.

  For example, from `iochannel.hg` in glibmm:

      _WRAP_ENUM(SeekType, GSeekType, NO_GTYPE, s#^SEEK_#SEEK_TYPE_#)

deprecated ["<text>"]

  Puts the generated code in #ifdef blocks. Text about the deprecation can be specified as an optional parameter.

newin "<version>"

  Adds a @newin Doxygen command to the documentation, or replaces the @newin command generated from the C documentation.

##### _WRAP_ENUM_DOCS_ONLY

This macro just generates a Doxygen documentationn block for the enum. This is useful for enums that can't be wrapped with `_WRAP_ENUM()` because they are complexly defined (maybe using C macros) but including the generated enum documentation is still desired. It is used with the same syntax as `_WRAP_ENUM()` and also processes the same options (though NO_GTYPE, gtype_func <function_name> and CONV_TO_INT are ignored because they make no difference when just generating the enum's documentation).

##### _WRAP_GERROR

This macro generates a C++ exception class, derived from Glib::Error, with a Code enum and a code() method. You must specify the desired C++ name, the name of the corresponding C enum, and the prefix for the C enum values.

Cette exception peut alors être déclenchée par des fonctions membres générées par _WRAP_METHOD() avec l'option errthrow.

For instance, from `pixbuf.hg`:

    _WRAP_GERROR(PixbufError, GdkPixbufError, GDK_PIXBUF_ERROR)

_WRAP_GERROR() accepts the same optional arguments as _WRAP_ENUM() (though CONV_TO_INT is ignored because all exception class enums are plain enums within a class).

##### _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)`

For example, in `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*)

#### gmmproc Parameter Processing

`gmmproc` allows processing the parameters in a method signature for the macros that process method signatures (like `_WRAP_METHOD()`, `_WRAP_CTOR()` and `_WRAP_CREATE()`) in a variety of ways:

##### Parameter Reordering

For all the macros that process method signatures, it is possible to specify a different order for the C++ parameters than the existing order in the C function, virtual function or signal. For example, say that the following C function were being wrapped as a C++ method for the Gtk::Widget class:

    void gtk_widget_set_device_events(GtkWidget* widget, GdkDevice* device,
      GdkEventMask events);

However, changing the order of the C++ method's two parameters is necessary. Something like the following would wrap the function as a C++ method with a different order for the two parameters:

    _WRAP_METHOD(void set_device_events(Gdk::EventMask events{events},
      const Glib::RefPtr<const Gdk::Device>& device{device}),
      gtk_widget_set_device_events)

The `{c_param_name}` following the method parameter names tells `gmmproc` to map the C++ parameter to the specified C parameter within the `{}`. 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)

Please note that when reordering parameters for a `_WRAP_SIGNAL()` method signature, the C parameter names would always be `p0`, `p1`, etc. because the `generate_extra_defs` utility uses those parameter names no matter what the C API's parameter names may be. It's how the utility is written presently.

##### Optional Parameter Processing

For all macros processing method signatures except `_WRAP_SIGNAL()` and `_WRAP_VFUNC()` it is also possible to make the parameters optional so that extra C++ methods are generated without the specified optional parameter. For example, say that the following `*_new()` function were being wrapped as a constructor in the Gtk::ToolButton class:

    GtkToolItem* gtk_tool_button_new(GtkWidget* icon_widget, const gchar* label);

Also, say that the C API allowed NULL for the function's label parameter so that that parameter is optional. It would be possible to have `gmmproc` generate the original constructor (with all the parameters) along with an additional constructor without that optional parameter by appending a `{?}` to the parameter name like so:

    _WRAP_CTOR(ToolButton(Widget& icon_widget, const Glib::ustring& label{?}),
      gtk_tool_button_new)

In this case, two constructors would be generated: One with the optional parameter and one without it.

##### Output Parameter Processing

With `_WRAP_METHOD()` it is also possible for the return of the wrapped C function (if it has one) to be placed in an output parameter of the C++ method instead of having the C++ method also return a value like the C function does. To do that, simply include the output parameter in the C++ method parameter list 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)')

`_WRAP_METHOD()` also supports setting C++ output parameters from C output parameters if the C function being wrapped has any. Suppose, for example, that we want to wrap the following C function that returns a value in its C output parameter rect:

    gboolean gtk_icon_view_get_cell_rect(GtkIconView* icon_view,
      GtkTreePath* path, GtkCellRenderer* cell, GdkRectangle* rect);

To have `gmmproc` place the value returned in the C++ rect output parameter, something like the following `_WRAP_METHOD()` macro could be used:

    _WRAP_METHOD(bool get_cell_rect(const TreeModel::Path& path,
      const CellRenderer& cell, Gdk::Rectangle& rect{>>}) const,
      gtk_icon_view_get_cell_rect)

The `{>>}` following the rect parameter name indicates that the C++ output parameter should be set from the value returned in the C parameter from the C function. `gmmproc` will generate a declaration of a temporary variable in which to store the value of the C output parameter and a statement that sets the C++ output parameter from the temporary variable. In this case it may be necessary to have an `_INITIALIZATION()` describing how to set a Gdk::Rectangle& from a GdkRectangle* such as the following:

    _INITIALIZATION(`Gdk::Rectangle&',`GdkRectangle',`$3 = Glib::wrap(&($4))')

##### String Parameter Processing

A string-valued input parameter in a C++ method is usually a const Glib::ustring& or a const std::string&. In C code it's a const gchar*. When an empty string is converted to const gchar*, it can be converted either to `nullptr` or to a pointer to an empty string (with c_str()). Some parameters in some C functions accept a `nullptr`, and interpret it in a special way. Other parameters must not be `nullptr`.

The default conversion in `_WRAP_METHOD()` and similar macros is

- for mandatory parameters (with or without default values): empty string to empty string,

- for optional parameters (with appended `{?}`): empty string to `nullptr`.

If the default conversion is not the best conversion, append `{NULL}` to a mandatory parameter or `{?!NULL}` to an optional parameter (`!NULL` = not `NULL`). If you append both a C parameter name and `NULL`, separate them with a space: `{c_param_name NULL}`.

#### 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 (or std::string for filenames)

### Fichiers sources codés à la main

You might want to include additional source files that will not be generated by `gmmproc` from `.hg` and `.ccg` files. You can simply place these in your `libsomething/libsomethingmm` directory and mention them in the `filelist.am` in the `files_extra_h` and `files_extra_cc` variables.

### Initialisation

Your library must be initialized before it can be used, to register the new types that it makes available. Also, the C library that you are wrapping might have its own initialization function that you should call. You can do this in an `init()` function that you can place in hand-coded `init.h` and `init.cc` files. This function should initialize your dependencies (such as the C function, and gtkmm) and call your generated `wrap_init()` function. For instance:

    void init()
    {
      Gtk::Main::init_gtkmm_internals(); //Sets up the g type system and the Glib::wrap() table.
      wrap_init(); //Tells the Glib::wrap() table about the libsomethingmm classes.
    }

The implementation of the `wrap_init()` method in `wrap_init.cc` is generated by `generate_wrap_init.pl`, but the declaration in `wrap_init.h` is hand-coded, so you will need to adjust `wrap_init.h` so that the `wrap_init()` function appears in the correct C++ namespace.

### 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

By convention, structs are declared in glib/GTK+-style headers like so:

    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.

This compiler error might look like this:

    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

or this:

    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

By convention, glib/GTK+-style objects have `*_new()` functions, such as `example_widget_new()` that do nothing more than call `g_object_new()` and return the result. The input parameters are supplied to `g_object_new()` along with the names of the properties for which they are values. For instance,

    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.

Another workaround is to add a `*_construct()` function that the C++ constructor can call after instantiating its own type. For instance,

    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)
    {
            //Do stuff that uses private API:
            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.

For instance,

    ./docextract_to_xml.py -s ~/checkout/gnome/gtk+/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

If you copied the skeleton source tree in mm-common and substituted the placeholder text, then you will already have suitable `Makefile.am` and `Doxyfile.in` files. With the mm-common build setup, the list of Doxygen input files is not defined in the Doxygen configuration file, but passed along from `make` to the standard input of `doxygen`. The input file list is defined by the `doc_input` variable in the `Makefile.am` file.