<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://docbook.org/docbook/xml/4.5/docbookx.dtd" [
<!ENTITY url_refdocs_base_glib_html "http://developer.gnome.org/glibmm/unstable/">
<!ENTITY url_refdocs_base_glib "&url_refdocs_base_glib_html;classGlib_1_1">
<!ENTITY url_refdocs_base_gtk_html "http://developer.gnome.org/gtkmm/unstable/">
<!ENTITY url_refdocs_base_gtk "&url_refdocs_base_gtk_html;classGtk_1_1">
<!ENTITY url_refdocs_base_gtk_namespace "&url_refdocs_base_gtk_html;namespaceGtk_1_1">
<!ENTITY url_figures_base "figures/">
<!ENTITY url_examples_base "http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/">
<!ENTITY url_examples_branchsuffix "">
<!ENTITY gtkmm "<application>gtkmm</application>">
<!ENTITY uuml "&#252;">
<!ENTITY szlig "&#223;">
<!ENTITY verbar "&#124;">
<!ENTITY copy "&#169;">
<!ENTITY nbsp "&#160;">
]>
<!--
NOTE TO TUTORIAL DOCUMENTATION AUTHORS:
When referring to the gtkmm project in this document, please use the form
&gtkmm; so that the name is consistent throughout the document. This will wrap
gtkmm with <application></application> tags which can then be styled by CSS if
desired (e.g. boldface, monospace, etc) to make it stand out as the project
name
-->
<!-- The XSL for developer.gnome.org requires this id. -->
<book id="index" lang="fr">

  <bookinfo>

    <title>Programming with <application>gtkmm</application> 3</title>

    <authorgroup>
      <author>
        <firstname>Murray</firstname>
        <surname>Cumming</surname>
      </author>
      <author>
        <firstname>Bernhard</firstname>
        <surname>Rieder</surname>
        <contrib>Chapitre « Fonctions à délai échu ».</contrib>
      </author>
      <author>
        <firstname>Jonathon</firstname>
        <surname>Jongsma</surname>
        <contrib>Chapitre « Tracés avec Cairo ».</contrib>
        <contrib>Chapitre « Travail sur le code source de gtkmm »</contrib>
        <contrib>Chapitre « Documents récents ».</contrib>
      </author>
      <author>
        <firstname>Ole</firstname>
        <surname>Laursen</surname>
        <contrib>Parties du chapitre « Internationalisation ».</contrib>
      </author>
      <author>
        <firstname>Gene</firstname>
        <surname>Ruebsamen</surname>
        <contrib>Chapitre « Installation sur Win32 ».</contrib>
      </author>
      <author>
        <firstname>Cedric</firstname>
        <surname>Gustin</surname>
        <contrib>Chapitre « Installation sur Win32 ».</contrib>
      </author>
      <author>
        <firstname>Marko</firstname>
        <surname>Anastasov</surname>
        <contrib>Chapitre « Impression ».</contrib>
        <contrib>Parties du chapitre « Internationalisation ».</contrib>
      </author>
      <author>
        <firstname>Daniel</firstname>
        <surname>Elstner</surname>
        <contrib>Section « Structure de construction » du chapitre « Habillage des bibliothèques C avec gmmproc ».</contrib>
      </author>
    </authorgroup>

    <abstract>

      <!-- This text is copied from the introduction. -->
      <para>Cet ouvrage explicite les concepts-clés de l'API C++ <application>gtkmm</application> 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).</para>

    </abstract>

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

    <legalnotice>
      <para>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.</para>
    </legalnotice>

  </bookinfo>

<chapter id="chapter-introduction">
<title>Introduction</title>

<sect1 id="sec-this-book">
<title>Cet ouvrage</title>

<para>Cet ouvrage explicite les concepts-clés de l'API C++ <application>gtkmm</application> 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.</para>

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

<para>Nous souhaitons vivement que vous nous rapportiez tout problème rencontré dans l'apprentissage de <application>gtkmm</application> avec ce document ; cela nous permet d'y apporter des améliorations en conséquence. Veuillez vous reporter au chapitre <link linkend="chapter-contributing">Contribution</link> pour plus d'informations.</para>
</sect1>

<sect1 id="sec-gtkmm">
<title>gtkmm</title>
<para><application>gtkmm</application> est un habillage (« wrapper ») C++ pour <ulink url="http://www.gtk.org/">GTK+</ulink>, une bibliothèque servant elle-même à créer des interfaces utilisateur graphique. <application>gtkmm</application> 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.</para>
<para>À l'origine <application>gtkmm</application> 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 <application>gtkmm</application> et c'est ainsi que nous le désignerons dans la suite.</para>

<sect2 id="why-use-gtkmm">
<title>Pourquoi utiliser <application>gtkmm</application> plutôt que GTK+ ?</title>
<para><application>gtkmm</application> 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é.</para>
<para><application>gtkmm</application> 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.</para>
<para>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.</para>
<para>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.</para>
<para>Comparé à GTK+, avec l'utilisation des noms de fonctions préfixés et de nombreuses macros de forçage de type, <application>gtkmm</application> nécessite moins de code.</para>
</sect2>

<sect2 id="gtkmm-vs-qt">
<title><application>gtkmm</application> comparée à <application>Qt</application></title>
<para>Qt de Trolltech est le plus proche concurrent de <application>gtkmm</application> ; cela mérite une explication.</para>

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

<sect2 id="gtkmm-is-a-wrapper">
<title><application>gtkmm</application> est un habillage</title>
<para><application>gtkmm</application> 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 <application>gtkmm</application> passent la majeure partie de leur temps à discuter de la manière dont <application>gtkmm</application> 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.</para>
</sect2>
</sect1>

</chapter>

<chapter id="chapter-installation">
<title>Installation</title>
<sect1 id="sec-installation-dependencies">
<title>Dépendances</title>
<para>
  Before attempting to install <application>gtkmm</application> 3.0, you might first need to install these other
  packages.
</para>
<itemizedlist>
  <listitem><para><application>libsigc++ 2.0</application></para></listitem>
  <listitem><para><application>GTK+ 3.0</application></para></listitem>
  <listitem><para><application>cairomm</application></para></listitem>
  <listitem><para><application>pangomm</application></para></listitem>
  <listitem><para><application>atkmm</application></para></listitem>
</itemizedlist>
<para>Ces dépendances ont elles-mêmes leurs propres dépendances, comprenant les applications et bibliothèques suivantes :</para>
<itemizedlist>
  <listitem><para><application>pkg-config</application></para></listitem>
  <listitem><para><application>glib</application></para></listitem>
  <listitem><para><application>ATK</application></para></listitem>
  <listitem><para><application>Pango</application></para></listitem>
  <listitem><para><application>cairo</application></para></listitem>
  <listitem><para><application>gdk-pixbuf</application></para></listitem>
</itemizedlist>
</sect1>

<sect1 id="sec-install-unix-and-linux">
<title>Unix et Linux</title>

<sect2 id="sec-linux-install-from-packages">
<title>Paquets logiciels pré-compilés</title>

<para>Les versions récentes de <application>gtkmm</application> sont empaquetées par pratiquement toutes les grandes distributions Linux. Donc, si vous êtes un utilisateur de Linux, vous pourrez probablement débuter avec <application>gtkmm</application> en installant son paquet à partir du dépôt officiel de votre distribution. Parmi les distributions qui mettent à disposition <application>gtkmm</application> dans leurs dépôts, citons Debian, Ubuntu, Red Hat, Fedora, Mandriva, Suse, mais il y en a beaucoup d'autres.</para>
<para>Les noms des paquets <application>gtkmm</application> varient selon les distributions (par exemple, <application>libgtkmm3.0-dev</application> sur Debian et Ubuntu ou <application>gtkmm30-devel</application> sur Red Hat Fedora) ; vérifiez donc avec le programme de gestion de paquets de votre distribution la dénomination correcte, puis installez-le comme vous feriez pour tout autre paquet.</para>
<note>
<para>
The package names will not change when new API/ABI-compatible versions of <application>gtkmm</application>
are released. Otherwise they would not be API/ABI-compatible. So don't be
surprised, for instance, to find <application>gtkmm</application> 3.2 supplied by Debian's
<application>libgtkmm3.0-dev</application> package.
</para>
</note>
</sect2>

<sect2 id="sec-install-from-source">
<title>Installation à partir des sources</title>

<para>Si votre distribution ne met pas à disposition un paquet pré-compilé de <application>gtkmm</application>, ou bien si vous souhaitez installer une version différente de celle fournie, vous pouvez installer <application>gtkmm</application> à partir des sources. Le code source de <application>gtkmm</application> est téléchargeable à partir de <ulink url="http://www.gtkmm.org/"/>.</para>
<para>Après installation de toutes les dépendances, téléchargez le code source de <application>gtkmm</application>, extrayez-le et déplacez vous dans le nouveau répertoire. <application>gtkmm</application> se construit et s'installe en saisissant cette suite de commandes :</para>
<screen>
# ./configure
# make
# make install
</screen>
<note>
<para>N'oubliez pas qu'avec un système d'exploitation Unix ou Linux, vous aurez besoin d'être <literal>root</literal> (avoir les privilèges administrateur) pour installer le logiciel. La commande <command>su</command> vous confère temporairement le statut d'administrateur après la saisie du mot de passe <literal>root</literal>.</para>
</note>
<para>Le script <filename>configure</filename> 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.</para>
<para>Par défaut, <application>gtkmm</application> est installé dans le répertoire <filename>/usr/local</filename>. Sur certains systèmes, il sera peut-être nécessaire de l'installer à un autre emplacement. Par exemple, sur les systèmes Linux Red Hat, vous utiliserez peut-être l'option <literal>--prefix</literal> avec configure, ainsi : <screen>
# ./configure --prefix=/usr
</screen></para>
<warning>
    <para>Il faut être très précautionneux si vous faites une installation avec comme préfixe un des répertoires système standard, comme <filename>/usr</filename>. Les distributions Linux installent leurs paquets logiciels dans <filename>/usr</filename> ; 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.</para>
</warning>
<para>Si vous souhaitez participer au développement de <application>gtkmm</application> ou expérimenter de nouvelles fonctionnalités, vous pouvez installer <application>gtkmm</application> à 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 <application>gtkmm</application>, consultez l'annexe <link linkend="chapter-working-with-source">Travail sur le code source de gtkmm</link></para>
</sect2>

</sect1>

<sect1 id="sec-packages-windows">
<title>Windows Microsoft</title>
<para>GTK+ et <application>gtkmm</application> ont été conçus pour bien fonctionner avec Windows Microsoft ; les développeurs poussent à son utilisation sur les plates-formes win32. Mais, Windows ne dispose d'aucune norme d'installation pour les bibliothèques de développement. Consultez les pages spécifiques relatives aux instructions et notes spécifiques à l'<ulink url="http://live.gnome.org/gtkmm/MSWindows">Installation sous Windows</ulink>.</para>
</sect1>

</chapter>

<chapter id="chapter-basics">
<title>Fondamentaux</title>

<para>Ce chapitre présente quelques aspects parmi les plus importants du codage avec <application>gtkmm</application>. 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.</para>
<para>Vos connaissances en matière de C++ vous seront d'un bon secours pour <application>gtkmm</application> comme pour toute autre bibliothèque. À moins que nous n'indiquions le contraire, vous pouvez vous attendre à ce que les classes <application>gtkmm</application> aient un comportement identique à celui des autres classes C++ et donc à utiliser vos techniques C++ habituelles avec elles.</para>

<sect1 id="sec-basics-simple-example">
<title>Un exemple simple</title>

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

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/base?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>base.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;gtkmm.h&gt;

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

  Gtk::Window window;

  Gtk::Main::run(window);

  return EXIT_SUCCESS;
}
</programlisting>
<!-- end inserted example code -->

<para>Détaillons maintenant chaque ligne de l'exemple</para>
<programlisting>#include &lt;gtkmm.h&gt;</programlisting>
<para>Tous les programmes <application>gtkmm</application> doivent inclure certains fichiers d'en-tête <application>gtkmm</application> ; <literal>gtkmm.h</literal> inclut la totalité du jeu d'en-têtes <application>gtkmm</application>. 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.</para>

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

<para>Les deux lignes de code suivantes créent et affichent une fenêtre :</para>
<programlisting>Gtk::Window window;</programlisting>
<para>La deuxième ligne affiche la fenêtre et entre dans la boucle principale de traitement, boucle dont on ne sort qu'à la fermeture de la fenêtre.</para>

<programlisting>Gtk::Main::run(window);</programlisting>

<para>Après avoir incorporé ces lignes de code source dans <literal>simple.cc</literal>, vous pouvez compiler ce programme avec la commande : <programlisting>g++ simple.cc -o simple `pkg-config gtkmm-3.0 --cflags --libs`</programlisting> Notez qu'il est impératif d'entourer l'appel à <literal>pkg-config</literal> d'apostrophes inverses. Elles demandent à l'interpréteur de commandes d'exécuter la commande entourée et d'intégrer au même emplacement la sortie correspondante dans la ligne de commande.</para>
</sect1>

<sect1 id="sec-headers-and-linking">
<title>Fichiers d'en-têtes et édition des liens </title>
<para>Même si nous avons indiqué la commande de compilation pour cet exemple simple, vous devriez vraiment utiliser les outils <application>automake</application> et <application>autoconf</application> tels que décrits dans « Autoconf, Automake, Libtool » par G.V. Vaughan et autres. Les exemples utilisés dans le présent ouvrage sont incorporés dans le paquet logiciel de <application>gtkmm</application>, avec les fichiers de construction appropriés ; nous ne mentionnerons donc pas ces commandes dans le futur. Il conviendra simplement de trouver le répertoire convenable, de s'y placer et de saisir <literal>make</literal>.</para>
<para>Pour simplifier la compilation, nous utilisons <literal>pkg-config</literal>, présent dans toutes les installations de <application>gtkmm</application> (correctement effectuées). Ce programme « sait » quels sont les commutateurs nécessaires à la compilation des programmes utilisant <application>gtkmm</application>. L'option <literal>--cflags</literal> demande à <literal>pkg-config</literal> de produire la liste des répertoires des en-têtes, répertoires que le compilateur devra parcourir ; l'option <literal>--libs</literal> 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.</para>
<para>Mais, il est plus simple d'utiliser la macro <function>PKG_CHECK_MODULES()</function> dans un fichier standard <filename>configure.ac</filename> avec <application>autoconf</application> et <application>automake</application>. Par exemple : <programlisting>PKG_CHECK_MODULES([MYAPP], [gtkmm-3.0 &gt;= 3.0.0])</programlisting> Cette commande vérifie la présence de <application>gtkmm</application> et définit les variables MYAPP_LIBS et MYAPP_CFLAGS à utiliser dans vos fichiers <filename>Makefile.am</filename>.</para>
<para>gtkmm-3.0 is the name of the current stable API. There was an older API called gtkmm-2-4 which installs in parallel when it is available. There were several versions of gtkmm-2.4, such as gtkmm 2.10 and there will be several versions of the gtkmm-3.0 API. Note that the API name does not change for every version because that would be an incompatible API and ABI break. Theoretically, there might be a future gtkmm-4.0 API which would install in parallel with gtkmm-3.0 without affecting existing applications.
</para>

<para>Note that if you mention extra modules in addition to gtkmm-3.0, they should be separated by spaces, not commas.
</para>
<para>Openismus fournit une <ulink url="http://www.openismus.com/documents/linux/automake/automake.shtml">Aide sur les fondamentaux avec automake et autoconf</ulink>.</para>

</sect1>

<sect1 id="sec-widgets-overview">
<title>Éléments graphiques</title>
<para>Les applications <application>gtkmm</application> 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.</para>
 <para>Les éléments graphiques sont disposés dans des conteneurs tels que cadres et bloc-notes, avec une hiérarchie entre éléments graphiques. Certains de ces conteneurs d'éléments graphiques, comme les <classname>Gtk::Grid</classname>, ne sont pas visibles ‑ ils ne participent qu'à la disposition relative des éléments graphiques. Voici un exemple de code qui place deux contrôles <classname>Gtk::Button</classname> dans un conteneur d'éléments graphiques <classname>Gtk::VBox</classname> : <programlisting>m_box.pack_start(m_Button1);
m_box.pack_start(m_Button2);</programlisting> et voici comment ajouter le <classname>Gtk::VBox</classname>, contenant ces boutons, dans un <classname>Gtk::Frame</classname>, qui possède un cadre et un titre visibles : <programlisting>m_frame.add(m_box);</programlisting></para>
<para>La plupart des chapitres de cet ouvrage traitent d'éléments graphiques spécifiques. Consultez la section <link linkend="chapter-container-widgets">Éléments graphiques conteneurs</link> pour de plus amples précisions sur la manière de placer des éléments graphiques dans des conteneurs.</para>

<para>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 <literal>Glade</literal> et de les charger avec <literal>Gtk::Builder</literal> à l'exécution de l'application. Consultez le chapitre <link linkend="chapter-builder">Glade et Gtk::Builder</link>.</para>

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

</sect1>

<sect1 id="sec-signals-overview">
<title>Signaux</title>

<para><application>gtkmm</application>, comme la plupart des boîtes à outils GUI, est <emphasis>piloté par événements</emphasis>. Lorsqu'un événement survient, comme un clic de bouton de souris, le signal approprié est <emphasis>émis</emphasis> 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 <emphasis>gestionnaire de signal</emphasis> pour capturer le signal « clicked » du bouton.</para>
<para><application>gtkmm</application> utilise la bibliothèque libsigc++ pour implémenter les signaux. Voici un exemple de ligne de code qui connecte le signal « clicked » émis par un Gtk::Button à un gestionnaire de signal nommé « on_button_clicked » : <programlisting>m_button1.signal_clicked().connect( sigc::mem_fun(*this,
  &amp;HelloWorld::on_button_clicked) );</programlisting></para>

<para>Pour plus de détails à propos des signaux, consultez cette <link linkend="chapter-signals">annexe</link>.</para>
<para>Pour des informations sur l'implémentation de vos propres signaux au lieu d'une simple connexion aux signaux prédéfinis de <application>gtkmm</application>, consultez cette <link linkend="chapter-custom-signals">annexe</link>.</para>

</sect1>

<sect1 id="sec-basics-ustring">
<title>Glib::ustring</title>
<para>Peut-être serez-vous surpris d'apprendre que <application>gtkmm</application> n'utilise pas la classe <classname>std::string</classname> dans ses interfaces. À la place, <application>gtkmm</application> utilise la classe <classname>Glib::ustring</classname> ; les deux classes sont tout à fait semblables et tellement amalgamées que vous pouvez vraiment prétendre que chaque Glib::ustring est un <classname>std::string</classname> et ignorer la suite de ce paragraphe. Mais poursuivez la lecture si vous voulez utiliser des langues autres que l'anglais dans vos applications.</para>
<para>std::string utilise 8 bits par caractère, mais 8 bits ne sont pas suffisants pour coder des langues telles que l'arabe, le chinois ou le japonais. Même si les codages pour ces langues ont maintenant été définis par le Consortium Unicode, les langages informatiques C et C++ ne fournissent pas encore une prise en charge normalisée de l'Unicode. GTK+ et GNOME ont choisi d'implémenter l'Unicode en utilisant l'UTF-8 ; c'est ce codage qui est intégré dans Glib::ustring. Il fournit une interface pratiquement identique à  std::string, tout en permettant des conversions automatiques de ou vers std::string.</para>
<para>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. <classname>std::string</classname> 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 <classname>Glib::ustring</classname> à la place.</para>
<para>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 »).</para>
<para>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. <classname>Glib::ustring</classname> 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.</para>

<para>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.</para>

<para><ulink url="http://developer.gnome.org/glibmm/unstable/classGlib_1_1ustring.html">Référence</ulink></para>

<para>Consultez le chapitre sur l'<link linkend="chapter-internationalization">Internationalisation</link> pour des informations concernant les chaînes littérales UTF-8.</para>

</sect1>

<sect1 id="sec-intermediate-types">
<title>Types intermédiaires</title>
<para>Some API related to gtkmm uses intermediate data containers, such as <classname>Glib::StringArrayHandle</classname>, instead of a specific Standard C++ container such as <classname>std::vector</classname> or <classname>std::list</classname>, though <application>gtkmm</application> itself now uses just <classname>std::vector</classname> since <application>gtkmm</application> 3.0.</para>
<para>You should not declare these types yourself. You should instead use whatever Standard C++ container you prefer. glibmm will do the conversion for you. Here are some of these intermediate types:
<itemizedlist>
    <listitem><para><classname>Glib::StringArrayHandle</classname> ou <classname>Glib::ArrayHandle&lt;Glib::ustring&gt;</classname> : utilisez <classname>std::vector&lt;Glib::ustring&gt;</classname>, <classname>std::list&lt;Glib::ustring&gt;</classname>, <literal>const char*[]</literal>, etc.</para></listitem>
    <listitem><para><classname>Glib::ListHandle&lt;Gtk::Widget*&gt;</classname> : utilisez <classname>std::vector&lt;Gtk::Widget*&gt;</classname>, <classname>std::list&lt;Gtk::Widget*&gt;</classname>, etc.</para></listitem>
    <listitem><para><classname>Glib::SListHandle&lt;Gtk::Widget*&gt;</classname> : utilisez <classname>std::vector&lt;Gtk::Widget*&gt;</classname>, <classname>std::list&lt;Gtk::Widget*&gt;</classname>, etc.</para></listitem>
</itemizedlist>

</para>

</sect1>

<sect1 id="sec-basics-gobj-and-wrap">
<title>Mélange des API C et C++</title>
<para>Vous pouvez utiliser des API C, si elles n'ont pas encore d'interfaces C++ commodes. Il n'y a généralement aucun problème avec l'utilisation des API C dans le C++ ; <application>gtkmm</application> vous aide en donnant un accès à l'objet C sous-jacent et en facilitant la création d'un objet C++ enveloppe de l'objet C, à condition que l'API C soit également fondée sur le système GObject.</para>

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

<para>
<programlisting>
Gtk::Button* button = new Gtk::Button("exemple");
gtk_button_do_something_new(button-&gt;gobj());
</programlisting>
</para>

<para>Pour obtenir un objet <application>gtkmm</application> à partir d'un élément GObject C, utilisez la fonction  Glib::wrap(). Par exemple</para>
<para>
<programlisting>
GtkButton* cbutton = get_a_button();
Gtk::Button* button = Glib::wrap(cbutton);
</programlisting>
</para>
</sect1>

<sect1 id="sec-helloworld">
<title>Hello World en <application>gtkmm</application></title>

<para>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 <application>gtkmm</application> :</para>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/helloworld?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>helloworld.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_HELLOWORLD_H
#define GTKMM_EXAMPLE_HELLOWORLD_H

#include &lt;gtkmm/button.h&gt;
#include &lt;gtkmm/window.h&gt;

class HelloWorld : public Gtk::Window
{

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

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

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

#endif // GTKMM_EXAMPLE_HELLOWORLD_H
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "helloworld.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<para>File: <filename>helloworld.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "helloworld.h"
#include &lt;iostream&gt;

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

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

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

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

HelloWorld::~HelloWorld()
{
}

void HelloWorld::on_button_clicked()
{
  std::cout &lt;&lt; "Hello World" &lt;&lt; std::endl;
}
</programlisting>
<!-- end inserted example code -->

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

<figure id="figure-helloworld">
  <title>Hello World</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/helloworld.png"/>
  </screenshot>
</figure>

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

<programlisting>class HelloWorld : public Gtk::Window
{

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

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

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

<para>Cette classe implémente la fenêtre « Hello World ». Elle est dérivée de la classe <classname>Gtk::Window</classname> et possède un simple <classname>Gtk::Button</classname> 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 :</para>

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

<para>Notez que nous avons utilisé une instruction d'initialisation pour étiqueter l'objet <literal>m_button</literal> avec « Hello World ».</para>

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

<para>Ensuite, nous raccordons un gestionnaire de signal pour le signal <literal>clicked</literal> du <literal>m_button</literal>. Le gestionnaire affiche sur <literal>stdout</literal> notre salut amical.</para>

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


<para>Maintenant examinons la fonction <function>main()</function> du programme. La voici, sans commentaire :</para>

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

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

  return 0;
}</programlisting>

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

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

</sect1>
</chapter>

<chapter id="changes-gtkmm3">
<title>Changes in <application>gtkmm</application> 3</title>

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

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


<para><application>gtkmm</application> 3 added some new classes:</para>

<orderedlist>
<!-- TODO: The AppChooser content-type is not documented properly: https://bugzilla.gnome.org/show_bug.cgi?id=650012 -->
<listitem><simpara><classname>Gtk::AppChooser</classname>, <classname>Gtk::AppChooserButton</classname>, <classname>Gtk::AppChooserDialog</classname> allow the user to select an installed application to open a particularl type of content.</simpara></listitem>

<listitem><simpara><classname>Gtk::Grid</classname> is a new container widget that will eventually replace <classname>Gtk::Box</classname>. It arranges its children according to properties of those children rather than its own layout details.</simpara></listitem>
<listitem><simpara><classname>Gtk::Switch</classname> displays On/Off states more explictly than <classname>Gtk::CheckBox</classname>. It may be useful, for instance, when allowing users to activate hardware.</simpara></listitem>
</orderedlist>

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

<para>
<orderedlist>

<listitem><simpara><classname>Gtk::CellLayout</classname>, used by <classname>Gtk::IconView</classname>, <classname>Gtk::TreeView::Column</classname> and <classname>Gtk::ComboBox</classname>, now has a <classname>Gtk::CellArea</classname> which can be used to specify more details of how the <classname>CellRenderer</classname>s are arranged and aligned.</simpara></listitem>

<listitem><simpara>Gtk::ComboBox now derives from CellLayout, allowing easier layout and alignment of its <classname>Gtk::CellRenderer</classname>s.</simpara></listitem>

<listitem><simpara><classname>Gtk::Adjustment</classname> and <classname>IconSet</classname> and <classname>Gdk::Cursor</classname> are now used via <classname>Glib::RefPtr</classname>.</simpara></listitem>

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

<listitem><simpara><classname>Gtk::IconView</classname>, <classname>Gtk::TextView</classname>, <classname>Gtk::TreeView</classname> and other widgets derive from Scrollable instead of having their own methods such as <methodname>get_vadjustment()</methodname> and instead of having their won set_scroll_adjustments signal.</simpara></listitem>

<listitem><simpara><classname>Gtk::Style</classname> and <classname>Gtk::Rc</classname> were removed, replaced by <classname>Gtk::StyleContext</classname>, and <classname>Gtk::StyleProvider</classname>s, such as <classname>Gtk::CssProvider</classname>.</simpara></listitem>

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

<listitem><simpara><classname>Gdk::RGBA</classname> replaces <classname>Color</classname>, adding an alpha component for opacity. <classname>Colormap</classname> was removed, along with its awkward use to allocate colors.</simpara></listitem>

<listitem><simpara><classname>Gdk::Pixmap</classname> and <classname>Gdk::Bitmap</classname> were removed in favour of <classname>Gdk::Pixbuf</classname>.</simpara></listitem>

<listitem><simpara><classname>Gdk::Drawable</classname> was removed, with its methods moving into <classname>Gdk::Window</classname>.</simpara></listitem>

<listitem><simpara>We now use std::vector in several methods instead of the intermediate *Handle types to make the API clearer.</simpara></listitem>

</orderedlist>
</para>

<para>All deprecated API was removed in <application>gtkmm</application> 3.0, though there will be new deprecations in future versions.</para>

<para>As a first step to porting your source code to <application>gtkmm</application>-3.0; you should probably ensure that your application builds with the deprecated <application>gtkmm</application>-2.4; API disabled, by defining macro such as GTK_DISABLE_DEPRECATED. There are some autotools macros that can help with this by defining them optionally at build time. See the <ulink url="https://live.gnome.org/gtkmm/PortingToGtkmm3">gtkmm 3 porting wiki page</ulink> for more details.</para>

</chapter>

<chapter id="chapter-button-widget">
<title>Boutons</title>

<para><application>gtkmm</application> met à votre disposition quatre types basiques de boutons :</para>

<variablelist>

<varlistentry>
<term>Bouton poussoir</term>
<listitem>
<para>
<ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Button.html"><classname>Gtk::Button</classname></ulink>. Standard buttons, usually
marked with a label or picture. Pushing one triggers an action. See the <link linkend="sec-pushbuttons">Button</link> section.
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Bouton bascule</term>
<listitem>
<para>
<ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1ToggleButton.html"><classname>Gtk::ToggleButton</classname></ulink>.
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 <link linkend="sec-toggle-buttons">ToggleButton</link> section.
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Case à cocher</term>
<listitem>
<para>
<ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1CheckButton.html"><classname>Gtk::CheckButton</classname></ulink>.
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 <link linkend="sec-checkboxes">CheckBox</link> section.
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Bouton radio</term>
<listitem>
<para>
<ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1RadioButton.html"><classname>Gtk::RadioButton</classname></ulink>.
Named after the station selectors on old car
radios, these buttons are used in groups for options which are
mutually exclusive. Pressing one causes all the
others in its group to turn off. They are similar to
CheckBoxes (a small widget with a label at the side), but usually
look different.
See the <link linkend="sec-radio-buttons">RadioButton</link> section.
</para>
</listitem>
</varlistentry>
</variablelist>

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

<sect1 id="sec-pushbuttons">
<title>Bouton</title>

<sect2 id="pushbutton-constructors"><title>Constructeurs</title>

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

<para>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 à <literal>true</literal> le paramètre optionnel <literal>mnemonic</literal> (mnémonique). Par exemple :</para>
<programlisting>Gtk::Button* pButton = new Gtk::Button("_Quelquechose", true);</programlisting>

<para>Chaque fois que cela est possible, vous devez utiliser les éléments du catalogue pour être cohérent avec les autres applications et en améliorer l'aspect en utilisant des icônes. Par exemple, <programlisting>Gtk::Button* pButton = new Gtk::Button(Gtk::Stock::OK);</programlisting> utilise un texte normalisé, dans toutes les langues, avec un raccourci clavier et une icône standard.</para>

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Button.html">Référence</ulink></para>
</sect2>

<sect2 id="pushbutton-example"><title>Exemple</title>

<para>Cet exemple crée un bouton avec image et étiquette.</para>

<figure id="figure-buttons">
  <title>Exemple de bouton</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/buttons.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/buttons/button?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>buttons.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_BUTTONS_H
#define GTKMM_EXAMPLE_BUTTONS_H

#include &lt;gtkmm/window.h&gt;
#include &lt;gtkmm/button.h&gt;

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
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "buttons.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<para>File: <filename>buttons.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "buttons.h"
#include &lt;iostream&gt;

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

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

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

  add(m_button);

  show_all_children();
}

Buttons::~Buttons()
{
}

void Buttons::on_button_clicked()
{
  std::cout &lt;&lt; "The Button was clicked." &lt;&lt; std::endl;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

<sect2 id="pushbutton-signals"><title>Signaux</title>

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

<para>
<variablelist>

<varlistentry>
<term><literal>pressed (enfoncé)</literal></term>
<listitem>
<para>Émis quand le bouton est enfoncé.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><literal>released (relâché)</literal></term>
<listitem>
<para>Émis quand le bouton est relâché.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><literal>clicked (cliqué)</literal></term>
<listitem>
<para>Émis quand le bouton est enfoncé et relâché.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><literal>enter (entré)</literal></term>
<listitem>
<para>Émis quand le pointeur de souris entre dans la fenêtre du bouton.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><literal>leave (quitté)</literal></term>
<listitem>
<para>Émis lorsque le pointeur de souris sort de la fenêtre du bouton.</para>
</listitem>
</varlistentry>
</variablelist>
</para>

</sect2>
</sect1>

<sect1 id="sec-toggle-buttons">
<title>Bouton bascule</title>

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

<para>Pour obtenir l'état du <classname>ToggleButton</classname>, utilisez la fonction membre <methodname>get_active()</methodname>. Elle renvoie <literal>true</literal> si le bouton est « enfoncé ». Vous pouvez aussi définir l'état du bouton bascule avec <methodname>set_active()</methodname>. 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é.</para>

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

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1ToggleButton.html">Référence</ulink></para>

</sect1>

<sect1 id="sec-checkboxes">
<title>Case à cocher</title>

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1CheckButton.html">Référence</ulink></para>

<sect2 id="checkbutton-example"><title>Exemple</title>

<figure id="figure-checkbutton">
  <title>Case à cocher</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/checkbutton.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/buttons/checkbutton?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_BUTTONS_H
#define GTKMM_EXAMPLE_BUTTONS_H

#include &lt;gtkmm/window.h&gt;
#include &lt;gtkmm/checkbutton.h&gt;

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
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;iostream&gt;

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

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

  add(m_button);

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_button_clicked()
{
  std::cout &lt;&lt; "The Button was clicked: state="
      &lt;&lt; (m_button.get_active() ? "true" : "false")
      &lt;&lt; std::endl;
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->
</sect2>

</sect1>

<sect1 id="sec-radio-buttons">
<title>Bouton radio</title>

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

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

<programlisting>class RadioButtons : public Gtk::Window
{
public:
    RadioButtons();

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

RadioButtons::RadioButtons()
  : m_rb1("Bouton1"),
    m_rb2("Bouton2"),
    m_rb3("Bouton3")
{
    Gtk::RadioButton::Group group = m_rb1.get_group();
    m_rb2.set_group(group);
    m_rb3.set_group(group);
}</programlisting>
<para>Nous indiquons à <application>gtkmm</application> de placer les trois objets <classname>RadioButton</classname> dans un même groupe en obtenant un pointeur sur le groupe avec <methodname>get_group()</methodname> et en utilisant <methodname>set_group()</methodname> pour faire en sorte que les autres <classname>RadioButton</classname> partagent le même groupe.</para>

<para>Notez qu'il n'est pas possible d'écrire simplement <programlisting>m_rb2.set_group(m_rb1.get_group()); // ne fonctionne pas !</programlisting> étant donné que <methodname>set_group()</methodname> modifie le groupe et qu'en conséquence, le pointeur n'est pas constant.</para>


<para>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 :</para>
<programlisting>class RadioButtons : public Gtk::Window
{
public:
    RadioButtons();
};

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

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

<sect2 id="radiobutton-methods"><title>Fonctions membres</title>
<para>À leur création, les objets de la classe <classname>RadioButtons</classname> sont « inactifs », donc, lors de la création du groupe, tous les boutons sont désactivés. N'oubliez donc pas d'en activer un avec <methodname>set_active()</methodname> :</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1RadioButton.html">Référence</ulink></para>

</sect2>

<sect2 id="radiobutton-example"><title>Exemple</title>
<para>L'exemple suivant montre l'utilisation de la classe <classname>RadioButton</classname> :</para>

<figure id="figure-radiobutton">
  <title>Bouton radio</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/radiobuttons.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/buttons/radiobutton?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>radiobuttons.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_RADIOBUTTONS_H
#define GTKMM_EXAMPLE_RADIOBUTTONS_H

#include &lt;gtkmm/box.h&gt;
#include &lt;gtkmm/window.h&gt;
#include &lt;gtkmm/radiobutton.h&gt;
#include &lt;gtkmm/separator.h&gt;

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

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

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

#endif //GTKMM_EXAMPLE_RADIOBUTTONS_H
</programlisting>
<para>File: <filename>radiobuttons.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "radiobuttons.h"


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

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

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

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

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

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

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

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

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

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

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

RadioButtons::~RadioButtons()
{
}

void RadioButtons::on_button_clicked()
{
  hide(); //to close the application.
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "radiobuttons.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

</sect1>

</chapter>


<chapter id="chapter-range-widgets">
<title>Éléments graphiques à plage de réglage</title>

<para>Les classes <classname>Gtk::Scale</classname> et <classname>Gtk::Scrollbar</classname> dérivent toutes deux de <classname>Gtk::Range</classname>, 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.</para>

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Range.html">Référence</ulink></para>

<sect1 id="sec-scrollbar-widgets">
<title>Éléments graphiques barres de défilement</title>

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

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Scrollbar.html">Référence</ulink></para>

</sect1>

<sect1 id="sec-scale-widgets">
<title>Éléments graphiques échelles de valeur</title>

<para>Les éléments graphiques de la classe <classname>Gtk::Scale</classname> (« 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.</para>

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

<sect2 id="scale-useful-methods">
<title>Fonctions membres utiles</title>

<para>Les éléments graphiques de la classe <classname>Scale</classname> 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 <methodname>set_draw_value()</methodname>.</para>

<para>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 <literal>value</literal> de l'objet <classname>Gtk::Adjustment</classname> associé. Vous pouvez modifier la précision avec la fonction membre <methodname>set_digits()</methodname>.</para>

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Scale.html">Référence</ulink></para>

</sect2>
</sect1>

<sect1 id="sec-range-update-policies">
<title>Politiques de mise à jour</title>

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

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

<para><literal>Gtk::UPDATE_DISCONTINUOUS</literal> — Le signal <literal>value_changed</literal> n'est émis que lorsque le curseur n'est plus déplacé et que l'utilisateur a relâché le bouton de la souris.</para>
</listitem>
<listitem>

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

</itemizedlist></para>
</sect1>

<sect1 id="sec-range-example">
<title>Exemple</title>

<para>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.</para>

<figure id="figure-range-widgets">
  <title>Éléments graphiques à plage de réglage</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/range_widgets.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/range_widgets?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_RANGEWIDGETS_H
#define GTKMM_EXAMPLE_RANGEWIDGETS_H

#include &lt;gtkmm.h&gt;

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

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

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

  Glib::RefPtr&lt;Gtk::Adjustment&gt; m_adjustment, m_adjustment_digits, m_adjustment_pagesize;

  Gtk::VScale m_VScale;
  Gtk::HScale m_HScale, m_Scale_Digits, m_Scale_PageSize;

  Gtk::HSeparator m_Separator;

  Gtk::CheckButton m_CheckButton;

  Gtk::HScrollbar m_Scrollbar;

  Gtk::Menu m_Menu_Position;

  Gtk::Button m_Button_Quit;
};

#endif //GTKMM_EXAMPLE_RANGEWIDGETS_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;iostream&gt;

ExampleWindow::ExampleWindow()
:
  m_VBox2(false, 20),
  m_VBox_HScale(false, 10),
  m_HBox_Scales(false, 10),
  m_HBox_Digits(false, 10),
  m_HBox_PageSize(false, 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) ),
  m_adjustment_pagesize( Gtk::Adjustment::create(1.0, 1.0, 101.0) ),

  m_VScale(m_adjustment),
  m_HScale(m_adjustment),
  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");

  //VScale:
  m_VScale.set_digits(1);
  m_VScale.set_value_pos(Gtk::POS_TOP);
  m_VScale.set_draw_value();

  //HScale:
  m_HScale.set_digits(1);
  m_HScale.set_value_pos(Gtk::POS_TOP);
  m_HScale.set_draw_value();
  m_HScale.set_size_request(200, 30);

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

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

  m_VBox_HScale.pack_start(m_HScale);

  //Scrollbar:
  m_VBox_HScale.pack_start(m_Scrollbar);

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

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

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

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

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

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

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

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

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

void ExampleWindow::on_adjustment1_value_changed()
{
  const double val = m_adjustment_digits-&gt;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-&gt;get_value();
  m_adjustment-&gt;set_page_size(val);
  m_adjustment-&gt;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();
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect1>

</chapter>

<chapter id="chapter-misc-widgets">
<title>Éléments graphiques divers</title>

<sect1 id="sec-labels">
<title>Étiquette</title>

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

<para>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.</para>

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

<para>
Gtk::Label support some simple formatting, for instance allowing you to make some
text bold, colored, or larger. You can do this by providing a string to
<methodname>set_markup()</methodname>, using the <ulink url="http://developer.gnome.org/pango/unstable/PangoMarkupFormat.html">Pango Markup syntax</ulink>. For instance,
<code>
&lt;b&gt;bold text&lt;/b&gt; and &lt;s&gt;strikethrough text&lt;/s&gt;
</code>
.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Label.html">Référence</ulink></para>

<sect2 id="label-example"><title>Exemple</title>
<para>Ci-dessous se trouve un court exemple pour illustrer ces fonctions. Cet exemple utilise l'élément graphique cadre pour mieux séparer les styles d'étiquettes (l'élément graphique cadre est exposé au paragraphe <link linkend="sec-frame">Cadre</link>).</para>

<figure id="figure-label">
  <title>Étiquette</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/label.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/label?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

protected:

  //Child widgets:
  Gtk::HBox m_HBox;
  Gtk::VBox 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
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;iostream&gt;

ExampleWindow::ExampleWindow()
:
  m_HBox(false, 5),
  m_VBox(false, 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\n"
          "Multi-line label.\nFourth line, (j/k)"),
  m_Label_Underlined("This label is underlined!\n"
          "This one is underlined in quite a funky fashion")
{
  set_title("Label");
  set_border_width(5);

  add(m_HBox);

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

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

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

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

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

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

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

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

</sect1>

<sect1 id="sec-text-entry">
<title>Champ de saisie</title>

<sect2 id="sec-text-entry-simple">
<title>Utilisation simple</title>

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

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

<para>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 <methodname>set_visibility()</methodname> avec <literal>false</literal> comme paramètre provoque le masquage du texte.</para>

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Entry.html">Référence</ulink></para>

<sect3 id="entry-example"><title>Exemple simple de saisie</title>
<para>Cet exemple utilise la classe <classname>Gtk::Entry</classname>. Deux cases à cocher de la classe <classname>CheckButton</classname> vous permettent d'inverser les marqueurs « editable » et « visible ».</para>

<figure id="figure-entry-simple">
  <title>Champ de saisie</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/entry.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/entry/simple?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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::HBox m_HBox;
  Gtk::VBox m_VBox;
  Gtk::Entry m_Entry;
  Gtk::Button m_Button_Close;
  Gtk::CheckButton m_CheckButton_Editable, m_CheckButton_Visible;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;iostream&gt;

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

  add(m_VBox);

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

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

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

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

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

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect3>

</sect2>

<sect2 id="sec-text-entry-completion">
<title>Complétion de saisie</title>
<para>Un élément graphique <classname>Entry</classname> peut offrir une liste déroulante de choix préétablis à partir des premiers caractères saisis par l'utilisateur. Par exemple, une boîte de dialogue de recherche peut suggérer un texte en fonction des recherches antérieures.</para>

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

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

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1EntryCompletion.html">Référence</ulink></para>

<sect3 id="entry-completion-example"><title>Exemple de complétion de saisie</title>
<para>Dans cet exemple, nous créons un objet <classname>Gtk::EntryCompletion</classname> et nous l'associons à un élément graphique <classname>Gtk::Entry</classname>. La complétion fait appel à un objet <classname>Gtk::TreeModel</classname> pour les diverses saisies possibles et quelques actions supplémentaires.</para>

<figure id="figure-entry-completion">
  <title>Complétion de saisie</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/entry_completion.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/entry/completion?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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&amp; key, const Gtk::TreeModel::const_iterator&amp; 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&lt;unsigned int&gt; m_col_id;
    Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_name;
  };

  ModelColumns m_Columns;

  typedef std::map&lt;int, Glib::ustring&gt; type_actions_map;
  type_actions_map m_CompletionActions;
  
  //Child widgets:
  Gtk::HBox m_HBox;
  Gtk::VBox m_VBox;
  Gtk::Entry m_Entry;
  Gtk::Label m_Label;
  Gtk::Button m_Button_Close;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;iostream&gt;

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

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

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

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

  //Add an EntryCompletion:
  Glib::RefPtr&lt;Gtk::EntryCompletion&gt; completion =
      Gtk::EntryCompletion::create();
  m_Entry.set_completion(completion);

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

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

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

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

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

  row = *(refCompletionModel-&gt;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-&gt;set_text_column(m_Columns.m_col_name);

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

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

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

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

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

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

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

  return false; //No match.
}
*/

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect3>
</sect2>

<sect2 id="sec-text-entry-icons">
<title>Icône dans un champ de saisie</title>
<para>Un élément graphique <classname>Entry</classname> peut afficher une icône au début ou à la fin de la zone de texte. L'icône est définie par des fonctions membres telles que <methodname>set_icon_from_pixbuf()</methodname> ou <methodname>set_icon_from_stock()</methodname>. Une application peut répondre à un utilisateur qui clique sur l'icône en prenant en charge le signal <methodname>signal_icon_press</methodname>.</para>

<sect3 id="entry-icon-example"><title>Exemple d'icône dans un champ de saisie</title>
<para>Cet exemple montre un élément graphique <classname>Gtk::Entry</classname> avec une icône « rechercher » prise dans le catalogue. Le texte dans le champ de saisie est reproduit dans la fenêtre du terminal quand l'icône est cliquée.</para>

<figure id="figure-entry-icon">
  <title>Saisie avec icône</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/entry_icon.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/entry/icon?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

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

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

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;iostream&gt;

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

  add(m_VBox);

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

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect3>
</sect2>

<sect2 id="sec-text-entry-progress">
<title>Saisie avec barre de progression</title>
<para>Un élément graphique <classname>Entry</classname> 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 <methodname>set_progress_fraction()</methodname> ou <methodname>set_progress_pulse_step()</methodname>.</para>

<sect3 id="entry-progress-example"><title>Exemple de saisie avec barre de progression</title>
<para>Cet exemple montre un élément graphique <classname>Gtk::Entry</classname> avec barre de progression.</para>

<figure id="figure-entry-progress">
  <title>Saisie avec barre de progression</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/entry_progress.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/entry/progress?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

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

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

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;iostream&gt;

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

  add(m_VBox);

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

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

  fraction += 0.01;
  if(fraction &gt; 1)
    fraction = 0;

  return true;
}

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect3>
</sect2>

</sect1>

<sect1 id="sec-spinbutton">
<title>Bouton compteur</title>

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

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

<para>Un objet <classname>SpinButton</classname> utilise un objet <link linkend="chapter-adjustment">Ajustement</link> pour mémoriser l'information sur la plage des valeurs permises. Le compteur utilise les attributs de l'objet Adjustment comme suit : <itemizedlist>
<listitem>

<para><literal>value</literal> : valeur initiale du compteur</para>
</listitem>
<listitem>

<para><literal>lower</literal> : limite inférieure de la plage</para>
</listitem>
<listitem>

<para><literal>upper</literal> : limite supérieure de la plage</para>
</listitem>
<listitem>
<para><literal>step_increment</literal> : valeur de l'incrément/ du décrément lors d'un clic avec le bouton 1 de la souris sur une flèche du compteur</para>
</listitem>
<listitem>

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

<para><literal>page_size</literal> : inutilisé</para>
</listitem>

</itemizedlist></para>

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

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


<sect2 id="spinbutton-methods"><title>Fonctions membres</title>

<para>Le nombre de décimales est modifié à l'aide de la fonction membre <methodname>set_digits()</methodname>.</para>

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

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

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

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

<para>Pour forcer le <classname>SpinButton</classname> à arrondir sa valeur au <literal>step_increment</literal> (pas d'incrément) le plus proche, utilisez la fonction membre <methodname>set_snap_to_ticks()</methodname>.</para>

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1SpinButton.html">Référence</ulink></para>

</sect2>

<sect2 id="spinbutton-example"><title>Exemple</title>

<para>Voici un exemple de <classname>SpinButton</classname> en action :</para>

<figure id="figure-spinbutton">
  <title>Bouton compteur</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/spinbutton.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/spinbutton?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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::HBox m_HBox_NotAccelerated, m_HBox_Accelerated,
    m_HBox_Buttons;
  Gtk::VBox 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&lt;Gtk::Adjustment&gt; 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
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;iostream&gt;
#include &lt;cstdio&gt;

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

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

  m_VBox_Main.pack_start(m_Frame_NotAccelerated);

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

  /* Day, month, year spinners */

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

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

  m_SpinButton_Day.set_wrap();

  m_VBox_Day.pack_start(m_SpinButton_Day);

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

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

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

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

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

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

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

  //Accelerated:
  m_VBox_Main.pack_start(m_Frame_Accelerated);

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

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

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

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

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

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

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

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

  m_VBox_Digits.pack_start(m_SpinButton_Digits);


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

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


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

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

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

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}


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

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

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

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

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

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

  m_Label_ShowValue.set_text(buf);
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

</sect1>

<sect1 id="sec-progressbar">
<title>Barres de progression</title>

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

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

<para>Le paramètre <literal>percentage</literal> est un nombre, entre 0 et 1, indiquant la proportion de remplissage de la barre.</para>

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1ProgressBar.html">Référence</ulink></para>

<sect2 id="progressbar-activity-mode">
<title>Mode activité</title>
<para>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 <emphasis>mode activité</emphasis>. 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).</para>

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

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

<sect2 id="progressbar-example"><title>Exemple</title>

<figure id="figure-progressbar">
  <title>Barres de progression</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/progressbar.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/progressbar?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

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

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

  int m_connection_id_timeout;
  bool m_bActivityMode;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;iostream&gt;

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

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

  m_VBox.pack_start(m_Alignment, Gtk::PACK_SHRINK, 5);
  m_Alignment.add(m_ProgressBar);

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

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

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

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

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_checkbutton_text()
{
  const Glib::ustring text = m_ProgressBar.get_text();

  if(!text.empty())
    m_ProgressBar.set_text("");
  else
    m_ProgressBar.set_text("some 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_orientation()
{
  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 &gt; 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;
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

</sect1>


<sect1 id="sec-infobar">
<title>Infobarre</title>

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1InfoBar.html">Référence</ulink></para>

<sect2 id="infobar-example"><title>Exemple</title>

<figure id="figure-infobar">
  <title>Infobarre</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/infobar.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/infobar?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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::VBox m_VBox;

  Gtk::ScrolledWindow m_ScrolledWindow;
  Gtk::TextView m_TextView;
  
  Glib::RefPtr&lt;Gtk::TextBuffer&gt; m_refTextBuffer;

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

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

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"

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

  add(m_VBox);

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

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

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

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

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

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

  m_VBox.pack_start(m_ScrolledWindow);

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

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

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

  show_all_children();

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

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

ExampleWindow::~ExampleWindow()
{
}

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

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

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

void ExampleWindow::on_textbuffer_changed()
{
  m_Button_Clear.set_sensitive(m_refTextBuffer-&gt;size() &gt; 0);
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

</sect1>

<sect1 id="sec-tooltips">
<title>Infobulles</title>

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Widget.html">Référence pour les éléments graphiques</ulink></para>
<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Tooltip.html">Référence Infobulles</ulink></para>

<sect2 id="tooltip-example"><title>Exemple</title>

<figure id="figure-tooltip">
  <title>Infobulle</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/tooltip.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/tooltips?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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&lt;Gtk::Tooltip&gt;&amp; tooltip);
  bool on_button_query_tooltip(int x, int y, bool keyboard_tooltip, const Glib::RefPtr&lt;Gtk::Tooltip&gt;&amp; tooltip);

  //Child widgets:
  Gtk::VBox m_vbox;

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

  Gtk::ScrolledWindow m_scrolled_window;
  Gtk::TextView m_text_view;
  Glib::RefPtr&lt;Gtk::TextBuffer&gt; m_ref_text_buffer;
  Glib::RefPtr&lt;Gtk::TextTag&gt; m_ref_bold_tag;

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

};

#endif // GTKMM_EXAMPLEWINDOW_H

</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"

#include &lt;vector&gt;

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

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

  add(m_vbox);

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

  //Label:
  m_label.set_tooltip_text("Another tooltip");
  m_vbox.pack_start(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.pack_start(m_button);

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

  connect_signals();

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::prepare_textview()
{
  Gtk::TextIter iter;
  std::vector&lt; Glib::RefPtr&lt;Gtk::TextTag&gt; &gt; tags;

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

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

  iter = m_ref_text_buffer-&gt;end();
  m_ref_text_buffer-&gt;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-&gt;create_tag("bold");
  m_ref_bold_tag-&gt;set_property("weight", Pango::WEIGHT_BOLD);

  tags.push_back(m_ref_bold_tag);

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

  iter = m_ref_text_buffer-&gt;end();
  m_ref_text_buffer-&gt;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, &amp;ExampleWindow::on_markup_checkbutton_click));

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

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

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

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

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

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

  return true;
}

bool ExampleWindow::on_button_query_tooltip(int, int, bool, const Glib::RefPtr&lt;Gtk::Tooltip&gt;&amp;)
{
  //We already have a custom window ready, just return true to show it:
  return true;
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

</sect1>

</chapter>

<chapter id="chapter-container-widgets">
<title>Éléments graphiques conteneurs</title>

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

<sect1 id="sec-single-item-containers">
<title>Conteneurs mono-éléments</title>

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

<para>Nous évoquerons également l'élément graphique <classname>Gtk::Paned</classname> 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é.</para>

<sect2 id="sec-frame">
<title>Cadre</title>

<para>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 <classname>RadioButton</classname> ou de <classname>CheckButton</classname> dans un objet <classname>Frame</classname>.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Frame.html">Référence</ulink></para>

<sect3 id="frame-example"><title>Exemple</title>

<figure id="figure-frame">
  <title>Cadre</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/frame.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/frame?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

protected:

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

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"

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

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

  add(m_Frame);

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

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect3>

</sect2>


<sect2 id="sec-paned">
<title>Volets</title>

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

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

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Paned.html">Référence</ulink></para>

<sect3 id="paned-example"><title>Exemple</title>

<figure id="figure-paned">
  <title>Volets</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/paned.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/paned?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>messageslist.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_MESSAGESLIST_H
#define GTKMM_EXAMPLE_MESSAGESLIST_H

#include &lt;gtkmm.h&gt;

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

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

    ModelColumns()
    { add(m_col_text); }

    Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_text;
  };

  ModelColumns m_Columns;

protected:
  Glib::RefPtr&lt;Gtk::ListStore&gt; m_refListStore; //The Tree Model.
  Gtk::TreeView m_TreeView; //The Tree View.
};
#endif //GTKMM_EXAMPLE_MESSAGESLIST_H
</programlisting>
<para>File: <filename>messagetext.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_MESSAGETEXT_H
#define GTKMM_EXAMPLE_MESSAGETEXT_H

#include &lt;gtkmm.h&gt;

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

  void insert_text();

protected:
  Gtk::TextView m_TextView;
};

#endif //GTKMM_EXAMPLE_MESSAGETEXT_H
</programlisting>
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include "messageslist.h"
#include "messagetext.h"
#include &lt;gtkmm.h&gt;

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

protected:

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

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>messagetext.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "messagetext.h"

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

  add(m_TextView);
  insert_text();

  show_all_children();
}

MessageText::~MessageText()
{
}

void MessageText::insert_text()
{
  Glib::RefPtr&lt;Gtk::TextBuffer&gt; refTextBuffer = m_TextView.get_buffer();

  Gtk::TextBuffer::iterator iter = refTextBuffer-&gt;get_iter_at_offset(0);
  refTextBuffer-&gt;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");
}
</programlisting>
<para>File: <filename>messageslist.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "messageslist.h"
#include &lt;sstream&gt;

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

  add(m_TreeView);

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

  m_TreeView.set_model(m_refListStore);

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

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

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

  show_all_children();
}

MessagesList::~MessagesList()
{
}
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"

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

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect3>

</sect2>

<sect2 id="sec-scrolledwindow">
<title>Fenêtre à défilement</title>

<para>Les éléments graphiques <classname>ScrolledWindow</classname> 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 <classname>ScrolledWindow</classname> ; cet élément graphique restera totalement accessible quelle que soit sa taille grâce aux barres de défilement. Notez que la classe <classname>ScrolledWindow</classname> ne dérive pas de la classe <classname>Gtk::Window</classname>, même si les dénominations peuvent prêter à confusion.</para>

<para>La fenêtre déroulante définit une <emphasis>politique de barres de défilement</emphasis> pour indiquer comment son objet <classname>Scrollbar</classname> doit être affiché. Cette politique est définie à l'aide de la fonction membre <methodname>set_policy()</methodname>. Le paramètre <literal>policy</literal> prend l'une des deux valeurs suivantes : <literal>Gtk::POLICY_AUTOMATIC</literal> ou bien <literal>Gtk::POLICY_ALWAYS</literal>. <literal>Gtk::POLICY_AUTOMATIC</literal> 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 <literal>Gtk::POLICY_ALWAYS</literal>, les barres de défilement sont toujours affichées.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1ScrolledWindow.html">Référence</ulink></para>

<sect3 id="scrolledwindow-example"><title>Exemple</title>

<para>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.</para>

<figure id="figure-scrolledwindow">
  <title>Fenêtre à défilement</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/scrolledwindow.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/scrolledwindow?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

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

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

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;cstdio&gt;

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

  m_ScrolledWindow.set_border_width(10);

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

  get_vbox()-&gt;pack_start(m_ScrolledWindow);

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

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

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

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

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

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect3>

</sect2>

<sect2 id="sec-aspectframe">
<title>Cadre proportionné</title>

<para>L'élément graphique de la classe <classname>AspectFrame</classname> est semblable à l'élément graphique <classname>Frame</classname>, mais, en plus, il impose à l'élément graphique enfant de garder un rapport de <emphasis>proportion</emphasis> (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.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1AspectFrame.html">Référence</ulink></para>

<sect3 id="aspectframe-example">
<title>Exemple</title>
<para>Le programme suivant utilise un objet <classname>Gtk::AspectFrame</classname> 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.</para>

<figure id="figure-aspectframe">
  <title>Cadre proportionné</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/aspectframe.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/aspectframe?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

protected:

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

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"

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

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->
</sect3>

</sect2>


<sect2 id="sec-alignment">
<title>Alignement</title>

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

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Alignment.html">Référence</ulink></para>

<sect3 id="alignment-example">
<title>Exemple</title>
<para>Cet exemple aligne à droite un bouton dans une fenêtre à l'aide de l'élément conteneur <classname>Alignment</classname>.</para>

<figure id="figure-alignment">
  <title>Alignement</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/alignment.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/alignment?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

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

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

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"

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

  add(m_Alignment);

  m_Alignment.add(m_Button);

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

<para>Dans le paragraphe sur les <link linkend="sec-progressbar">Barres de progression</link>, vous pourrez voir un autre exemple d'utilisation de la classe <classname>Alignment</classname>.</para>

</sect3>

</sect2>

</sect1>

<sect1 id="sec-multi-item-containers">
<title>Conteneurs multi-éléments</title>

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

<sect2 id="container-packing">
<title>Empaquetage</title>
<para>Vous avez probablement remarqué que les fenêtres <application>gtkmm</application> 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 ».</para>

<para>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 :</para>

<itemizedlist>

<listitem>
<para>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.</para>
</listitem>

<listitem>
<para>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.</para>
</listitem>

<listitem>
<para>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.</para>
</listitem>

</itemizedlist>

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

<para><application>gtkmm</application> dispose les éléments graphiques de manière hiérarchique en utilisant des <emphasis>conteneurs</emphasis>. Un élément graphique conteneur contient d'autres éléments graphiques. La plupart des éléments graphiques <application>gtkmm</application> 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 <classname>Gtk::Bin</classname> et les conteneurs multi-enfants qui héritent de la classe <classname>Gtk::Container</classname>. La plupart des éléments graphiques de <application>gtkmm</application> dérivent de la classe <classname>Gtk::Bin</classname>, y compris <classname>Gtk::Window</classname>.</para>

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


<itemizedlist>

<listitem>
<para><classname>Gtk::Grid</classname> disposent respectivement leurs éléments graphiques enfants en lignes et en colonnes. Utilisez <methodname>attach()</methodname>, <methodname>attach_next_to()</methodname> et <methodname>add()</methodname> pour insérer des éléments graphiques enfants.</para>
</listitem>

<listitem>
<para><classname>Gtk::VBox</classname> et <classname>Gtk::HBox</classname> disposent respectivement leurs éléments graphiques enfants verticalement et horizontalement. Utilisez <methodname>pack_start()</methodname> et <methodname>pack_end()</methodname> pour insérer des éléments graphiques enfants.</para>
</listitem>

<listitem>
<para><classname>Gtk::Table</classname> place ses éléments graphiques sur une grille. Utilisez <methodname>attach()</methodname> pour insérer les éléments graphiques.</para>
</listitem>

</itemizedlist>

<para>Il existe plusieurs autres conteneurs. Nous en parlerons également.</para>

<para>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.</para>

</sect2>

<sect2 id="sec-helloworld2">
<title>Un Hello World amélioré</title>

<para>Regardons un <literal>helloworld</literal> légèrement perfectionné en se servant de nos nouvelles connaissances.</para>

<figure id="figure-helloworld2">
  <title>Hello World 2</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/helloworld2.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/helloworld2?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>helloworld.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_HELLOWORLD_H
#define GTKMM_EXAMPLE_HELLOWORLD_H

#include &lt;gtkmm/box.h&gt;
#include &lt;gtkmm/button.h&gt;
#include &lt;gtkmm/window.h&gt;

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

protected:

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

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

#endif // GTKMM_EXAMPLE_HELLOWORLD_H
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "helloworld.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<para>File: <filename>helloworld.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "helloworld.h"
#include &lt;iostream&gt;

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

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

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

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

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

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

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

  m_box1.pack_start(m_button2);

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

HelloWorld::~HelloWorld()
{
}

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

</programlisting>
<!-- end inserted example code -->

<para>Après avoir construit et lancé ce programme, essayez de redimensionner la fenêtre pour voir son comportement. Également, essayez de jouer avec les options de la fonction membre <methodname>pack_start()</methodname> après avoir lu le paragraphe relatif aux <link linkend="sec-boxes">boîtes</link>.</para>

</sect2>

<sect2 id="sec-boxes">
<title>Boîtes</title>

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

<sect3 id="boxes-adding-widgets"><title>Ajout d'éléments graphiques</title>
<sect4 id="per-child-packing-options"><title>Options d'empaquetage par enfant</title>
<para>Les fonctions membres <methodname>pack_start()</methodname> et <methodname>pack_end()</methodname> placent les éléments graphiques dans ces conteneurs. La fonction membre <methodname>pack_start()</methodname> débute l'insertion en haut de l'objet <classname>VBox</classname> et va en descendant ; elle empaquette de gauche vers la droite dans un objet <classname>HBox</classname>. La fonction membre <methodname>pack_end()</methodname> fait l'inverse. Elle empaquette de bas en haut dans un <classname>VBox</classname>, de droite à gauche dans un <classname>HBox</classname>. L'utilisation de ces fonctions membres vous permet de justifier à droite ou à gauche les éléments graphiques. Nous nous servirons de <methodname>pack_start()</methodname> dans la plupart de nos exemples.</para>

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

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

<figure id="figure-box-packing1">
  <title>Empaquetage dans boîte n°1</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/box_packing1.png"/>
  </screenshot>
</figure>

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

<para>Voici la déclaration de la fonction membre <methodname>pack_start()</methodname> :</para>
<programlisting>void pack_start(Gtk::Widget&amp; child,
                PackOptions options = PACK_EXPAND_WIDGET,
                guint padding = 0);</programlisting>

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

<para>Le paramètre <parameter>options</parameter> peut prendre une des trois valeurs suivantes : <itemizedlist>
<listitem><para><literal>PACK_SHRINK</literal> : l'espace est condensé à la taille des éléments graphiques enfants. L'élément graphique prend la place qui lui est juste nécessaire et n'est jamais étiré.</para></listitem>
<listitem><para><literal>PACK_EXPAND_PADDING</literal> : l'espace excédentaire est constitué de remplissage. Les éléments graphiques sont régulièrement espacés, mais leurs tailles ne varient pas — des espaces vides sont ménagés entre éléments graphiques.</para></listitem>
<listitem><para><literal>PACK_EXPAND_WIDGET</literal> : l'espace excédentaire est occupé par une augmentation de la taille des éléments graphiques enfants, sans modifier la répartition de l'espacement entre éléments graphiques.</para></listitem>
</itemizedlist></para>

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Box.html">Référence</ulink></para>

</sect4>

<sect4 id="per-container-packing-options"><title>Options d'empaquetage par conteneur</title>
<para>Voici le constructeur des éléments graphiques de la boîte : <programlisting>Gtk::Box(bool homogeneous = false, int spacing = 0);</programlisting> Si le paramètre <parameter>homogeneous</parameter> est défini à <literal>true</literal>, tous les éléments graphiques de la boîte auront la même taille. <parameter>spacing</parameter> représente le nombre de pixels (minimum) à laisser entre chaque élément graphique.</para>

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

<figure id="figure-box-packing2">
  <title>Empaquetage dans boîte n°2</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/box_packing2.png"/>
  </screenshot>
</figure>

</sect4>
</sect3>

<sect3 id="box-packing-example">
<title>Exemple</title>
<para>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.</para>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/box?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>packbox.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_PACKBOX_H
#define GTKMM_EXAMPLE_PACKBOX_H

#include &lt;gtkmm.h&gt;

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

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

  char padstr[80];
};

#endif //GTKMM_EXAMPLE_PACKBOX_H
</programlisting>
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;
#include "packbox.h"

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

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

  //Child widgets:
  Gtk::Button m_button;
  Gtk::VBox m_box1;
  Gtk::HBox m_boxQuit;
  Gtk::Button m_buttonQuit;

  Gtk::Label m_Label1, m_Label2;

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

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include "examplewindow.h"

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

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

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

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

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

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

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

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

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

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

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

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

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

      break;
    }

    case 2:
    {

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

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

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

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


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

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

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

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

      break;
    }

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

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

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

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

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

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

      break;
    }

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

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

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;
#include &lt;iostream&gt;
#include &lt;cstdlib&gt;

using std::atoi;

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

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

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

  return 0;
}
</programlisting>
<para>File: <filename>packbox.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "packbox.h"
#include &lt;cstdio&gt; //For sprintf().

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

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

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

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

</programlisting>
<!-- end inserted example code -->
</sect3>

</sect2>

<sect2 id="sec-buttonbox">
<title>Boîtes à boutons</title>

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

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

<para>Les boutons sont insérés dans l'objet <classname>ButtonBox</classname> à l'aide de la fonction membre <methodname>add()</methodname>.</para>

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

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1ButtonBox.html">Référence</ulink></para>

<sect3 id="buttonbox-example">
<title>Exemple</title>

<figure id="figure-buttonbox">
  <title>Boîte à bouton</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/buttonbox.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/buttonbox?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplebuttonbox.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_BUTTONBOX_H
#define GTKMM_EXAMPLE_BUTTONBOX_H

#include &lt;gtkmm.h&gt;

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

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

#endif //GTKMM_EXAMPLE_BUTTONBOX_H
</programlisting>
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

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

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

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplebuttonbox.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplebuttonbox.h"

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

  if(horizontal)
    bbox = Gtk::manage( new Gtk::HButtonBox() );
  else
    bbox = Gtk::manage( new Gtk::VButtonBox() );

  bbox-&gt;set_border_width(5);

  add(*bbox);

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

  bbox-&gt;add(m_Button_OK);
  bbox-&gt;add(m_Button_Cancel);
  bbox-&gt;add(m_Button_Help);
}

</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include "examplebuttonbox.h"

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

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

  //The horizontal ButtonBoxes:
  m_VBox.set_border_width(10);
  m_Frame_Horizontal.add(m_VBox);

  m_VBox.pack_start(*Gtk::manage(
              new ExampleButtonBox(true, "Spread (spacing 40)", 40,
                  Gtk::BUTTONBOX_SPREAD)),
          Gtk::PACK_EXPAND_WIDGET, 0);

  m_VBox.pack_start(*Gtk::manage(
              new ExampleButtonBox(true, "Edge (spacing 30)", 30,
                  Gtk::BUTTONBOX_EDGE)),
          Gtk::PACK_EXPAND_WIDGET, 5);

  m_VBox.pack_start(*Gtk::manage(
              new ExampleButtonBox(true, "Start (spacing 20)", 20,
                  Gtk::BUTTONBOX_START)),
          Gtk::PACK_EXPAND_WIDGET, 5);

  m_VBox.pack_start(*Gtk::manage(
              new ExampleButtonBox(true, "end (spacing 10)", 10,
                  Gtk::BUTTONBOX_END)),
          Gtk::PACK_EXPAND_WIDGET, 5);


  //The vertical ButtonBoxes:
  m_VBox_Main.pack_start(m_Frame_Vertical, Gtk::PACK_EXPAND_WIDGET, 10);

  m_HBox.set_border_width(10);
  m_Frame_Vertical.add(m_HBox);

  m_HBox.pack_start(*Gtk::manage(
              new ExampleButtonBox(false, "Spread (spacing 5)", 5,
                  Gtk::BUTTONBOX_SPREAD)),
          Gtk::PACK_EXPAND_WIDGET, 0);

  m_HBox.pack_start(*Gtk::manage(
              new ExampleButtonBox(false, "Edge (spacing 30)", 30,
                  Gtk::BUTTONBOX_EDGE)),
          Gtk::PACK_EXPAND_WIDGET, 5);

  m_HBox.pack_start(*Gtk::manage(
              new ExampleButtonBox(false, "Start (spacing 20)", 20,
                  Gtk::BUTTONBOX_START)),
          Gtk::PACK_EXPAND_WIDGET, 5);

  m_HBox.pack_start(*Gtk::manage(new ExampleButtonBox(false, "End (spacing 10)",
                  10, Gtk::BUTTONBOX_END)),
          Gtk::PACK_EXPAND_WIDGET, 5);

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_button_clicked()
{
  hide();
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect3>

</sect2>

<sect2 id="sec-grid">
<title>Grille</title>

<para>
A <classname>Grid</classname> dynamically lays out child widgets in rows and
columns. The dimensions of the grid do not need to be specified in the constructor.
</para>

<para>
Child widgets can span multiple rows or columns, using
<methodname>attach()</methodname>, or added next to an existing widget inside
the grid with <methodname>attach_next_to()</methodname>. Individual rows and columns of the grid can be set to have uniform height or width with
<methodname>set_row_homogeneous()</methodname> and
<methodname>set_column_homogeneous()</methodname>.
</para>
<para>You can set the <emphasis>margin</emphasis> and <emphasis>expand</emphasis> properties of the
child <classname>Widget</classname>s to control their spacing and their behaviour when the Grid is resized.
</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Grid.html">Référence</ulink></para>

<sect3 id="grid-example"><title>Exemple</title>
<para>
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.
</para>

<figure id="figure-grid">
  <title>Grille</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/grid.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/grid?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

private:
  // Signal handlers:
  void on_button_quit();
  void on_button_numbered(const Glib::ustring&amp; data);

  // Child widgets:
  Gtk::Grid m_grid;
  Gtk::Button m_button_1, m_button_2, m_button_quit;
};

#endif /* GTKMM_EXAMPLEWINDOW_H */
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include "examplewindow.h"

ExampleWindow::ExampleWindow()
: m_button_1("button 1"),
  m_button_2("button 2"),
  m_button_quit("Quit")
{
  set_title("Gtk::Grid");
  set_border_width(12);

  add(m_grid);

  m_grid.add(m_button_1);
  m_grid.add(m_button_2);
  m_grid.attach_next_to(m_button_quit, m_button_1, Gtk::POS_BOTTOM, 2, 1);

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

void
ExampleWindow::on_button_numbered(const Glib::ustring&amp; data)
{
  std::cout &lt;&lt; data &lt;&lt; " was pressed" &lt;&lt; std::endl;
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect3>

</sect2>

<sect2 id="sec-table">
<title>Tableau</title>

<para>Les tableaux permettent de placer les éléments graphiques sur une grille, de manière identique à <classname>Gtk::Grid</classname>.</para>

<sect3 id="table-constructor"><title>Constructeur</title>
<para>Il est nécessaire de définir les dimensions de la grille dans le constructeur :</para>
<programlisting>Gtk::Table(int rows = 1, int columns = 1, bool homogeneous = false);</programlisting>

<para>Le premier paramètre est le nombre de lignes du tableau, le second le nombre de colonnes. Si <parameter>homogeneous</parameter> est égal à <literal>true</literal>, toutes les cellules du tableau auront la même taille (la taille du plus grand élément graphique du tableau).</para>

<para>Les lignes et les colonnes sont numérotées à partir de zéro. Si vous définissez <parameter>rows</parameter> = 2 et <parameter>columns</parameter> = 2, la disposition ressemble à ceci :</para>

<programlisting>
 0          1          2
0+----------+----------+
 |          |          |
1+----------+----------+
 |          |          |
2+----------+----------+
</programlisting>

<para>Notez que l'origine du système de coordonnées est l'angle supérieur gauche.</para>
</sect3>

<sect3 id="table-adding-widgets"><title>Ajout d'éléments graphiques</title>
<para>Pour placer un élément graphique dans une cellule, utilisez la fonction membre suivante :</para>
<programlisting>void Gtk::Table::attach(Gtk::Widget&amp; child,
                        guint left_attach, guint right_attach,
                        guint top_attach, guint bottom_attach,
                        guint xoptions = Gtk::FILL | Gtk::EXPAND,
                        guint yoptions = Gtk::FILL | Gtk::EXPAND,
                        guint xpadding = 0, guint ypadding = 0);</programlisting>
<para>Le premier paramètre est l'élément graphique que vous souhaitez placer dans la table.</para>

<para>Les paramètres <parameter>left_attach</parameter> et <parameter>right_attach</parameter> indiquent où placer l'élément graphique et combien de cellules utiliser. Par  exemple, si vous voulez placer un bouton dans la cellule inférieure droite d'un tableau 2 x 2 et souhaitez qu'il occupe <emphasis>uniquement</emphasis> cette cellule, alors <parameter>left_attach</parameter> doit être égal à 1, <parameter>right_attach</parameter> à 2, <parameter>top_attach</parameter> à 1 et <parameter>bottom_attach</parameter> à 2. Si, d'autre part, vous souhaitez que l'élément graphique occupe la totalité de la rangée haute du tableau 2 x 2, vous définirez <parameter>left_attach</parameter> = 0, <parameter>right_attach</parameter> = 2, <parameter>top_attach</parameter> = 0 et <parameter>bottom_attach</parameter> = 1.</para>

<para>Les paramètres <parameter>xoptions</parameter> et <parameter>yoptions</parameter> s'utilisent pour définir les options d'empaquetage. Pour définir des options multiples, il convient de les lier entre elles avec l'opérateur binaire OR. Ces options sont :</para>

<para>
<variablelist>

<varlistentry>
<term><literal>Gtk::FILL</literal></term>
<listitem>
<para>Si la cellule du tableau est plus grande que l'élément graphique et si <literal>Gtk::FILL</literal> est indiqué, l'élément graphique sera étiré pour utiliser toute la place disponible.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><literal>Gtk::SHRINK</literal></term>
<listitem>
<para>Si l'élément graphique tableau dispose de moins de place que nécessaire (parce que l'utilisateur a redimensionné la fenêtre), les éléments graphiques dans les cellules vont être cachés par le bas de la fenêtre. Si <literal>Gtk::SHRINK</literal> est indiqué, les éléments graphiques vont rétrécir avec le tableau.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><literal>Gtk::EXPAND</literal></term>
<listitem>
<para>Cette option va provoquer l'étalement du tableau jusqu'à occuper tout l'espace libre de la fenêtre.</para>
</listitem>
</varlistentry>

</variablelist>
</para>

<para>Les paramètres de remplissage fonctionnent exactement comme pour la fonction membre <methodname>pack_start()</methodname>.</para>
</sect3>

<sect3 id="table-other-methods"><title>Autres fonctions membres</title>

<para><methodname>set_row_spacing()</methodname> et <methodname>set_col_spacing()</methodname> définissent l'espacement entre lignes ou entre colonnes pour la ligne ou la colonne indiquée. Notez que, pour les colonnes, l'espacement se situe à droite de la colonne et que, pour les lignes, l'espacement se situe sous la ligne.</para>

<para>Vous pouvez également fixer un espacement d'ensemble pour toutes les lignes et toutes les colonnes avec <methodname>set_row_spacings()</methodname> et <methodname>set_col_spacings()</methodname>. Notez qu'avec ces fonctions membres, la dernière ligne et la dernière colonne n'ont pas l'espacement indiqué.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Table.html">Référence</ulink></para>

</sect3>

<sect3 id="table-example"><title>Exemple</title>
<para>Dans l'exemple ci-après, nous créons une fenêtre avec trois boutons dans un tableau 2 x 2. Les deux premiers boutons sont placés dans la ligne supérieure. Le troisième bouton est placé dans la ligne inférieure et occupe les deux colonnes.</para>

<figure id="figure-table">
  <title>Tableau</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/table.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/table?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

protected:
  //Signal handlers:
  void on_button_quit();
  void on_button_numbered(Glib::ustring data);

  //Child widgets:
  Gtk::Table m_Table;
  Gtk::Button m_Button_1, m_Button_2, m_Button_Quit;

};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include "examplewindow.h"

ExampleWindow::ExampleWindow()
: m_Table(2, 2, true),
  m_Button_1("button 1"),
  m_Button_2("button 2"),
  m_Button_Quit("Quit")
{
  set_title("Gtk::Table");
  set_border_width(20);

  add(m_Table);

  m_Table.attach(m_Button_1, 0, 1, 0, 1);
  m_Table.attach(m_Button_2, 1, 2, 0, 1);
  m_Table.attach(m_Button_Quit, 0, 2, 1, 2);

  m_Button_1.signal_clicked().connect(
          sigc::bind&lt;Glib::ustring&gt;( sigc::mem_fun(*this,
                  &amp;ExampleWindow::on_button_numbered), "button 1") );
  m_Button_2.signal_clicked().connect(
          sigc::bind&lt;Glib::ustring&gt;( sigc::mem_fun(*this,
                  &amp;ExampleWindow::on_button_numbered), "button 2") );

  m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_quit) );

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

void
ExampleWindow::on_button_numbered(Glib::ustring data)
{
  std::cout &lt;&lt; "Hello again - " &lt;&lt; data &lt;&lt; " was pressed" &lt;&lt; std::endl;
}

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect3>

</sect2>

<sect2 id="sec-notebook">
<title>Bloc-note</title>

<para>L'objet <classname>Notebook</classname> est constitué d'un jeu de <literal>pages</literal> empilées, chacune contenant des éléments graphiques. Les onglets étiquetés permettent à l'utilisateur de choisir les pages. <classname>Notebook</classname> 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.</para>

<para>Servez-vous des fonctions membres <methodname>append_page()</methodname>, <methodname>prepend_page()</methodname> et <methodname>insert_page()</methodname> pour ajouter des pages à onglets dans l'objet <literal>Notebook</literal> en précisant l'élément graphique enfant et le nom de l'onglet.</para>

<para>Pour connaître la page actuellement affichée, utilisez la fonction membre <methodname>get_current_page()</methodname>. Elle renvoie un numéro de page, puis, en appelant <methodname>get_nth_page()</methodname> avec ce numéro de page, vous obtiendrez un pointeur sur l'élément graphique enfant de la page.</para>

<para>Pour changer de page sélectionnée au cours du programme, utilisez la fonction membre <methodname>set_current_page()</methodname>.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Notebook.html">Référence</ulink></para>

<sect3 id="notebook-example"><title>Exemple</title>

<figure id="figure-notebook">
  <title>Bloc-note</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/notebook.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/notebook/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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::VBox m_VBox;
  Gtk::Notebook m_Notebook;
  Gtk::Label m_Label1, m_Label2;

  Gtk::HButtonBox m_ButtonBox;
  Gtk::Button m_Button_Quit;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include "examplewindow.h"

ExampleWindow::ExampleWindow()
: m_Label1("Contents of tab 1"),
  m_Label2("Contents of tab 2"),
  m_Button_Quit("Quit")
{
  set_title("Gtk::Notebook example");
  set_border_width(10);
  set_default_size(400, 200);


  add(m_VBox);

  //Add the Notebook, with the button underneath:
  m_Notebook.set_border_width(10);
  m_VBox.pack_start(m_Notebook);
  m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

  m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
  m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;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,
              &amp;ExampleWindow::on_notebook_switch_page) );

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

void ExampleWindow::on_notebook_switch_page(Gtk::Widget* /* page */, guint page_num)
{
  std::cout &lt;&lt; "Switched to tab with index " &lt;&lt; page_num &lt;&lt; std::endl;

  //You can also use m_Notebook.get_current_page() to get this index.
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect3>

</sect2>

<sect2 id="sec-assistant">
<title>Assistant</title>

<para>Un objet <classname>Assistant</classname> 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 <methodname>set_page_type()</methodname>.</para>

<para>Utilisez les fonctions membres <methodname>append_page()</methodname>, <methodname>prepend_page</methodname> et <methodname>insert_page()</methodname> pour ajouter des pages à un objet <classname>Assistant</classname>, tout en indiquant l'élément graphique enfant pour chacune d'entre elles.</para>

<para>Pour connaître la page en cours d'utilisation, servez-vous de la fonction membre <methodname>get_current_page()</methodname>, passez le résultat à <methodname>get_nth_page()</methodname> qui vous renverra un pointeur sur l'élément graphique affiché. Pour changer en cours de programme la page active, utilisez la fonction membre <methodname>set_current_page()</methodname>.</para>

<para>Pour définir le titre de la page, servez-vous de la fonction membre <methodname>set_page_title()</methodname>. Les images de l'en-tête et du côté de la page sont insérées avec les fonctions membres <methodname>set_page_header_image()</methodname> et <methodname>set_page_side_image()</methodname>.</para>

<para>Pour ajouter des éléments graphiques dans la zone d'action, utilisez la fonction membre <methodname>add_action_widget()</methodname>. Ils seront empaquetés à côté des boutons par défaut. Servez-vous de la fonction membre <methodname>remove_action_widget()</methodname> pour enlever des éléments graphiques.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Assistant.html">Référence</ulink></para>

<sect3 id="assistant-example"><title>Exemple</title>

<figure id="figure-assistant">
  <title>Assistant</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/assistant.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/assistant/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>exampleassistant.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEASSISTANT_H
#define GTKMM_EXAMPLEASSISTANT_H

#include &lt;gtkmm.h&gt;

class ExampleAssistant : public Gtk::Assistant
{
public:
  ExampleAssistant();
  virtual ~ExampleAssistant();

  void get_result(bool&amp; check_state, Glib::ustring&amp; 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::HBox m_box;
  Gtk::Label m_label1, m_label2;
  Gtk::CheckButton m_check;
  Gtk::Entry m_entry;
};

#endif /* GTKMM_EXAMPLEASSISTANT_H */
</programlisting>
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include "exampleassistant.h"
#include &lt;gtkmm.h&gt;

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

private:
  // Signal handlers:
  void on_button_clicked();
  void on_assistant_apply();

  // Child widgets:
  Gtk::Table m_table;
  Gtk::Button m_button;
  Gtk::Label m_label1, m_label2;
  Gtk::CheckButton m_check;
  Gtk::Entry m_entry;
  ExampleAssistant m_assistant;
};

#endif /* GTKMM_EXAMPLEWINDOW_H */
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include "exampleassistant.h"

ExampleWindow::ExampleWindow()
: m_table(3, 2),
  m_button("Show the assistant"),
  m_label1("State of assistant checkbutton:"),
  m_label2("Contents of assistant entry:")
{
  set_title("Gtk::Assistant example");
  set_border_width(12);

  m_table.attach(m_button, 0, 2, 0, 1, Gtk::FILL, Gtk::EXPAND);
  m_table.attach(m_label1, 0, 1, 1, 2, Gtk::FILL, Gtk::EXPAND);
  m_table.attach(m_label2, 0, 1, 2, 3, Gtk::FILL, Gtk::EXPAND);
  m_table.attach(m_check, 1, 2, 1, 2);
  m_table.attach(m_entry, 1, 2, 2, 3);
  add(m_table);

  m_label1.set_alignment(0.0, 0.5);
  m_label2.set_alignment(0.0, 0.5);

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

  m_check.set_sensitive(false);
  m_entry.set_sensitive(false);

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_assistant_apply()
{
  bool check_state;
  Glib::ustring entry_text;

  m_assistant.get_result(check_state, entry_text);
  m_check.set_active(check_state);
  m_entry.set_text(entry_text);
}

void ExampleWindow::on_button_clicked()
{
  m_assistant.show();
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<para>File: <filename>exampleassistant.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include "exampleassistant.h"

ExampleAssistant::ExampleAssistant()
: m_box(false, 12),
  m_label1("Type text to allow the assistant to continue:"),
  m_label2("Confirmation page"),
  m_check("Optional extra information")
{
  set_title("Gtk::Assistant example");
  set_border_width(12);
  set_default_size(400, 300);

  m_box.pack_start(m_label1);
  m_box.pack_start(m_entry);

  append_page(m_box);
  append_page(m_check);
  append_page(m_label2);

  set_page_title(*get_nth_page(0), "Page 1");
  set_page_title(*get_nth_page(1), "Page 2");
  set_page_title(*get_nth_page(2), "Confirmation");

  set_page_complete(m_check, true);
  set_page_complete(m_label2, true);

  set_page_type(m_box, Gtk::ASSISTANT_PAGE_INTRO);
  set_page_type(m_label2, Gtk::ASSISTANT_PAGE_CONFIRM);

  signal_apply().connect(sigc::mem_fun(*this,
    &amp;ExampleAssistant::on_assistant_apply));
  signal_cancel().connect(sigc::mem_fun(*this,
    &amp;ExampleAssistant::on_assistant_cancel));
  signal_close().connect(sigc::mem_fun(*this,
    &amp;ExampleAssistant::on_assistant_close));
  signal_prepare().connect(sigc::mem_fun(*this,
    &amp;ExampleAssistant::on_assistant_prepare));

  m_entry.signal_changed().connect(sigc::mem_fun(*this,
    &amp;ExampleAssistant::on_entry_changed));

  show_all_children();
}

ExampleAssistant::~ExampleAssistant()
{
}

void ExampleAssistant::get_result(bool&amp; check_state, Glib::ustring&amp; entry_text)
{
  check_state = m_check.get_active();
  entry_text = m_entry.get_text();
}

void ExampleAssistant::on_assistant_apply()
{
  std::cout &lt;&lt; "Apply was clicked";
  print_status();
}

void ExampleAssistant::on_assistant_cancel()
{
  std::cout &lt;&lt; "Cancel was clicked";
  print_status();
  hide();
}

void ExampleAssistant::on_assistant_close()
{
  std::cout &lt;&lt; "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 &lt;&lt; ", entry contents: \"" &lt;&lt; m_entry.get_text()
    &lt;&lt; "\", checkbutton status: " &lt;&lt; m_check.get_active() &lt;&lt; std::endl;
}
</programlisting>
<!-- end inserted example code -->

</sect3>

</sect2>

</sect1>

</chapter>

<chapter id="chapter-treeview">

<title>L'élément graphique arborescence</title>
<para>L'élément graphique <classname>Gtk::TreeView</classname> peut incorporer des listes ou des arborescences de données, disposées en colonnes.</para>

<sect1 id="sec-treeview-model">
<title>Le modèle</title>
<para>Chaque objet <classname>Gtk::TreeView</classname> possède un objet <classname>Gtk::TreeModel</classname> associé ; il contient les données à afficher par l'objet <classname>TreeView</classname>. Tout <classname>Gtk::TreeModel</classname> peut être utilisé par plus d'un <classname>Gtk::TreeView</classname>. 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.</para>
<para>Même si vous pouvez théoriquement implémenter votre propre modèle, vous utiliserez normalement, soit la classe modèle <classname>ListStore</classname>, soit la classe modèle <classname>TreeStore</classname>.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1TreeModel.html">Référence</ulink></para>

<sect2 id="treeview-model-liststore">
<title>Modèle listStore, pour des colonnes</title>
<para>Un objet <classname>ListStore</classname> contient de simples colonnes de données et chaque colonne n'a pas d'enfant.</para>

<figure id="figure-treeview-liststore-model">
  <title>TreeView - ListStore</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/treeview_list.png"/>
  </screenshot>
</figure>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1ListStore.html">Référence</ulink></para>

</sect2>

<sect2 id="treeview-model-treestore">
<title>Modèle treeStore, pour une hiérarchie</title>
<para>L'objet <classname>TreeStore</classname> contient des colonnes de données et chaque colonne peut avoir des colonnes enfants.</para>

<figure id="figure-treeview-treestore-model">
  <title>TreeView - TreeStore</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/treeview_tree.png"/>
  </screenshot>
</figure>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1TreeStore.html">Référence</ulink></para>

</sect2>

<sect2 id="treeview-model-columns">
<title>Modèle colonnes</title>
<para>La classe <classname>TreeModelColumnRecord</classname> s'utilise pour enregistrer les colonnes et leurs types de données. Vous ajoutez des exemplaires de <classname>TreeModelColumn</classname> au <classname>ColumnRecord</classname>, puis utilisez ces <classname>TreeModelColumns</classname> pour obtenir ou placer les données dans les colonnes du modèle. Vous trouverez certainement commode de dériver un nouveau <classname>TreeModelColumnRecord</classname> incorporant vos exemplaires de <classname>TreeModelColumn</classname> en tant que données membres.</para>

<programlisting>class ModelColumns : public Gtk::TreeModelColumnRecord
{
public:

  ModelColumns()
    { add(m_col_text); add(m_col_number); }

  Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_text;
  Gtk::TreeModelColumn&lt;int&gt; m_col_number;
};

ModelColumns m_Columns;</programlisting>

<para>Vous précisez le <classname>ColumnRecord</classname> à la création du modèle, ainsi :</para>
<programlisting>Glib::RefPtr&lt;Gtk::ListStore&gt; refListStore =
    Gtk::ListStore::create(m_Columns);</programlisting>
<para>Notez que les exemplaires de colonnes (tels que m_Columns ici) ne sont habituellement pas qualifiés « static », étant donné qu'ils doivent être instanciés après que glibmm l'ait été lui-même.</para>
</sect2>

<sect2 id="treeview-adding-rows">
<title>Ajout de lignes</title>
<para>Ajoutez des lignes au modèle avec les fonctions membres <methodname>append()</methodname>, <methodname>prepend()</methodname> ou <methodname>insert()</methodname>.</para>
<programlisting>Gtk::TreeModel::iterator iter = m_refListStore-&gt;append();</programlisting>
<para>Vous pouvez déréférencer l'itérateur pour obtenir la ligne :</para>
<programlisting>Gtk::TreeModel::Row row = *iter;</programlisting>
<sect3 id="treeview-adding-child-rows"><title>Ajout de colonnes enfants</title>
<para>Les modèles <classname>Gtk::TreeStore</classname> peuvent avoir des éléments enfants. Pour les ajouter, servez-vous des fonctions membres <methodname>append()</methodname>, <methodname>prepend()</methodname> ou <methodname>insert()</methodname>, ainsi : </para>
<programlisting>Gtk::TreeModel::iterator iter_child =
    m_refListStore-&gt;append(row.children());</programlisting>
</sect3>

</sect2>

<sect2 id="treeview-setting-values">
<title>Définition des valeurs</title>
<para>Vous pouvez utiliser la surdéfinition de <methodname>operator[]</methodname> pour définir les données d'une colonne désignée dans la ligne en indiquant le <classname>TreeModelColumn</classname> utilisé pour créer le modèle.</para>
<programlisting>row[m_Columns.m_col_text] = "textedonné";</programlisting>
</sect2>

<sect2 id="treeview-getting-values">
<title>Obtention des valeurs</title>
<para>Vous pouvez utiliser la surdéfinition de <methodname>operator[]</methodname> pour obtenir les données d'une colonne particulière dans une ligne, en précisant le <classname>TreeModelColumn</classname> qui a été utilisé pour créer le modèle.</para>
<programlisting>Glib::ustring strText = row[m_Columns.m_col_text];
int number = row[m_Columns.m_col_number];</programlisting>
<para>Le compilateur se plaint si vous utilisez un type inapproprié et génère, par exemple, l'erreur de compilation suivante :</para>
<programlisting>//compiler error - no conversion from ustring to int.
int number = row[m_Columns.m_col_text];</programlisting>
</sect2>

<sect2 id="treeview-hidden-columns">
<title>Colonnes « cachées »</title>
<para>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.</para>
</sect2>

</sect1>

<sect1 id="sec-treeview">
<title>La vue</title>
<para>La vue est l'élément graphique (<classname>Gtk::TreeView</classname>) qui affiche concrètement les données du modèle (<classname>Gtk::TreeModel</classname>) et qui autorise l'utilisateur à interagir. Elle peut afficher, de diverses manières, toutes les colonnes du modèle ou seulement quelques unes.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1TreeView.html">Référence</ulink></para>

<sect2 id="sec-treeview-using-a-model">
<title>Utilisation d'un modèle</title>
<para>Vous pouvez définir le modèle <classname>Gtk::TreeModel</classname> à la construction de l'objet vue <classname>Gtk::TreeView</classname> ou bien vous pouvez utiliser la fonction membre <methodname>set_model()</methodname>, comme suit :</para>
<programlisting>m_TreeView.set_model(m_refListStore);</programlisting>
</sect2>

<sect2 id="treeview-adding-view-columns">
<title>Ajout de colonnes à la vue</title>
<para>Vous pouvez utiliser la fonction membre <methodname>append_column()</methodname> pour demander à la vue d'afficher certaines colonnes du modèle, dans un certain ordre, avec un certain intitulé.</para>
<programlisting>m_TreeView.append_column("Messages", m_Columns.m_col_text);</programlisting>
<para>En utilisant cette simple surdéfinition de <methodname>append_column()</methodname>, l'objet <classname>TreeView</classname> affiche la donnée du modèle avec un <classname>CellRenderer</classname> approprié. Par exemple, les chaînes littérales et les nombres sont affichés dans un simple contrôle <classname>Gtk::Entry</classname> et les booléens dans un <classname>Gtk::CheckButton</classname>. Cela correspond aux besoins habituels. Pour des colonnes relatives à d'autres types, vous pouvez, soit connecter une fonction de rappel qui convertit avec <methodname>TreeViewColumn::set_cell_data_func()</methodname> le type en chaîne littérale le représentant, soit créer par dérivation un <classname>CellRenderer</classname> personnalisé. Notez que le type <literal>(unsigned) short</literal> n'est pas pris en charge par défaut — à la place, vous pouvez utiliser le type <literal>(unsigned) int</literal> ou <literal>(unsigned) long</literal>.</para>
</sect2>

<sect2 id="treeview-multiple-model-columns-per-view-column">
<title>Plus d'une colonne de modèle par colonne de vue</title>
<para>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 <classname>TreeView::Column</classname> manuellement et d'utiliser la fonction membre <methodname>pack_start()</methodname> pour y ajouter les colonnes du modèle.</para>

<para>Ensuite, avec <methodname>append_column()</methodname>, ajoutez la colonne à la vue. Vous noterez que <methodname>Gtk::View::append_column()</methodname> a été surdéfini pour accepter, soit un élément graphique <classname>Gtk::View::Column</classname> préalablement construit, soit uniquement un <classname>TreeModelColumn</classname> à partir duquel cette fonction membre génére un élément graphique <classname>Gtk::View::Column</classname> approprié.</para>
<para>Voici quelques exemples de code extraits de <filename>demos/gtk-demo/example_stockbrowser.cc</filename>, qui possède une icône pixelisée et du texte dans une même colonne :</para>
<programlisting>Gtk::TreeView::Column* pColumn =
    Gtk::manage( new Gtk::TreeView::Column("Symbole") );

// m_columns.icon et m_columns.symbol sont des colonnes du modèle.
// pColumn est la colonne dans l'objet TreeView :
pColumn-&gt;pack_start(m_columns.icon, false); //false = ne pas développer.
pColumn-&gt;pack_start(m_columns.symbol);

m_TreeView.append_column(*pColumn);</programlisting>
</sect2>

<sect2 id="treeview-cellrenderer-details">
<title>Détails pour la définition du CellRenderer</title>
<para>Le comportement par défaut de la classe <classname>CellRenderers</classname> suffit en règle générale, mais vous pouvez dans certains cas avoir besoin d'un contrôle plus fin. Ainsi, cet exemple de code, pris dans <filename>demos/gtk-demo/example_treestore.cc</filename>, construit manuellement un élément graphique <classname>Gtk::CellRenderer</classname> et le programme pour qu'il effectue un rendu avec variations d'aspect selon les données des diverses colonnes du modèle.</para>
<programlisting>Gtk::CellRendererToggle* pRenderer =
    Gtk::manage( new Gtk::CellRendererToggle() );
int cols_count = m_TreeView.append_column("Alex", *pRenderer);
Gtk::TreeViewColumn* pColumn = m_TreeView.get_column(cols_count-1);
if(pColumn)
{
  pColumn-&gt;add_attribute(pRenderer-&gt;property_active(),
      m_columns.alex);
  pColumn-&gt;add_attribute(pRenderer-&gt;property_visible(),
      m_columns.visible);
  pColumn-&gt;add_attribute(pRenderer-&gt;property_activatable(),
      m_columns.world);</programlisting>

<para>Vous pouvez aussi connecter les signaux du <classname>CellRenderer</classname> pour détecter des actions utilisateur. Par exemple :</para>
<programlisting>Gtk::CellRendererToggle* pRenderer =
    Gtk::manage( new Gtk::CellRendererToggle() );
pRenderer-&gt;signal_toggled().connect(
    sigc::bind( sigc::mem_fun(*this,
        &amp;Example_TreeView_TreeStore::on_cell_toggled), m_columns.dave)
);</programlisting>
</sect2>

<sect2 id="treeview-editable-cells">
<title>Cellules modifiables</title>

<sect3 id="treeview-editable-cells-automatic">
<title>Cellules modifiables à enregistrement automatique.</title>
<para>Des cellules d'un objet <classname>TreeView</classname> peuvent être modifiées in-situ par l'utilisateur. Pour permettre ce comportement, utilisez les fonctions membres <classname>Gtk::TreeView</classname><methodname>insert_column_editable()</methodname> et <methodname>append_column_editable()</methodname> au lieu de <methodname>insert_column()</methodname> et <methodname>append_column()</methodname>. Quand ces colonnes sont modifiées, les nouvelles valeurs sont immédiatement enregistrées dans le modèle. Notez que ces fonctions membres sont des prototypes qui ne peuvent être utilisés que dans le cas de types de colonnes simples tels que des <classname>Glib::ustring</classname>, des <literal>int</literal> et des <literal>long</literal>.</para>
</sect3>

<sect3 id="treeview-editable-cells-custom">
<title>Implémentation d'une logique personnalisée pour les cellules modifiables.</title>
<para>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.</para>
<para>Pour réaliser cela, utilisez les fonctions membres normales <classname>Gtk::TreeView</classname><methodname>insert_column()</methodname> et <methodname>append_column()</methodname>, puis, avec <methodname>get_column_cell_renderer()</methodname>, obtenez le pointeur sur le <classname>Gtk::CellRenderer</classname> utilisé par cette colonne.</para>
<para>Ensuite vous ferez un forçage du type de ce pointeur <classname>Gtk::CellRenderer*</classname> vers un <classname>CellRenderer</classname> donné, conforme à vos attentes. Vous utilisez ainsi une API particulière.</para>
<para>Par exemple, pour un CellRendererText, vous définissez la propriété <emphasis>editable</emphasis> égale à <literal>true</literal>, comme ceci :</para>
<programlisting>cell.property_editable() = true;</programlisting>
<para>Pour un « CellRendererToggle », vous paramétrez la propriété <emphasis>activatable</emphasis> à la place.</para>
<para>Vous pouvez alors connecter le signal « edited » approprié, par exemple, connecter à <methodname>Gtk::CellRendererText::signal_edited()</methodname> ou <methodname>Gtk::CellRendererToggle::signal_toggled()</methodname>. Si la colonne comprend plus d'un <classname>CellRenderer</classname>, vous aurez besoin d'utiliser <methodname>Gtk::TreeView::get_column()</methodname>, puis d'appeler <methodname>get_cell_renderers()</methodname> sur cette colonne de la vue.</para>
<para>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.</para>
</sect3>

</sect2>


</sect1>

<sect1 id="sec-iterating-over-model-rows">
<title>Itération parmi les colonnes du modèle</title>
<para><classname>Gtk::TreeModel</classname> fournit un conteneur dans le style de la bibliothèque standard C++ pour ses enfants par l'intermédiaire de la fonction membre <methodname>children()</methodname>. Vous pouvez utiliser les fonctions membres habituelles <methodname>begin()</methodname> et <methodname>end()</methodname> pour incrémenter un itérateur, comme ceci :</para>
<programlisting>typedef Gtk::TreeModel::Children type_children; // minimise la longueur du code.
type_children children = refModel-&gt;children();
for(type_children::iterator iter = children.begin();
    iter != children.end(); ++iter)
{
  Gtk::TreeModel::Row row = *iter;
  // Faire quelque chose avec la ligne - voir plus haut pour set/get.
}</programlisting>

<sect2 id="treeview-row-children">
<title>Ligne enfant</title>
<para>Si vous vous servez d'un objet <classname>Gtk::TreeStore</classname>, les lignes peuvent avoir des lignes enfants qui, à leur tour, peuvent avoir leur propres enfants. Utilisez <methodname>Gtk::TreeModel::Row::children()</methodname> pour obtenir le conteneur des objets <classname>Row</classname> enfants : <programlisting>Gtk::TreeModel::Children children = row.children();</programlisting></para>
</sect2>

</sect1>

<sect1 id="sec-treeview-selection">
<title>La sélection</title>
<para>Pour retrouver quelles sont les lignes sélectionnées par l'utilisateur, obtenez l'objet <classname>Gtk::TreeView::Selection</classname> du <classname>TreeView</classname> ainsi :</para>
<programlisting>Glib::RefPtr&lt;Gtk::TreeSelection&gt; refTreeSelection =
    m_TreeView.get_selection();</programlisting>

<sect2 id="treeview-selection-mode">
<title>Sélection simple ou multiple</title>
<para>Par défaut, vous ne pouvez sélectionner qu'une seule ligne, mais la sélection multiple est possible en activant le mode correspondant, comme ceci : <programlisting>refTreeSelection-&gt;set_mode(Gtk::SELECTION_MULTIPLE);</programlisting></para>
</sect2>

<sect2 id="treeview-selected-rows">
<title>Les lignes sélectionnées</title>
<para>Pour une simple sélection, appelez simplement la fonction membre <methodname>get_selected()</methodname>, comme suit :</para>
<programlisting>TreeModel::iterator iter = refTreeSelection-&gt;get_selected();
if(iter) // si quelque chose est sélectionné
{
  TreeModel::Row row = *iter;
  // Faire quelque chose avec la ligne.
}</programlisting>

<para>Pour une sélection multiple, vous aurez besoin de définir une fonction de rappel et de la fournir en paramètre à <methodname>selected_foreach()</methodname>, <methodname>selected_foreach_path()</methodname> ou <methodname>selected_foreach_iter()</methodname>, ainsi :</para>
<programlisting>refTreeSelection-&gt;selected_foreach_iter(
    sigc::mem_fun(*this, &amp;TheClass::selected_row_callback) );

void TheClass::selected_row_callback(
    const Gtk::TreeModel::iterator&amp; iter)
{
  TreeModel::Row row = *iter;
  // Faire quelque chose avec la ligne.
}</programlisting>

</sect2>

<sect2 id="treeview-selection-changed-signal">
<title>Le signal « changed »</title>
<para>Pour répondre à l'utilisateur qui clique sur une ligne ou une plage de lignes, connectez le signal ainsi :</para>
<programlisting>refTreeSelection-&gt;signal_changed().connect(
    sigc::mem_fun(*this, &amp;Example_StockBrowser::on_selection_changed)
);</programlisting>
</sect2>

<sect2 id="treeview-selection-preventing">
<title>Empêcher la sélection de lignes</title>
<para>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.</para>
<para>Pour contrôler quelles lignes peuvent être sélectionnées, utilisez la fonction membre <methodname>set_select_function()</methodname> et passez lui en paramètre un signal de rappel <classname>sigc::slot</classname>. Par exemple :</para>
<programlisting>m_refTreeSelection-&gt;set_select_function( sigc::mem_fun(*this,
    &amp;DemoWindow::select_function) );</programlisting>
<para>puis</para>
<programlisting>bool DemoWindow::select_function(
    const Glib::RefPtr&lt;Gtk::TreeModel&gt;&amp; model,
    const Gtk::TreeModel::Path&amp; path, bool)
{
  const Gtk::TreeModel::iterator iter = model-&gt;get_iter(path);
  // n'autoriser que la sélection des nœuds d'extrémité
  return iter-&gt;children().empty(); 
}</programlisting>
</sect2>

<sect2 id="treeview-selection-changing">
<title>Modification de la sélection</title>
<para>Pour modifier la sélection, précisez un <classname>Gtk::TreeModel::iterator</classname> ou <classname>Gtk::TreeModel::Row</classname>, ainsi :</para>
<programlisting>Gtk::TreeModel::Row row = m_refModel-&gt;children()[5]; // 5ième ligne.
if(row)
  refTreeSelection-&gt;select(row);</programlisting>
<para>ou</para>
<programlisting>Gtk::TreeModel::iterator iter = m_refModel-&gt;children().begin()
if(iter)
  refTreeSelection-&gt;select(iter);</programlisting>
</sect2>

</sect1>


<sect1 id="sec-treeview-sort">
<title>Tris</title>
<para>Les modèles standard d'arborescence (<classname>TreeStore</classname> et <classname>ListStore</classname>) dérivent de la classe <classname>TreeSortable</classname> ; ils offrent donc la possibilité de tri. Par exemple, faites appel à <methodname>set_sort_column()</methodname> pour trier le modèle sur la colonne donnée, ou bien définissez une fonction de rappel pour <methodname>set_sort_func()</methodname> pour implémenter un algorithme de tri plus complexe.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1TreeSortable.html">Référence de TreeSortable</ulink></para>

<sect2 id="treeview-sort-headers">
<title>Tri en cliquant sur l'en-tête de colonne</title>
<para>Pour implémenter le tri par clic sur l'en-tête d'une colonne d'un objet <classname>TreeView</classname> afin d'ordonner son contenu, appelez <methodname>Gtk::TreeViewModel::set_sort_column()</methodname> en indiquant la colonne du modèle sur laquelle le tri est effectué quand l'en-tête est cliquée. Par exemple :</para>
<programlisting>Gtk::TreeView::Column* pColumn = treeview.get_column(0);
if(pColumn)
  pColumn-&gt;set_sort_column(m_columns.m_col_id);</programlisting>
</sect2>

<sect2 id="treeview-sort-independent-views">
<title>Vues d'un même modèle triées de manière indépendante</title>
<para>Nous avons déjà vu que la classe <classname>TreeView</classname> vous permet d'afficher le même <classname>TreeModel</classname> dans deux éléments graphiques <classname>TreeView</classname> distincts. Si vous avez besoin qu'un des TreeView trie le modèle de manière différente de l'autre, vous devez utiliser un objet <classname>TreeModelSort</classname> au lieu d'utiliser uniquement <methodname>Gtk::TreeViewModel::set_sort_column()</methodname>, par exemple. <classname>TreeModelSort</classname> est un modèle contenant une version triée d'un autre modèle. Par exemple, vous pouvez ajouter une autre version triée d'un modèle à un objet <classname>TreeView</classname> ainsi :</para>
<programlisting>Glib::RefPtr&lt;Gtk::TreeModelSort&gt; sorted_model =
    Gtk::TreeModelSort::create(model);
sorted_model-&gt;set_sort_column(columns.m_col_name, Gtk::SORT_ASCENDING);
treeview.set_model(sorted_model);</programlisting>

<para>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 :</para>
<programlisting>void ExampleWindow::on_button_delete()
{
  Glib::RefPtr&lt;Gtk::TreeSelection&gt; refTreeSelection =
      m_treeview.get_selection();
  if(refTreeSelection)
  {
    Gtk::TreeModel::iterator sorted_iter =
        m_refTreeSelection-&gt;get_selected();
    if(sorted_iter)
    {
      Gtk::TreeModel::iterator iter =
          m_refModelSort-&gt;convert_iter_to_child_iter(sorted_iter);
      m_refModel-&gt;erase(iter);
    }
  }
}</programlisting>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1TreeModelSort.html">Référence de TreeModelSort</ulink></para>
</sect2>

</sect1>

<sect1 id="sec-treeview-draganddrop">
<title>Glisser-déposer</title>
<para><classname>Gtk::TreeView</classname> implémente déjà le simple glisser-déposer lorsqu'on l'utilise avec des modèles <classname>Gtk::ListStore</classname> ou <classname>Gtk::TreeStore</classname>. Mais, si nécessaire, il vous permet d'implémenter des comportements plus complexes lorsque les éléments sont glissés et déposés en utilisant l'API classique du <link linkend="chapter-draganddrop">glisser-déposer</link>.</para>

<sect2 id="treeview-reorderable-rows">
<title>Réarrangement de lignes</title>
<para>Si vous faites appel à la fonction membre <methodname>Gtk::TreeView::set_reorderable()</methodname>, 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 <classname>TreeStore</classname>.</para>
<para>Toutefois, cela ne vous donne aucun contrôle sur les éléments qu'il est possible de faire glisser et sur l'emplacement où ils peuvent être déposés. Si vous avez besoin de ce contrôle supplémentaire, vous devez créer un <literal>Gtk::TreeModel</literal> dérivé de <literal>Gtk::TreeStore</literal> ou <literal>Gtk::ListStore</literal> et opérer une surdéfinition des fonctions membres virtuelles <literal>Gtk::TreeDragSource::row_draggable()</literal> et <literal>Gdk::TreeDragDest::row_drop_possible()</literal>. Vous examinez alors les <literal>Gtk::TreeModel::Path</literal> fournis et autorisez/interdisez le glisser ou le déposer en renvoyant <literal>true</literal> ou <literal>false</literal>.</para>
<para>Cette construction est montrée dans l'exemple du glisser-déposer.</para>
</sect2>

</sect1>

<sect1 id="sec-treeview-contextmenu">
<title>Menu contextuel</title>
<para>Nombre de programmeurs ont besoin d'implémenter des menus contextuels s'ouvrant d'un clic droit de souris sur des objets <classname>TreeView</classname>. 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 <link linkend="sec-menus-popup">chapitre Menus</link>.</para>

<sect2 id="treeview-button-press-event">
<title>Gestion du signal <literal>button_press_event</literal></title>
<para>Pour détecter un clic du bouton droit de la souris, il faut gérer le signal <literal>button_press_event</literal> et vérifier quel est exactement le bouton pressé. Comme <classname>TreeView</classname> gère normalement ce signal intégralement, vous devrez, soit procéder à la surdéfinition du gestionnaire de signal par défaut dans une classe <classname>TreeView</classname> dérivée, soit utiliser la fonction membre <methodname>connect_notify()</methodname> à la place de <methodname>connect()</methodname>. Vous souhaiterez probablement aussi appeler le gestionnaire par défaut avant de faire quoi que ce soit d'autre ; un clic-droit provoque donc au préalable la sélection de la ligne.</para>
<para>Ceci est montré dans l'exemple Menu contextuel personnalisé.</para>
</sect2>

</sect1>

<sect1 id="sec-treeview-examples"><title>Exemples</title>

<sect2 id="liststore-example"><title>ListStore</title>
<para>Voici un exemple d'élément graphique <classname>Gtk::TreeView</classname> avec un modèle <classname>Gtk::ListStore</classname>.</para>


<figure id="figure-treeview-liststore">
  <title>TreeView - ListStore</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/treeview_list.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/treeview/list/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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&lt;unsigned int&gt; m_col_id;
    Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_name;
    Gtk::TreeModelColumn&lt;short&gt; m_col_number;
    Gtk::TreeModelColumn&lt;int&gt; m_col_percentage;
  };

  ModelColumns m_Columns;

  //Child widgets:
  Gtk::VBox m_VBox;

  Gtk::ScrolledWindow m_ScrolledWindow;
  Gtk::TreeView m_TreeView;
  Glib::RefPtr&lt;Gtk::ListStore&gt; m_refTreeModel;

  Gtk::HButtonBox m_ButtonBox;
  Gtk::Button m_Button_Quit;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include "examplewindow.h"

ExampleWindow::ExampleWindow()
: m_Button_Quit("Quit")
{
  set_title("Gtk::TreeView (ListStore) example");
  set_border_width(5);
  set_default_size(400, 200);

  add(m_VBox);

  //Add the TreeView, inside a ScrolledWindow, with the button underneath:
  m_ScrolledWindow.add(m_TreeView);

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

  m_VBox.pack_start(m_ScrolledWindow);
  m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

  m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
  m_ButtonBox.set_border_width(5);
  m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
  m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_quit) );

  //Create the Tree model:
  m_refTreeModel = Gtk::ListStore::create(m_Columns);
  m_TreeView.set_model(m_refTreeModel);

  //Fill the TreeView's model
  Gtk::TreeModel::Row row = *(m_refTreeModel-&gt;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-&gt;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-&gt;append());
  row[m_Columns.m_col_id] = 3;
  row[m_Columns.m_col_name] = "Rob McRoberts";
  row[m_Columns.m_col_number] = 30;
  row[m_Columns.m_col_percentage] = 70;

  //Add the TreeView's view columns:
  //This number will be shown with the default numeric formatting.
  m_TreeView.append_column("ID", m_Columns.m_col_id);
  m_TreeView.append_column("Name", m_Columns.m_col_name);

  m_TreeView.append_column_numeric("Formatted number", m_Columns.m_col_number,
          "%010d" /* 10 digits, using leading zeroes. */);

  //Display a progress bar instead of a decimal number:
  Gtk::CellRendererProgress* cell = Gtk::manage(new Gtk::CellRendererProgress);
  int cols_count = m_TreeView.append_column("Some percentage", *cell);
  Gtk::TreeViewColumn* pColumn = m_TreeView.get_column(cols_count - 1);
  if(pColumn)
  {
    pColumn-&gt;add_attribute(cell-&gt;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 &lt; 2; i++)
  {
    Gtk::TreeView::Column* pColumn = m_TreeView.get_column(i);
    pColumn-&gt;set_reorderable();
  }

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

<sect2 id="treestore-example"><title>TreeStore</title>

<para>C'est exemple est tout à fait semblable au précédent, mais il utilise un modèle <classname>Gtk::TreeStore</classname> à la place et il ajoute des enfants aux colonnes.</para>

<figure id="figure-treeview-treestore">
  <title>TreeView - TreeStore</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/treeview_tree.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/treeview/tree/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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&amp; 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&lt;int&gt; m_col_id;
    Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_name;
  };

  ModelColumns m_Columns;

  //Child widgets:
  Gtk::VBox m_VBox;

  Gtk::ScrolledWindow m_ScrolledWindow;
  Gtk::TreeView m_TreeView;
  Glib::RefPtr&lt;Gtk::TreeStore&gt; m_refTreeModel;

  Gtk::HButtonBox m_ButtonBox;
  Gtk::Button m_Button_Quit;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include "examplewindow.h"

ExampleWindow::ExampleWindow()
: m_Button_Quit("Quit")
{
  set_title("Gtk::TreeView (TreeStore) example");
  set_border_width(5);
  set_default_size(400, 200);

  add(m_VBox);

  //Add the TreeView, inside a ScrolledWindow, with the button underneath:
  m_ScrolledWindow.add(m_TreeView);

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

  m_VBox.pack_start(m_ScrolledWindow);
  m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

  m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
  m_ButtonBox.set_border_width(5);
  m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
  m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_quit) );

  //Create the Tree model:
  m_refTreeModel = Gtk::TreeStore::create(m_Columns);
  m_TreeView.set_model(m_refTreeModel);

  //All the items to be reordered with drag-and-drop:
  m_TreeView.set_reorderable();

  //Fill the TreeView's model
  Gtk::TreeModel::Row row = *(m_refTreeModel-&gt;append());
  row[m_Columns.m_col_id] = 1;
  row[m_Columns.m_col_name] = "Billy Bob";

  Gtk::TreeModel::Row childrow = *(m_refTreeModel-&gt;append(row.children()));
  childrow[m_Columns.m_col_id] = 11;
  childrow[m_Columns.m_col_name] = "Billy Bob Junior";

  childrow = *(m_refTreeModel-&gt;append(row.children()));
  childrow[m_Columns.m_col_id] = 12;
  childrow[m_Columns.m_col_name] = "Sue Bob";

  row = *(m_refTreeModel-&gt;append());
  row[m_Columns.m_col_id] = 2;
  row[m_Columns.m_col_name] = "Joey Jojo";


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

  childrow = *(m_refTreeModel-&gt;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,
              &amp;ExampleWindow::on_treeview_row_activated) );

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

<sect2 id="sec-editable-cells-example"><title>Cellules modifiables</title>

<para>Cet exemple est identique à l'exemple avec <classname>ListStore</classname>, mais il utilise <methodname>TreeView::append_column_editable()</methodname> à la place de <methodname>TreeView::append_column()</methodname>.</para>

<figure id="figure-treeview-editablecells">
  <title>TreeView - Cellules modifiables</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/treeview_editablecells.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/treeview/editable_cells/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

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

  void treeviewcolumn_validated_on_cell_data(Gtk::CellRenderer* renderer, const Gtk::TreeModel::iterator&amp; iter);
  void cellrenderer_validated_on_editing_started(Gtk::CellEditable* cell_editable, const Glib::ustring&amp; path);
  void cellrenderer_validated_on_edited(const Glib::ustring&amp; path_string, const Glib::ustring&amp; 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&lt;unsigned int&gt; m_col_id;
    Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_name;
    Gtk::TreeModelColumn&lt;bool&gt; m_col_foo;
    Gtk::TreeModelColumn&lt;int&gt; m_col_number;
    Gtk::TreeModelColumn&lt;int&gt; m_col_number_validated;
  };

  ModelColumns m_Columns;

  //Child widgets:
  Gtk::VBox m_VBox;

  Gtk::ScrolledWindow m_ScrolledWindow;
  Gtk::TreeView m_TreeView;
  Glib::RefPtr&lt;Gtk::ListStore&gt; m_refTreeModel;

  Gtk::HButtonBox 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
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include &lt;cstdio&gt;
#include &lt;cstdlib&gt;
#include "examplewindow.h"

using std::sprintf;
using std::strtol;

ExampleWindow::ExampleWindow()
: m_Button_Quit("Quit"),
  m_validate_retry(false)
{
  set_title("Gtk::TreeView Editable Cells example");
  set_border_width(5);
  set_default_size(400, 200);


  add(m_VBox);

  //Add the TreeView, inside a ScrolledWindow, with the button underneath:
  m_ScrolledWindow.add(m_TreeView);

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

  m_VBox.pack_start(m_ScrolledWindow);
  m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

  m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
  m_ButtonBox.set_border_width(5);
  m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
  m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_quit) );

  //Create the Tree model:
  m_refTreeModel = Gtk::ListStore::create(m_Columns);
  m_TreeView.set_model(m_refTreeModel);

  //Fill the TreeView's model
  Gtk::TreeModel::Row row = *(m_refTreeModel-&gt;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-&gt;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-&gt;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 (&lt;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,
              &amp;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,
        &amp;ExampleWindow::cellrenderer_validated_on_editing_started) );

  m_cellrenderer_validated.signal_edited().connect( sigc::mem_fun(*this,
              &amp;ExampleWindow::cellrenderer_validated_on_edited) );

  //If this was a CellRendererSpin then you would have to set the adjustment:
  //m_cellrenderer_validated.property_adjustment() = m_spin_adjustment;

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

void ExampleWindow::treeviewcolumn_validated_on_cell_data(
        Gtk::CellRenderer* /* renderer */,
        const Gtk::TreeModel::iterator&amp; iter)
{
  //Get the value from the model and show it appropriately in the view:
  if(iter)
  {
    Gtk::TreeModel::Row row = *iter;
    int model_value = row[m_Columns.m_col_number_validated];

    //This is just an example.
    //In this case, it would be easier to use append_column_editable() or
    //append_column_numeric_editable()
    char buffer[32];
    sprintf(buffer, "%d", model_value); 

    Glib::ustring view_text = buffer;
    m_cellrenderer_validated.property_text() = view_text;
  }
}

void ExampleWindow::cellrenderer_validated_on_editing_started(
        Gtk::CellEditable* cell_editable, const Glib::ustring&amp; /* path */)
{
  //Start editing with previously-entered (but invalid) text, 
  //if we are allowing the user to correct some invalid data. 
  if(m_validate_retry)
  {
    //This is the CellEditable inside the CellRenderer. 
    Gtk::CellEditable* celleditable_validated = cell_editable;

    //It's usually an Entry, at least for a CellRendererText:
    Gtk::Entry* pEntry = dynamic_cast&lt;Gtk::Entry*&gt;(celleditable_validated);
    if(pEntry)
    {
      pEntry-&gt;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&amp; path_string,
        const Glib::ustring&amp; new_text)
{
  Gtk::TreePath path(path_string);

  //Convert the inputed text to an integer, as needed by our model column:
  char* pchEnd = 0;
  int new_value = strtol(new_text.c_str(), &amp;pchEnd, 10);

  if(new_value &gt; 10)
  {
    //Prevent entry of numbers higher than 10.

    //Tell the user:
    Gtk::MessageDialog dialog(*this,
            "The number must be less than 10. Please try again.",
            false, Gtk::MESSAGE_ERROR);
    dialog.run();

    //Start editing again, with the bad text, so that the user can correct it.
    //A real application should probably allow the user to revert to the
    //previous text.

    //Set the text to be used in the start_editing signal handler:
    m_invalid_text_for_retry = new_text;
    m_validate_retry = true;

    //Start editing again:
    m_TreeView.set_cursor(path, m_treeviewcolumn_validated,
            m_cellrenderer_validated, true /* start_editing */);
  }
  else
  {
    //Get the row from the path:
    Gtk::TreeModel::iterator iter = m_refTreeModel-&gt;get_iter(path);
    if(iter)
    {
      Gtk::TreeModel::Row row = *iter;

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

<sect2 id="treeview-dnd-example"><title>Glisser-déposer</title>

<para>Cet exemple est similaire à l'exemple <classname>TreeStore</classname>, mais il a deux colonnes supplémentaires, une pour indiquer si la ligne peut être glissée, une pour indiquer si elle accepte des lignes déposées. Il se sert d'une classe <classname>Gtk::TreeStore</classname> dérivée dans laquelle s'opère une surdéfinition  des fonctions virtuelles comme décrit dans le paragraphe <link linkend="sec-treeview-draganddrop">TreeView et glisser-déposer</link>.</para>

<figure id="figure-treeview-draganddrop">
  <title>TreeView - Glisser-déposer</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/treeview_draganddrop.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/treeview/drag_and_drop/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>treemodel_dnd.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_TREEMODEL_DND_H
#define GTKMM_EXAMPLE_TREEMODEL_DND_H

#include &lt;gtkmm.h&gt;

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&lt;int&gt; m_col_id;
    Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_name;
    Gtk::TreeModelColumn&lt;bool&gt; m_col_draggable;
    Gtk::TreeModelColumn&lt;bool&gt; m_col_receivesdrags;
  };

  ModelColumns m_Columns;

  static Glib::RefPtr&lt;TreeModel_Dnd&gt; create();

protected:
  //Overridden virtual functions:
  virtual bool row_draggable_vfunc(const Gtk::TreeModel::Path&amp; path) const;
  virtual bool row_drop_possible_vfunc(const Gtk::TreeModel::Path&amp; dest, const Gtk::SelectionData&amp; selection_data) const;
  
};

#endif //GTKMM_EXAMPLE_TREEMODEL_DND_H
</programlisting>
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;
#include "treemodel_dnd.h"


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

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


  //Child widgets:
  Gtk::VBox m_VBox;

  Gtk::ScrolledWindow m_ScrolledWindow;
  Gtk::TreeView m_TreeView;
  Glib::RefPtr&lt;TreeModel_Dnd&gt; m_refTreeModel;

  Gtk::HButtonBox m_ButtonBox;
  Gtk::Button m_Button_Quit;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>treemodel_dnd.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "treemodel_dnd.h"
#include &lt;iostream&gt;

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&lt;TreeModel_Dnd&gt; TreeModel_Dnd::create()
{
  return Glib::RefPtr&lt;TreeModel_Dnd&gt;( new TreeModel_Dnd() );
}

bool
TreeModel_Dnd::row_draggable_vfunc(const Gtk::TreeModel::Path&amp; path) const
{
  // Make the value of the "draggable" column determine whether this row can
  // be dragged:

  //TODO: Add a const version of get_iter to TreeModel:
  TreeModel_Dnd* unconstThis = const_cast&lt;TreeModel_Dnd*&gt;(this);
  const_iterator iter = unconstThis-&gt;get_iter(path);
  //const_iterator iter = get_iter(path);
  if(iter)
  {
    Row row = *iter;
    bool is_draggable = row[m_Columns.m_col_draggable];
    return is_draggable;
  }

  return Gtk::TreeStore::row_draggable_vfunc(path);
}

bool
TreeModel_Dnd::row_drop_possible_vfunc(const Gtk::TreeModel::Path&amp; dest,
        const Gtk::SelectionData&amp; selection_data) const
{
  //Make the value of the "receives drags" column determine whether a row can be
  //dragged into it:

  //dest is the path that the row would have after it has been dropped:
  //But in this case we are more interested in the parent row:
  Gtk::TreeModel::Path dest_parent = dest;
  bool dest_is_not_top_level = dest_parent.up();
  if(!dest_is_not_top_level || dest_parent.empty())
  {
    //The user wants to move something to the top-level.
    //Let's always allow that.
  }
  else
  {
    //Get an iterator for the row at this path:
    //We must unconst this. This should not be necessary with a future version
    //of gtkmm.
    //TODO: Add a const version of get_iter to TreeModel:
    TreeModel_Dnd* unconstThis = const_cast&lt;TreeModel_Dnd*&gt;(this);
    const_iterator iter_dest_parent = unconstThis-&gt;get_iter(dest_parent);
    //const_iterator iter_dest_parent = get_iter(dest);
    if(iter_dest_parent)
    {
      Row row = *iter_dest_parent;
      bool receives_drags = row[m_Columns.m_col_receivesdrags];
      return receives_drags;
    }
  }

  //You could also examine the row being dragged (via selection_data)
  //if you must look at both rows to see whether a drop should be allowed.
  //You could use
  //TODO: Add const version of get_from_selection_data(): Glib::RefPtr&lt;const
  //Gtk::TreeModel&gt; refThis = Glib::RefPtr&lt;const Gtk::TreeModel&gt;(this);
  //
  //Glib::RefPtr&lt;Gtk::TreeModel&gt; refThis =
  //Glib::RefPtr&lt;Gtk::TreeModel&gt;(const_cast&lt;TreeModel_Dnd*&gt;(this));
  //refThis-&gt;reference(); //, true /* take_copy */)
  //Gtk::TreeModel::Path path_dragged_row;
  //Gtk::TreeModel::Path::get_from_selection_data(selection_data, refThis,
  //path_dragged_row);

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

</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include "examplewindow.h"

ExampleWindow::ExampleWindow()
: m_Button_Quit(Gtk::Stock::QUIT)
{
  set_title("Gtk::TreeView (Drag and Drop) example");
  set_border_width(5);
  set_default_size(400, 200);

  add(m_VBox);

  //Add the TreeView, inside a ScrolledWindow, with the button underneath:
  m_ScrolledWindow.add(m_TreeView);

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

  m_VBox.pack_start(m_ScrolledWindow);
  m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

  m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
  m_ButtonBox.set_border_width(5);
  m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
  m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_quit) );

  //Create the Tree model:
  //Use our derived model, which overrides some Gtk::TreeDragDest and
  //Gtk::TreeDragSource virtual functions:
  //The columns are declared in the overridden TreeModel.
  m_refTreeModel = TreeModel_Dnd::create();
  m_TreeView.set_model(m_refTreeModel);

  //Enable Drag-and-Drop of TreeView rows:
  //See also the derived TreeModel's *_vfunc overrides.
  m_TreeView.enable_model_drag_source();
  m_TreeView.enable_model_drag_dest();

  //Fill the TreeView's model
  Gtk::TreeModel::Row row = *(m_refTreeModel-&gt;append());
  row[m_refTreeModel-&gt;m_Columns.m_col_id] = 1;
  row[m_refTreeModel-&gt;m_Columns.m_col_name] = "Billy Bob";
  row[m_refTreeModel-&gt;m_Columns.m_col_draggable] = true;
  row[m_refTreeModel-&gt;m_Columns.m_col_receivesdrags] = true;

  Gtk::TreeModel::Row childrow = *(m_refTreeModel-&gt;append(row.children()));
  childrow[m_refTreeModel-&gt;m_Columns.m_col_id] = 11;
  childrow[m_refTreeModel-&gt;m_Columns.m_col_name] = "Billy Bob Junior";
  childrow[m_refTreeModel-&gt;m_Columns.m_col_draggable] = true;
  childrow[m_refTreeModel-&gt;m_Columns.m_col_receivesdrags] = true;

  childrow = *(m_refTreeModel-&gt;append(row.children()));
  childrow[m_refTreeModel-&gt;m_Columns.m_col_id] = 12;
  childrow[m_refTreeModel-&gt;m_Columns.m_col_name] = "Sue Bob";
  childrow[m_refTreeModel-&gt;m_Columns.m_col_draggable] = true;
  childrow[m_refTreeModel-&gt;m_Columns.m_col_receivesdrags] = true;

  row = *(m_refTreeModel-&gt;append());
  row[m_refTreeModel-&gt;m_Columns.m_col_id] = 2;
  row[m_refTreeModel-&gt;m_Columns.m_col_name] = "Joey Jojo";
  row[m_refTreeModel-&gt;m_Columns.m_col_draggable] = true;
  row[m_refTreeModel-&gt;m_Columns.m_col_receivesdrags] = true;

  row = *(m_refTreeModel-&gt;append());
  row[m_refTreeModel-&gt;m_Columns.m_col_id] = 3;
  row[m_refTreeModel-&gt;m_Columns.m_col_name] = "Rob McRoberts";
  row[m_refTreeModel-&gt;m_Columns.m_col_draggable] = true;
  row[m_refTreeModel-&gt;m_Columns.m_col_receivesdrags] = true;

  childrow = *(m_refTreeModel-&gt;append(row.children()));
  childrow[m_refTreeModel-&gt;m_Columns.m_col_id] = 31;
  childrow[m_refTreeModel-&gt;m_Columns.m_col_name] = "Xavier McRoberts";
  childrow[m_refTreeModel-&gt;m_Columns.m_col_draggable] = true;
  childrow[m_refTreeModel-&gt;m_Columns.m_col_receivesdrags] = true;

  //Add the TreeView's view columns:
  m_TreeView.append_column("ID", m_refTreeModel-&gt;m_Columns.m_col_id);
  m_TreeView.append_column("Name", m_refTreeModel-&gt;m_Columns.m_col_name);
  m_TreeView.append_column_editable("Draggable",
          m_refTreeModel-&gt;m_Columns.m_col_draggable);
  m_TreeView.append_column_editable("Receives Drags",
          m_refTreeModel-&gt;m_Columns.m_col_receivesdrags);

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

<sect2 id="treeview-popup-menu-example"><title>Menu contextuel</title>

<para>Cet exemple est tout à fait semblable à l'exemple <classname>ListStore</classname>, excepté qu'il crée un <classname>TreeView</classname> personnalisé par dérivation pour permettre la surdéfinition de <literal>button_press_event</literal> et pour encapsuler le code du modèle d'arborescence dans cette classe dérivée. Consultez le paragraphe <link linkend="sec-treeview-contextmenu">Menu contextuel et TreeView</link>.</para>

<figure id="figure-treeview-popup">
  <title>TreeView - Menu contextuel</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/treeview_popup.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/treeview/popup/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>treeview_withpopup.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_TREEVIEW_WITHPOPUP_H
#define GTKMM_EXAMPLE_TREEVIEW_WITHPOPUP_H

#include &lt;gtkmm.h&gt;

class TreeView_WithPopup : public Gtk::TreeView
{
public:
  TreeView_WithPopup();
  virtual ~TreeView_WithPopup();

protected:
  // Override Signal handler:
  // Alternatively, use signal_button_press_event().connect_notify()
  virtual bool on_button_press_event(GdkEventButton *ev);

  //Signal handler for popup menu items:
  void on_menu_file_popup_generic();

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

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

    Gtk::TreeModelColumn&lt;unsigned int&gt; m_col_id;
    Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_name;
  };
  
  ModelColumns m_Columns;

  //The Tree model:
  Glib::RefPtr&lt;Gtk::ListStore&gt; m_refTreeModel;

  Gtk::Menu m_Menu_Popup;
};

#endif //GTKMM_EXAMPLE_TREEVIEW_WITHPOPUP_H
</programlisting>
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;
#include "treeview_withpopup.h"

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

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

 

  //Child widgets:
  Gtk::VBox m_VBox;

  Gtk::ScrolledWindow m_ScrolledWindow;
  TreeView_WithPopup m_TreeView;

  Gtk::HButtonBox m_ButtonBox;
  Gtk::Button m_Button_Quit;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>treeview_withpopup.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "treeview_withpopup.h"
#include &lt;iostream&gt;

TreeView_WithPopup::TreeView_WithPopup()
{
  //Create the Tree model:
  m_refTreeModel = Gtk::ListStore::create(m_Columns);
  set_model(m_refTreeModel);

  //Fill the TreeView's model
  Gtk::TreeModel::Row row = *(m_refTreeModel-&gt;append());
  row[m_Columns.m_col_id] = 1;
  row[m_Columns.m_col_name] = "right-click on this";

  row = *(m_refTreeModel-&gt;append());
  row[m_Columns.m_col_id] = 2;
  row[m_Columns.m_col_name] = "or this";

  row = *(m_refTreeModel-&gt;append());
  row[m_Columns.m_col_id] = 3;
  row[m_Columns.m_col_name] = "or this, for a popup context menu";

  //Add the TreeView's view columns:
  append_column("ID", m_Columns.m_col_id);
  append_column("Name", m_Columns.m_col_name);

  //Fill popup menu:
  Gtk::MenuItem* item = Gtk::manage(new Gtk::MenuItem("_Edit"));
  item-&gt;signal_activate().connect(
    sigc::mem_fun(*this, &amp;TreeView_WithPopup::on_menu_file_popup_generic) );
  m_Menu_Popup.append(*item);
    
  item = Gtk::manage(new Gtk::MenuItem("_Process"));
  item-&gt;signal_activate().connect(
    sigc::mem_fun(*this, &amp;TreeView_WithPopup::on_menu_file_popup_generic) );
  m_Menu_Popup.append(*item);
    
  item = Gtk::manage(new Gtk::MenuItem("_Remove"));
  item-&gt;signal_activate().connect(
    sigc::mem_fun(*this, &amp;TreeView_WithPopup::on_menu_file_popup_generic) );
  m_Menu_Popup.append(*item);

  m_Menu_Popup.accelerate(*this);

#ifndef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  signal_button_press_event()
    .connect(sigc::mem_fun(*this, &amp;TreeView_WithPopup::on_button_press_event), false);
#endif
}

TreeView_WithPopup::~TreeView_WithPopup()
{
}

bool TreeView_WithPopup::on_button_press_event(GdkEventButton* event)
{
  bool return_value = false;

  //Call base class, to allow normal handling,
  //such as allowing the row to be selected by the right-click:
  return_value = TreeView::on_button_press_event(event);

  //Then do our custom stuff:
  if( (event-&gt;type == GDK_BUTTON_PRESS) &amp;&amp; (event-&gt;button == 3) )
  {
    m_Menu_Popup.popup(event-&gt;button, event-&gt;time);
  }

  return return_value;
}

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

  Glib::RefPtr&lt;Gtk::TreeView::Selection&gt; refSelection = get_selection();
  if(refSelection)
  {
    Gtk::TreeModel::iterator iter = refSelection-&gt;get_selected();
    if(iter)
    {
      int id = (*iter)[m_Columns.m_col_id];
      std::cout &lt;&lt; "  Selected ID=" &lt;&lt; id &lt;&lt; std::endl;
    }
  }
}
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include "examplewindow.h"

ExampleWindow::ExampleWindow()
: m_Button_Quit("Quit")
{
  set_title("Gtk::TreeView (ListStore) example");
  set_border_width(5);
  set_default_size(400, 200);

  add(m_VBox);

  //Add the TreeView, inside a ScrolledWindow, with the button underneath:
  m_ScrolledWindow.add(m_TreeView);

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

  m_VBox.pack_start(m_ScrolledWindow);
  m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

  m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
  m_ButtonBox.set_border_width(5);
  m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
  m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_quit) );

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>


</sect1>

</chapter>


<chapter id="chapter-combobox">
<title>Boîtes combinées</title>

<para>Les éléments graphiques de la classe <classname>ComboBox</classname> offrent une liste (ou un arbre) de choix dans un menu déroulant. Opportunément, elle peut afficher des informations supplémentaires concernant chacun des éléments, comme du texte, une image, une case à cocher ou une barre de progression. L'élément graphique <classname>ComboBox</classname> n'autorise habituellement que les choix prédéfinis, mais il peut à l'occasion posséder une boîte <classname>Entry</classname>, permettant à l'utilisateur de saisir un texte quelconque si aucun de ceux qui sont proposés ne lui conviennent.</para>

<para>La liste est donnée via un objet <classname>TreeModel</classname> 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 <methodname>ComboBox::pack_start()</methodname>. Cela procure beaucoup de souplesse et de sécurité sur les types de données à la compilation ; mais la classe <classname>ComboBoxText</classname> dispose d'un paramétrage texte simple pour les cas où cette souplesse n'est pas recherchée.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1ComboBox.html">Référence</ulink></para>

<sect1 id="sec-combobox-model">
<title>Le modèle</title>
<para>Le modèle d'une boîte combinée se définit et se remplit exactement comme un objet <classname>TreeView</classname>. Par exemple, vous pouvez dériver à partir de ComboBox une classe comportant une colonne d'entiers et une colonne texte comme suit :</para>
<programlisting>ModelColumns()
{ add(m_col_id); add(m_col_name); }

  Gtk::TreeModelColumn&lt;int&gt; m_col_id;
  Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_name;
};

ModelColumns m_columns;</programlisting>

<para>Après avoir ajouté des lignes à ce modèle, intégrez le modèle dans l'objet <classname>ComboBox</classname> avec la fonction membre <methodname>set_model()</methodname>. Puis, servez-vous des fonctions membres <methodname>pack_start()</methodname> ou <methodname>pack_end()</methodname> pour définir les colonnes à afficher dans la boîte combinée. Comme avec une vue arborescente vous pouvez, soit utiliser le moteur de rendu par défaut en passant le <classname>TreeModelColumn</classname> aux fonctions membres d'empaquetage, soit créer un exemplaire particulier de <classname>CellRenderer</classname> en définissant une correspondance personnalisée avec <methodname>add_attribute()</methodname> ou <methodname>set_cell_data_func()</methodname>. Notez que ces fonctions membres font partie de la classe de base <classname>CellLayout</classname>.</para>
</sect1>

<sect1 id="sec-combobox-get">
<title>L'élément choisi</title>
<para>Pour savoir quel élément, s'il y lieu, a été sélectionné dans la boîte combinée par l'utilisateur, faites appel à <methodname>ComboBox::get_active()</methodname>. Cette fonction membre renvoie un pointeur sur un <classname>TreeModel::iterator</classname> que vous pouvez déréférencer pour obtenir un objet <classname>Row</classname> afin de lire les valeurs des colonnes. Ainsi, vous pourriez lire à partir du modèle une valeur d'identification sous forme d'un entier, même si vous avez choisi de n'afficher qu'une description littérale dans la boîte combinée. Par exemple :</para>
<programlisting>Gtk::TreeModel::iterator iter = m_Combo.get_active();
if(iter)
{
  Gtk::TreeModel::Row row = *iter;

  // Obtenir les données de la ligne choisie grâce à notre 
  // connaissance du modèle d'arborescence :
  int id = row[m_Columns.m_col_id];
  set_something_id_chosen(id); // Votre fonction.
}
else
  set_nothing_chosen(); // Votre fonction.</programlisting>
</sect1>

<sect1 id="sec-combobox-changes">
<title>Réponse à une modification</title>
<para>Vous pouvez avoir besoin de réagir à un changement de sélection dans la boîte combinée, par exemple pour mettre à jour d'autres éléments graphiques. Pour cela, vous devez gérer le signal « changed ». Par exemple :</para>
<programlisting>m_combo.signal_changed().connect( sigc::mem_fun(*this,
      &amp;ExampleWindow::on_combo_changed) );</programlisting>
</sect1>

<sect1 id="combobox-example-full"><title>Exemple complet</title>

<figure id="figure-combobox-complex">
  <title>ComboBox</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/combobox_complex.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/combobox/complex?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm/window.h&gt;
#include &lt;gtkmm/comboboxtext.h&gt;
#include &lt;gtkmm/liststore.h&gt;

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

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

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

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

    Gtk::TreeModelColumn&lt;int&gt; m_col_id;
    Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_name;
  };

  ModelColumns m_Columns;

  //Child widgets:
  Gtk::ComboBox m_Combo;
  Glib::RefPtr&lt;Gtk::ListStore&gt; m_refTreeModel;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/stock.h&gt;
#include &lt;iostream&gt;

ExampleWindow::ExampleWindow()
{
  set_title("ComboBox example");

  //Create the Tree model:
  //m_refTreeModel = Gtk::TreeStore::create(m_Columns);
  m_refTreeModel = Gtk::ListStore::create(m_Columns);
  m_Combo.set_model(m_refTreeModel);

  //Fill the ComboBox's Tree Model:
  Gtk::TreeModel::Row row = *(m_refTreeModel-&gt;append());
  row[m_Columns.m_col_id] = 1;
  row[m_Columns.m_col_name] = "Billy Bob";
  /*
  Gtk::TreeModel::Row childrow = *(m_refTreeModel-&gt;append(row.children()));
  childrow[m_Columns.m_col_id] = 11;
  childrow[m_Columns.m_col_name] = "Billy Bob Junior";

  childrow = *(m_refTreeModel-&gt;append(row.children()));
  childrow[m_Columns.m_col_id] = 12;
  childrow[m_Columns.m_col_name] = "Sue Bob";
  */

  row = *(m_refTreeModel-&gt;append());
  row[m_Columns.m_col_id] = 2;
  row[m_Columns.m_col_name] = "Joey Jojo";


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

  /*
  childrow = *(m_refTreeModel-&gt;append(row.children()));
  childrow[m_Columns.m_col_id] = 31;
  childrow[m_Columns.m_col_name] = "Xavier McRoberts";
  */

  //Add the model columns to the Combo (which is a kind of view),
  //rendering them in the default way:
  m_Combo.pack_start(m_Columns.m_col_id);
  m_Combo.pack_start(m_Columns.m_col_name);

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_combo_changed()
{
  Gtk::TreeModel::iterator iter = m_Combo.get_active();
  if(iter)
  {
    Gtk::TreeModel::Row row = *iter;
    if(row)
    {
      //Get the data for the selected row, using our knowledge of the tree
      //model:
      int id = row[m_Columns.m_col_id];
      Glib::ustring name = row[m_Columns.m_col_name];

      std::cout &lt;&lt; " ID=" &lt;&lt; id &lt;&lt; ", name=" &lt;&lt; name &lt;&lt; std::endl;
    }
  }
  else
    std::cout &lt;&lt; "invalid iter" &lt;&lt; std::endl;
}

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect1>

<sect1 id="combobox-example-simple"><title>Exemple texte simple</title>

<figure id="figure-combobox-text">
  <title>ComboBox</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/combobox_text.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/combobox/text?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm/window.h&gt;
#include &lt;gtkmm/comboboxtext.h&gt;

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
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/stock.h&gt;
#include &lt;iostream&gt;

ExampleWindow::ExampleWindow()
{
  set_title("ComboBoxText example");

  //Fill the combo:
  m_Combo.append("something");
  m_Combo.append("something else");
  m_Combo.append("something or other");

  add(m_Combo);

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_combo_changed()
{
  Glib::ustring text = m_Combo.get_active_text();
  if(!(text.empty()))
    std::cout &lt;&lt; "Combo changed: " &lt;&lt; text &lt;&lt; std::endl;
}

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect1>

<sect1 id="sec-comboboxentry">
<title>Boîte combinée avec saisie</title>

<para>Une <classname>ComboBox</classname> peut contenir un élément graphique <classname>Entry</classname> afin de saisir un texte arbitraire en fixant à true (vrai) le paramètre <literal>has_entry</literal> du constructeur.</para>

<sect2 id="sec-comboboxentry-text-column">
<title>La colonne texte</title>
<para>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 <methodname>set_text_column()</methodname>. For instance:
<programlisting>m_combo.set_text_column(m_columns.m_col_name);</programlisting>
</para>
<para>Si vous faites une sélection dans le menu déroulant, la valeur de cette colonne sera placée dans l'élément graphique <classname>Entry</classname>.</para>
</sect2>

<sect2 id="sec-comboboxentry-model">
<title>La saisie</title>
<para>Étant donné que l'utilisateur peut saisir n'importe quel texte, une ligne active du modèle ne suffit pas pour indiquer quel est le texte saisi par l'utilisateur. C'est pourquoi, vous devez retrouver l'élément graphique <classname>Entry</classname> avec la fonction membre <methodname>ComboBoxEntry::get_entry()</methodname> et appeler <methodname>get_text()</methodname> sur cet objet.</para>
</sect2>

<sect2 id="comboboxentry-example-full"><title>Exemple complet</title>

<figure id="figure-comboboxentry-complex">
  <title>Boîte combinée avec saisie</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/comboboxentry_complex.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/combobox/entry_complex?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm/window.h&gt;
#include &lt;gtkmm/combobox.h&gt;
#include &lt;gtkmm/liststore.h&gt;

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

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

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

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

    Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_id; //The data to choose - this must be text.
    Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_name;
  };

  ModelColumns m_Columns;

  //Child widgets:
  Gtk::ComboBox m_Combo;
  Glib::RefPtr&lt;Gtk::ListStore&gt; m_refTreeModel;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/stock.h&gt;
#include &lt;iostream&gt;

ExampleWindow::ExampleWindow()
: m_Combo(true /* has_entry */)
{
  set_title("ComboBox example");

  //Create the Tree model:
  //m_refTreeModel = Gtk::TreeStore::create(m_Columns);
  m_refTreeModel = Gtk::ListStore::create(m_Columns);
  m_Combo.set_model(m_refTreeModel);

  //Fill the ComboBox's Tree Model:
  Gtk::TreeModel::Row row = *(m_refTreeModel-&gt;append());
  row[m_Columns.m_col_id] = "1";
  row[m_Columns.m_col_name] = "Billy Bob";
  /*
  Gtk::TreeModel::Row childrow = *(m_refTreeModel-&gt;append(row.children()));
  childrow[m_Columns.m_col_id] = 11;
  childrow[m_Columns.m_col_name] = "Billy Bob Junior";

  childrow = *(m_refTreeModel-&gt;append(row.children()));
  childrow[m_Columns.m_col_id] = 12;
  childrow[m_Columns.m_col_name] = "Sue Bob";
  */

  row = *(m_refTreeModel-&gt;append());
  row[m_Columns.m_col_id] = "2";
  row[m_Columns.m_col_name] = "Joey Jojo";


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

  /*
  childrow = *(m_refTreeModel-&gt;append(row.children()));
  childrow[m_Columns.m_col_id] = 31;
  childrow[m_Columns.m_col_name] = "Xavier McRoberts";
  */

  //Add the model columns to the Combo (which is a kind of view),
  //rendering them in the default way:
  //This is automatically rendered when we use set_entry_text_column().
  //m_Combo.pack_start(m_Columns.m_col_id);
  m_Combo.pack_start(m_Columns.m_col_name);

  m_Combo.set_entry_text_column(m_Columns.m_col_id);

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

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

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_combo_changed()
{
  Gtk::Entry* entry = m_Combo.get_entry();
  //Note: to get changes only when the entry has been completed,
  //instead of on every key press, connect to Entry::signal_changed()
  //instead of ComboBoxEntry::signal_changed.

  if(entry)
  {
    std::cout &lt;&lt; " ID=" &lt;&lt; entry-&gt;get_text() &lt;&lt; std::endl;
  }
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

<sect2 id="comboboxentry-example-simple"><title>Exemple texte simple</title>

<figure id="figure-comboboxentry-text">
  <title>Boîte combinée avec saisie de texte</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/comboboxentry_text.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/combobox/entry_text?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm/window.h&gt;
#include &lt;gtkmm/comboboxtext.h&gt;

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
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/stock.h&gt;
#include &lt;iostream&gt;

ExampleWindow::ExampleWindow()
: m_Combo(true /* has_entry */)
{
  set_title("ComboBoxText example");

  //Fill the combo:
  m_Combo.append("something");
  m_Combo.append("something else");
  m_Combo.append("something or other");

  add(m_Combo);

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

  m_Combo.property_has_frame() = false;
  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_combo_changed()
{
  Glib::ustring text = m_Combo.get_active_text();
  if(!(text.empty()))
    std::cout &lt;&lt; "Combo changed: " &lt;&lt; text &lt;&lt; std::endl;
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>




</sect1>

</chapter>


<chapter id="chapter-textview">
<title>Élément graphique TextView</title>
<para>L'élément graphique <classname>TextView</classname> s'utilise pour afficher et modifier de grosses quantités de texte formatté. Comme l'objet <classname>TreeView</classname>, il y a une correspondance vue/modèle. Dans le cas présent, le modèle est l'objet <classname>TextBuffer</classname>.</para>

<sect1 id="sec-textview-buffer">
<title>Le tampon</title>
<para><classname>Gtk::TextBuffer</classname> est un modèle contenant les données pour <classname>Gtk::TextView</classname>, tout comme <classname>Gtk::TreeModel</classname> utilisé par <classname>Gtk::TreeView</classname>. Cela permet à deux <classname>Gtk::TextView</classname> ou plus de partager le même <classname>TextBuffer</classname> tout en étant affichés de façon légèrement différente. Ou bien encore, vous pouvez disposer de plusieurs <classname>Gtk::TextBuffer</classname> et choisir d'afficher dans le même élément graphique <classname>Gtk::TextView</classname> le contenu de l'un ou l'autre d'entre eux selon les circonstances.</para>
<para>L'objet <classname>TextView</classname> crée par défaut son propre <classname>TextBuffer</classname>. Vous y accédez avec la fonction membre <methodname>get_buffer()</methodname>.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1TextBuffer.html">Référence</ulink></para>

<sect2 id="textview-iterators">
<title>Itérateurs</title>
<para>
</para>
</sect2>

<sect2 id="textview-formatting">
<title>Balisages et formats</title>

<sect3 id="textview-formatting-tags">
<title>Balisages</title>
<para>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 :</para>
<programlisting>Glib::RefPtr&lt;Gtk::TextBuffer::Tag&gt; refTagMatch =
    Gtk::TextBuffer::Tag::create();
refTagMatch-&gt;property_background() = "orange";</programlisting>
<para>Vous pouvez définir un nom pour l'objet <classname>Tag</classname> quand vous appelez la fonction membre <methodname>create()</methodname>, mais ce n'est pas obligatoire.</para>

<para>La classe <classname>Tag</classname> dispose de nombreuses autres propriétés.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1TextTag.html">Référence</ulink></para>

</sect3>

<sect3 id="textview-formatting-tagtable">
<title>Tableau des balises</title>

<para>Chaque <classname>Gtk::TextBuffer</classname> utilise un objet <classname>Gtk::TextBuffer::TagTable</classname> contenant les balises pour ce tampon. Deux objets <classname>TextBuffer</classname> ou plus peuvent partager le même objet <classname>TagTable</classname>. Quand vous créez un objet <classname>Tag</classname> vous devez l'incorporer dans l'objet <classname>TagTable</classname>. Par exemple :</para>
<programlisting>Glib::RefPtr&lt;Gtk::TextBuffer::TagTable&gt; refTagTable =
    Gtk::TextBuffer::TagTable::create();
refTagTable-&gt;add(refTagMatch);
// Avec un peu de chance une future version de <application>gtkmm</application> 
// disposera d'une fonction membre set_tag_table(),
// à utiliser après la création du tampon.
Glib::RefPtr&lt;Gtk::TextBuffer&gt; refBuffer =
    Gtk::TextBuffer::create(refTagTable);</programlisting>

<para>Vous pouvez aussi utiliser <methodname>get_tag_table()</methodname> pour obtenir, et peut-être modifier, l'objet <classname>TagTable</classname> par défaut du <classname>TextBuffer</classname> au lieu d'en créer un explicitement.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1TextTagTable.html">Référence</ulink></para>

</sect3>

<sect3 id="textview-formatting-applying-tags">
<title>Application des balises</title>
<para>Si vous avez créé un <classname>Tag</classname> et l'avez ajouté à l'objet <classname>TagTable</classname>, vous pouvez appliquer cette balise sur une partie du texte du <classname>TextBuffer</classname> 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  <classname>Gtk::TextBuffer::iterator</classname>. Par exemple :</para>
<programlisting>refBuffer-&gt;apply_tag(refTagMatch, iterRangeStart, iterRangeStop);</programlisting>
<para>Vous pouvez également définir le balisage dès l'insertion du texte : refBuffer-&gt;insert_with_tag(iter, "Un peu de texte", refTagMatch);</para>

<para>Vous pouvez appliquer plus d'un objet <classname>Tag</classname> au même texte en utilisant plusieurs fois la fonction membre <methodname>apply_tag()</methodname> ou en utilisant <methodname>insert_with_tags()</methodname>. L'objet <classname>Tag</classname> 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 <methodname>Tag::set_priority()</methodname>.</para>

</sect3>
</sect2>

<sect2 id="textview-marks">
<title>Marquages</title>
<para>Les itérateurs du <classname>TextBuffer</classname> sont généralement invalidés si le texte est modifié ; mais, vous pouvez utiliser un objet <classname>Gtk::TextBuffer::Mark</classname> pour mémoriser une position dans ces cas-là. Par exemple :</para>
<programlisting>Glib::RefPtr&lt;Gtk::TextBuffer::Mark&gt; refMark =
    refBuffer-&gt;create_mark(iter);</programlisting>

<para>Puis vous utiliserez ultérieurement la fonction membre <methodname>get_iter()</methodname> pour créer un itérateur pour la nouvelle position de l'objet <classname>Mark</classname>.</para>

<para>Il y a deux objets <classname>Mark</classname> prédéfinis — <literal>insert</literal> et <literal>select_bound</literal>, objets auxquels vous aurez accès grâce aux fonctions membres <methodname>get_insert()</methodname> et <methodname>get_selection_bound()</methodname> de la classe <classname>TextBuffer</classname>.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1TextMark.html">Référence</ulink></para>

</sect2>

<sect2 id="textview-view">
<title>La vue</title>
<para>Comme mentionné plus haut, chaque <classname>TextView</classname> possède un <classname>TextBuffer</classname> et un ou plusieurs <classname>TextView</classname> peuvent partager le même <classname>TextBuffer</classname>.</para>

<para>Comme pour un <classname>TreeView</classname>, vous pouvez placer l'objet <classname>TextView</classname> dans un objet <classname>ScrolledWindow</classname> pour permettre à l'utilisateur d'explorer la totalité du texte à l'aide de barres de défilement.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1TextView.html">Référence</ulink></para>

<sect3 id="textview-default-formatting">
<title>Format par défaut</title>
<para><classname>TextView</classname> 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 <classname>Gtk::TextTag</classname> dans le tampon, si elles définissent les mêmes choses. Par exemple, <methodname>set_left_margin()</methodname>, <methodname>set_right_margin()</methodname>, <methodname>set_indent()</methodname>, etc.</para>
</sect3>

<sect3 id="textview-scrolling">
<title>Défilement</title>
<para><classname>Gtk::TextView</classname> dispose de diverses fonctions membres <methodname>scroll_to_*()</methodname>. Elles vous permettent de vous assurer qu'une zone donnée du texte du tampon est visible. Ainsi, la fonctionnalité Rechercher de votre application pourra utiliser la fonction membre <methodname>Gtk::TextView::scroll_to_iter()</methodname> pour afficher le texte trouvé.</para>
</sect3>

</sect2>


</sect1>

<sect1 id="sec-widgets-and-childanchors">
<title>Éléments graphiques et ancres pour enfant</title>
<para>Vous pouvez incorporer des éléments graphiques, comme des <classname>Gtk::Button</classname>, dans le texte. Chaque élément graphique de ce type a besoin d'un objet <classname>ChildAnchor</classname>. Les ancrages des (objets) enfants sont associés à des <classname>iterators</classname>. Ainsi, pour créer un ancrage pour un objet enfant à une position donnée, utilisez <methodname>Gtk::TextBuffer::create_child_anchor()</methodname> :</para>
<programlisting>Glib::RefPtr&lt;Gtk::TextChildAnchor&gt; refAnchor =
    refBuffer-&gt;create_child_anchor(iter);</programlisting>

<para>Puis, pour ajouter l'élément graphique à la position indiquée, servez-vous de <methodname>Gtk::TextView::add_child_at_anchor()</methodname> :</para>
<programlisting>m_TextView.add_child_at_anchor(m_Button, refAnchor);</programlisting>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1TextChildAnchor.html">Référence</ulink></para>

</sect1>

<sect1 id="sec-textview-examples"><title>Exemples</title>

<sect2 id="textview-example-simple"><title>Un exemple simple</title>

<figure id="figure-textview">
  <title>Élément graphique TextView</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/textview.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/textview/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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::VBox m_VBox;

  Gtk::ScrolledWindow m_ScrolledWindow;
  Gtk::TextView m_TextView;
  
  Glib::RefPtr&lt;Gtk::TextBuffer&gt; m_refTextBuffer1, m_refTextBuffer2;

  Gtk::HButtonBox m_ButtonBox;
  Gtk::Button m_Button_Quit, m_Button_Buffer1, m_Button_Buffer2;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"

ExampleWindow::ExampleWindow()
: m_Button_Quit(Gtk::Stock::QUIT),
  m_Button_Buffer1("Use buffer 1"),
  m_Button_Buffer2("Use buffer 2")
{
  set_title("Gtk::TextView example");
  set_border_width(5);
  set_default_size(400, 200);


  add(m_VBox);

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

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

  m_VBox.pack_start(m_ScrolledWindow);

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

  m_ButtonBox.pack_start(m_Button_Buffer1, Gtk::PACK_SHRINK);
  m_ButtonBox.pack_start(m_Button_Buffer2, Gtk::PACK_SHRINK);
  m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
  m_ButtonBox.set_border_width(5);
  m_ButtonBox.set_spacing(5);
  m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);

  //Connect signals:
  m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_quit) );
  m_Button_Buffer1.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_buffer1) );
  m_Button_Buffer2.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_buffer2) );

  fill_buffers();
  on_button_buffer1();

  show_all_children();
}

void ExampleWindow::fill_buffers()
{
  m_refTextBuffer1 = Gtk::TextBuffer::create();
  m_refTextBuffer1-&gt;set_text("This is the text from TextBuffer #1.");

  m_refTextBuffer2 = Gtk::TextBuffer::create();
  m_refTextBuffer2-&gt;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);
}

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

</sect1>

</chapter>

<chapter id="chapter-menus-and-toolbars">
<title>Menus et barres d'outils</title>

<para>Les menus et les barres d'outils ont des API distinctes, mais vous pouvez les manipuler simultanément en utilisant l'<classname>UIManager</classname> pour définir une <classname>Action</classname> que vous disposez ensuite à la fois dans le menu et dans la barre d'outils. De la sorte, vous pourrez gérer le déclenchement de l'action d'un coup au lieu d'organiser une réponse séparée aux éléments du menu et à ceux de la barre d'outils. Vous pourrez également activer ou désactiver les éléments de menu et de barre d'outils par l'intermédiaire de l'objet <classname>Action</classname>.</para>
<para>Cette façon d'opérer implique l'utilisation des classes <classname>Gtk::ActionGroup</classname>, <classname>Gtk::Action</classname> et <classname>UIManager</classname> ; chacune d'entre elles sera instanciée avec la fonction membre <methodname>create()</methodname> qui renverra un pointeur <classname>RefPtr</classname>.</para>

<sect1 id="sec-actions">
<title>Actions</title>
<para>Créez tout d'abord un objet <classname>Action</classname> et ajoutez-le à un <classname>ActionGroup</classname> avec <methodname>ActionGroup::add()</methodname>.</para>

<para>Les paramètres de <methodname>Action::create()</methodname> définissent le nom de l'action et la manière dont celle-ci apparaîtra dans les menus et barres d'outils. Utilisez des éléments du catalogue si possible ; ainsi, il ne vous sera pas nécessaire de préciser l'étiquette, le raccourci clavier, l'icône et les infobulles ; de plus, vous bénéficierez des traductions existantes.</para>
<para>Vous pouvez également indiquer le gestionnaire de signal lors de l'appel à <methodname>ActionGroup::add()</methodname>. Ce gestionnaire de signal sera appelé quand l'action sera activée par l'intermédiaire, soit de l'élément de menu, soit du bouton de la barre d'outils.</para>
<para>Notez que vous devez définir des actions pour les éléments de sous-menus de la même manière que pour les menus.</para>

<para>Par exemple :</para>
<programlisting>m_refActionGroup = Gtk::ActionGroup::create();

m_refActionGroup-&gt;add( Gtk::Action::create("MenuFile", "_File") );
m_refActionGroup-&gt;add( Gtk::Action::create("New", Gtk::Stock::NEW),
  sigc::mem_fun(*this, &amp;ExampleWindow::on_action_file_new) );
m_refActionGroup-&gt;add( Gtk::Action::create("ExportData", "Export Data"),
  sigc::mem_fun(*this, &amp;ExampleWindow::on_action_file_open) );
m_refActionGroup-&gt;add( Gtk::Action::create("Quit", Gtk::Stock::QUIT),
  sigc::mem_fun(*this, &amp;ExampleWindow::on_action_file_quit) );</programlisting>

<para>Notez que les noms des actions, tels qu'ils seront vus par l'utilisateur dans les menus et les barres d'outils, est précisé ici. En les plaçant dans la macro _(), ces chaînes pourront être traduites. Quand vous utilisez les éléments du catalogue Gtk::Stock, les traductions sont, bien entendu, automatiquement accessibles.</para>
</sect1>


<sect1 id="sec-uimanager">
<title>UIManager</title>
<para>Vous devez ensuite créer un <classname>UIManager</classname> dans lequel vous ajoutez les objets <classname>ActionGroup</classname> avec <methodname>insert_action_group()</methodname>. Il est judicieux d'indiquer à cet instant à la fenêtre parent de répondre aux raccourcis claviers avec la fonction membre <methodname>add_accel_group()</methodname>.</para>

<para>Par exemple,</para>
<programlisting>Glib::RefPtr&lt;Gtk::UIManager&gt; m_refUIManager =
    Gtk::UIManager::create();
m_refUIManager-&gt;insert_action_group(m_refActionGroup);
add_accel_group(m_refUIManager-&gt;get_accel_group());</programlisting>
<para>Puis, vous définissez la disposition réelle de l'affichage des menus et des barres d'outils en insérant l'agencement de l'UI dans l'<classname>UIManager</classname>. Cette « chaîne ui » utilise un format XML dans lequel vous mentionnez le nom des actions que vous venez de créer. Par exemple :</para>
<programlisting>Glib::ustring ui_info =
    "&lt;ui&gt;"
    "  &lt;menubar name='MenuBar'&gt;"
    "    &lt;menu action='MenuFile'&gt;"
    "      &lt;menuitem action='New'/&gt;"
    "      &lt;menuitem action='Open'/&gt;"
    "      &lt;separator/&gt;"
    "      &lt;menuitem action='Quit'/&gt;"
    "    &lt;/menu&gt;"
    "    &lt;menu action='MenuEdit'&gt;"
    "      &lt;menuitem action='Cut'/&gt;"
    "      &lt;menuitem action='Copy'/&gt;"
    "      &lt;menuitem action='Paste'/&gt;"
    "    &lt;/menu&gt;"
    "  &lt;/menubar&gt;"
    "  &lt;toolbar  name='ToolBar'&gt;"
    "    &lt;toolitem action='Open'/&gt;"
    "    &lt;toolitem action='Quit'/&gt;"
    "  &lt;/toolbar&gt;"
    "&lt;/ui&gt;";

m_refUIManager-&gt;add_ui_from_string(ui_info);</programlisting>

<para>Souvenez-vous que ces noms sont uniquement les identifiants utilisés lors de la création des actions. Ce n'est pas le texte que l'utilisateur verra dans les menus et les barres d'outils. Nous avons indiqué les libellés lisibles par l'utilisateur lors de la création des actions.</para>
<para>Pour créer un objet <classname>Gtk::MenuBar</classname> ou <classname>Gtk::Toolbar</classname> que vous pouvez vraiment afficher, utilisez la fonction membre <methodname>UIManager::get_widget()</methodname> et ajoutez l'élément graphique dans un conteneur. Par exemple :</para>
<programlisting>Gtk::Widget* pMenubar = m_refUIManager-&gt;get_widget("/MenuBar");
pBox-&gt;add(*pMenuBar, Gtk::PACK_SHRINK);</programlisting>

</sect1>


<sect1 id="sec-menus-popup"><title>Menus contextuels</title>
<para>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.</para>

<para>La présentation UI d'un menu contextuel utilise la balise <literal>popup</literal>. Par exemple :</para>
<programlisting>Glib::ustring ui_info =
    "&lt;ui&gt;"
    "  &lt;popup name='PopupMenu'&gt;"
    "    &lt;menuitem action='ContextEdit'/&gt;"
    "    &lt;menuitem action='ContextProcess'/&gt;"
    "    &lt;menuitem action='ContextRemove'/&gt;"
    "  &lt;/popup&gt;"
    "&lt;/ui&gt;";

m_refUIManager-&gt;add_ui_from_string(ui_info);</programlisting>

<para>Pour afficher le menu contextuel, utilisez la fonction membre <methodname>popup()</methodname> de la classe <classname>Gtk::Menu</classname>. Vous indiquez l'identifiant du bouton de souris et le délai d'activation tels que fournis par le signal <literal>button_press_event</literal>, signal que vous devez gérer de toutes façons. Par exemple :</para>
<programlisting>bool ExampleWindow::on_button_press_event(GdkEventButton* event)
{
  if( (event-&gt;type == GDK_BUTTON_PRESS) &amp;&amp;
      (event-&gt;button == 3) )
  {
    m_Menu_Popup-&gt;popup(event-&gt;button, event-&gt;time);
    return true; // Il est géré.
  }
  else
    return false;
}</programlisting>

</sect1>

<sect1 id="sec-menus-examples">
    <title>Exemples</title>

<sect2 id="menu-example-main"><title>Exemple de menu principal</title>

<figure id="figure-menus-mainmenu">
  <title>Menu principal</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/main_menu.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/menus/main_menu/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

protected:
  //Signal handlers:
  void on_menu_file_new_generic();
  void on_menu_file_quit();
  void on_menu_others();

  void on_menu_choices_one();
  void on_menu_choices_two();

  //Child widgets:
  Gtk::VBox m_Box;

  Glib::RefPtr&lt;Gtk::UIManager&gt; m_refUIManager;
  Glib::RefPtr&lt;Gtk::ActionGroup&gt; m_refActionGroup;
  Glib::RefPtr&lt;Gtk::RadioAction&gt; m_refChoiceOne, m_refChoiceTwo;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/stock.h&gt;
#include &lt;iostream&gt;

ExampleWindow::ExampleWindow()
{
  set_title("main menu example");
  set_default_size(200, 200);

  add(m_Box); // put a MenuBar at the top of the box and other stuff below it.

  //Create actions for menus and toolbars:
  m_refActionGroup = Gtk::ActionGroup::create();

  //File|New sub menu:
  m_refActionGroup-&gt;add(Gtk::Action::create("FileNewStandard",
              Gtk::Stock::NEW, "_New", "Create a new file"),
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_new_generic));

  m_refActionGroup-&gt;add(Gtk::Action::create("FileNewFoo",
              Gtk::Stock::NEW, "New Foo", "Create a new foo"),
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_new_generic));

  m_refActionGroup-&gt;add(Gtk::Action::create("FileNewGoo",
              Gtk::Stock::NEW, "_New Goo", "Create a new goo"),
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_new_generic));

  //File menu:
  m_refActionGroup-&gt;add(Gtk::Action::create("FileMenu", "File"));
  //Sub-menu.
  m_refActionGroup-&gt;add(Gtk::Action::create("FileNew", Gtk::Stock::NEW));
  m_refActionGroup-&gt;add(Gtk::Action::create("FileQuit", Gtk::Stock::QUIT),
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_quit));

  //Edit menu:
  m_refActionGroup-&gt;add(Gtk::Action::create("EditMenu", "Edit"));
  m_refActionGroup-&gt;add(Gtk::Action::create("EditCopy", Gtk::Stock::COPY),
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_others));
  m_refActionGroup-&gt;add(Gtk::Action::create("EditPaste", Gtk::Stock::PASTE),
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_others));
  m_refActionGroup-&gt;add(Gtk::Action::create("EditSomething", "Something"),
          Gtk::AccelKey("&lt;control&gt;&lt;alt&gt;S"),
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_others));


  //Choices menu, to demonstrate Radio items
  m_refActionGroup-&gt;add( Gtk::Action::create("ChoicesMenu", "Choices") );
  Gtk::RadioAction::Group group_userlevel;
  m_refChoiceOne = Gtk::RadioAction::create(group_userlevel, "ChoiceOne", "One");
  m_refActionGroup-&gt;add(m_refChoiceOne,
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_choices_one) );
  m_refChoiceTwo = Gtk::RadioAction::create(group_userlevel, "ChoiceTwo", "Two");
  m_refActionGroup-&gt;add(m_refChoiceTwo,
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_choices_two) );

  //Help menu:
  m_refActionGroup-&gt;add( Gtk::Action::create("HelpMenu", "Help") );
  m_refActionGroup-&gt;add( Gtk::Action::create("HelpAbout", Gtk::Stock::HELP),
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_others) );

  m_refUIManager = Gtk::UIManager::create();
  m_refUIManager-&gt;insert_action_group(m_refActionGroup);

  add_accel_group(m_refUIManager-&gt;get_accel_group());

  //Layout the actions in a menubar and toolbar:
  Glib::ustring ui_info = 
        "&lt;ui&gt;"
        "  &lt;menubar name='MenuBar'&gt;"
        "    &lt;menu action='FileMenu'&gt;"
        "      &lt;menu action='FileNew'&gt;"
        "        &lt;menuitem action='FileNewStandard'/&gt;"
        "        &lt;menuitem action='FileNewFoo'/&gt;"
        "        &lt;menuitem action='FileNewGoo'/&gt;"
        "      &lt;/menu&gt;"
        "      &lt;separator/&gt;"
        "      &lt;menuitem action='FileQuit'/&gt;"
        "    &lt;/menu&gt;"
        "    &lt;menu action='EditMenu'&gt;"
        "      &lt;menuitem action='EditCopy'/&gt;"
        "      &lt;menuitem action='EditPaste'/&gt;"
        "      &lt;menuitem action='EditSomething'/&gt;"
        "    &lt;/menu&gt;"
        "    &lt;menu action='ChoicesMenu'&gt;"
        "      &lt;menuitem action='ChoiceOne'/&gt;"
        "      &lt;menuitem action='ChoiceTwo'/&gt;"
        "    &lt;/menu&gt;"
        "    &lt;menu action='HelpMenu'&gt;"
        "      &lt;menuitem action='HelpAbout'/&gt;"
        "    &lt;/menu&gt;"
        "  &lt;/menubar&gt;"
        "  &lt;toolbar  name='ToolBar'&gt;"
        "    &lt;toolitem action='FileNewStandard'/&gt;"
        "    &lt;toolitem action='FileQuit'/&gt;"
        "  &lt;/toolbar&gt;"
        "&lt;/ui&gt;";

  try
  {
    m_refUIManager-&gt;add_ui_from_string(ui_info);
  }
  catch(const Glib::Error&amp; ex)
  {
    std::cerr &lt;&lt; "building menus failed: " &lt;&lt;  ex.what();
  }

  //Get the menubar and toolbar widgets, and add them to a container widget:
  Gtk::Widget* pMenubar = m_refUIManager-&gt;get_widget("/MenuBar");
  if(pMenubar)
    m_Box.pack_start(*pMenubar, Gtk::PACK_SHRINK);

  Gtk::Widget* pToolbar = m_refUIManager-&gt;get_widget("/ToolBar") ;
  if(pToolbar)
    m_Box.pack_start(*pToolbar, Gtk::PACK_SHRINK);

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_menu_file_quit()
{
  hide(); //Closes the main window to stop the Gtk::Main::run().
}

void ExampleWindow::on_menu_file_new_generic()
{
   std::cout &lt;&lt; "A File|New menu item was selected." &lt;&lt; std::endl;
}

void ExampleWindow::on_menu_others()
{
  std::cout &lt;&lt; "A menu item was selected." &lt;&lt; std::endl;
}

void ExampleWindow::on_menu_choices_one()
{
  Glib::ustring message;
  if(m_refChoiceOne-&gt;get_active())
    message = "Choice 1 was selected.";
  else
    message = "Choice 1 was deselected";

  std::cout &lt;&lt; message &lt;&lt; std::endl;
}

void ExampleWindow::on_menu_choices_two()
{
  Glib::ustring message;
  if(m_refChoiceTwo-&gt;get_active())
    message = "Choice 2 was selected.";
  else
    message = "Choice 2 was deselected";

  std::cout &lt;&lt; message &lt;&lt; std::endl;
}

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

<sect2 id="menu-example-popup"><title>Exemple de menu contextuel</title>

<figure id="figure-menus-popup">
  <title>Menu contextuel</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/menu_popup.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/menus/popup/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

protected:
  //Signal handlers:
  virtual bool on_button_press_event(GdkEventButton* event);
  void on_menu_file_popup_generic();

  //Child widgets:
  Gtk::VBox m_Box;
  Gtk::EventBox m_EventBox;
  Gtk::Label m_Label;

  Glib::RefPtr&lt;Gtk::UIManager&gt; m_refUIManager;
  Glib::RefPtr&lt;Gtk::ActionGroup&gt; m_refActionGroup;

  Gtk::Menu* m_pMenuPopup;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/stock.h&gt;
#include &lt;iostream&gt;

ExampleWindow::ExampleWindow()
: m_Label("Right-click to see the popup menu."),
  m_pMenuPopup(0)
  /* m_Image(Gtk::Stock::DIALOG_QUESTION, Gtk::ICON_SIZE_MENU) */
{
  set_title("popup example");
  set_default_size(200, 200);

  add(m_Box);

  //Add an event box that can catch button_press events:
  m_Box.pack_start(m_EventBox);
  m_EventBox.signal_button_press_event().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_press_event) );

  m_EventBox.add(m_Label);

  //Create actions:

  //Fill menu:

  m_refActionGroup = Gtk::ActionGroup::create();

  //File|New sub menu:
  //These menu actions would normally already exist for a main menu, because a
  //context menu should not normally contain menu items that are only available
  //via a context menu.
  m_refActionGroup-&gt;add(Gtk::Action::create("ContextMenu", "Context Menu"));

  m_refActionGroup-&gt;add(Gtk::Action::create("ContextEdit", "Edit"),
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_popup_generic));

  m_refActionGroup-&gt;add(Gtk::Action::create("ContextProcess", "Process"),
          Gtk::AccelKey("&lt;control&gt;P"),
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_popup_generic));

  m_refActionGroup-&gt;add(Gtk::Action::create("ContextRemove", "Remove"),
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_popup_generic));

  //TODO:
  /*
    //Add a ImageMenuElem:
    menulist.push_back( Gtk::Menu_Helpers::ImageMenuElem("_Something", m_Image,
      sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_popup_generic) ) ) ;
  */

  m_refUIManager = Gtk::UIManager::create();
  m_refUIManager-&gt;insert_action_group(m_refActionGroup);

  add_accel_group(m_refUIManager-&gt;get_accel_group());

  //Layout the actions in a menubar and toolbar:
  Glib::ustring ui_info =
        "&lt;ui&gt;"
        "  &lt;popup name='PopupMenu'&gt;"
        "    &lt;menuitem action='ContextEdit'/&gt;"
        "    &lt;menuitem action='ContextProcess'/&gt;"
        "    &lt;menuitem action='ContextRemove'/&gt;"
        "  &lt;/popup&gt;"
        "&lt;/ui&gt;";

  try
  {
    m_refUIManager-&gt;add_ui_from_string(ui_info);
  }
  catch(const Glib::Error&amp; ex)
  {
    std::cerr &lt;&lt; "building menus failed: " &lt;&lt;  ex.what();
  }

  //Get the menu:
  m_pMenuPopup = dynamic_cast&lt;Gtk::Menu*&gt;(
          m_refUIManager-&gt;get_widget("/PopupMenu")); 
  if(!m_pMenuPopup)
    g_warning("menu not found");

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_menu_file_popup_generic()
{
   std::cout &lt;&lt; "A popup menu item was selected." &lt;&lt; std::endl;
}

bool ExampleWindow::on_button_press_event(GdkEventButton* event)
{
  if( (event-&gt;type == GDK_BUTTON_PRESS) &amp;&amp; (event-&gt;button == 3) )
  {
    if(m_pMenuPopup)
      m_pMenuPopup-&gt;popup(event-&gt;button, event-&gt;time);

    return true; //It has been handled.
  }
  else
    return false;
}

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

</sect1>

</chapter>

<chapter id="chapter-toolpalette">
<title>Palette d'outils</title>

<para>L'objet <classname>ToolPalette</classname> est semblable à un objet <classname>Toolbar</classname>, mais il peut comporter un quadrillage d'éléments classés en groupements. L'utilisateur peut masquer ou développer chaque groupement. Comme dans une barre d'outils, les éléments sont affichés sous forme d'icônes uniquement, texte uniquement ou icônes avec texte.</para>
<para>Il est possible de faire glisser, ou simplement activer, les éléments d'un objet <classname>ToolPalette</classname>. Par exemple, l'utilisateur peut faire glisser des objets sur un canevas pour y créer de nouveaux éléments, ou bien, il peut cliquer sur un élément pour activer une taille de plume donnée dans une application de tracé.</para>
<para>Ajoutez un <classname>ToolItemGroup</classname> à une palette d'outils par l'intermédiaire de la fonction membre <function>Gtk::Container::add()</function> de la classe de base. Comme ceci :</para>
<para>
<programlisting>
Gtk::ToolItemGroup* group_brushes =
  Gtk::manage(new Gtk::ToolItemGroup("Brosses"));
m_ToolPalette.add(*group_brushes);
</programlisting>
</para>
<para>Les éléments <classname>Gtk::ToolItem</classname> sont ensuite ajoutés au groupement. Ainsi :</para>
<para>
<programlisting>
Gtk::ToolButton* button = Gtk::manage(new Gtk::ToolButton(icon, "Grande"));
button-&gt;set_tooltip_text("Grande brosse);
group_brushes-&gt;insert(*button);
</programlisting>
</para>
<para>Vous pouvez après cela gérer le signal <literal>clicked</literal> sur l'objet <classname>ToolButton</classname>. Autre possibilité, vous pouvez autoriser le glisser-déposer de l'élément sur un autre élément graphique avec <methodname>Gtk::ToolPalette::add_drag_dest()</methodname>, puis en faisant appel à <methodname>Gtk::ToolPalette::get_drag_item()</methodname> dans le gestionnaire du signal <literal>drag_data_received</literal> de l'autre élément graphique.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1ToolPalette.html">Référence de ToolPalette</ulink></para>
<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1ToolItemGroup.html">Référence de ToolItemGroup</ulink></para>
<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1ToolItem.html">Référence de ToolItem</ulink></para>

<sect1 id="toolpallete-dranganddrop">
<title>Glisser-déposer</title>
<para>Appelez la fonction membre <methodname>add_drag_dest()</methodname> pour permettre le glisser-déposer d'éléments ou de groupes depuis une palette d'outils jusqu'à un élément graphique destination donné. Puis vous pouvez vous servir de <methodname>get_drag_item()</methodname> pour savoir quel outil élémentaire ou quel groupe a été glissé. Un <literal>dynamic_cast</literal> vous permet de savoir s'il s'agit d'un élément ou d'un groupe. Ainsi, dans le gestionnaire du signal <literal>drag_data_received</literal> vous utilisez ce forçage de type pour ajouter un élément déposé ou pour afficher une icône adaptée pendant le glissé.</para>
<para>Consultez le chapitre <link linkend="chapter-draganddrop">Glisser-déposer</link> pour des considérations générales sur cette fonctionnalité avec gtkmm.</para>
</sect1>

<sect1 id="toolpalette-example"><title>Exemple de palette d'outils</title>

<para>Dans cet exemple, des objets <classname>ToolPalette</classname> et <classname>DrawingArea</classname> sont associés à une fenêtre. L'utilisateur est autorisé à faire un glisser-déposer depuis la palette d'outils sur la surface de tracé. La palette d'outils contient divers groupes d'éléments. Des boîtes combinées permettent à l'utilisateur de changer le style et l'orientation de la palette d'outils.</para>

<figure id="figure-toolpalette">
  <title>Palette d'outils</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/toolpalette.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/toolpalette/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>canvas.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_CANVAS_H
#define GTKMM_EXAMPLE_CANVAS_H

#include &lt;gtkmm.h&gt;

// This little canvas class is only here 
// because gtkmm does not have a canvas class yet.
// Applications should probably use GooCanvas::Canvas (goocanvasmm) instead.
class Canvas : public Gtk::DrawingArea
{
public:
  Canvas();
  virtual ~Canvas();

private:

  class CanvasItem
  {
  public:
    CanvasItem(Gtk::Widget* canvas, Gtk::ToolButton* button, double x, double y)
    {
      const Gtk::StockID stock_id(button-&gt;get_stock_id()); 
      this-&gt;pixbuf = canvas-&gt;render_icon_pixbuf(stock_id, Gtk::ICON_SIZE_DIALOG);
      this-&gt;x = x;
      this-&gt;y = y;
    }

    Glib::RefPtr&lt;Gdk::Pixbuf&gt; pixbuf;
    double x, y;
  };

  void item_draw(const CanvasItem *item,
    const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr,
    bool preview);

  virtual bool on_draw(const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr);
  virtual void on_drag_data_received(const Glib::RefPtr&lt;Gdk::DragContext&gt;&amp; context, 
    int x, int y, const Gtk::SelectionData&amp; selection_data, guint info, guint time);
  virtual bool on_drag_motion(const Glib::RefPtr&lt;Gdk::DragContext&gt;&amp; context, int x, int y, guint time);
  virtual bool on_drag_drop(const Glib::RefPtr&lt;Gdk::DragContext&gt;&amp; context, int x, int y, guint time);
  virtual void on_drag_leave(const Glib::RefPtr&lt;Gdk::DragContext&gt;&amp; context, guint time);

  bool m_drag_data_requested_for_drop; //So we know what to do in on_drag_data_received().
  CanvasItem* m_drop_item;
  
  typedef std::vector&lt;CanvasItem*&gt; type_vec_items;
  type_vec_items m_canvas_items;
};

#endif //GTKMM_EXAMPLE_CANVAS_H
</programlisting>
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;
#include "canvas.h"

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

private:

  void load_stock_items();
  void load_toggle_items();
  void load_special_items();

  //Signal handlers:
  void on_combo_orientation_changed();
  void on_combo_style_changed();

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

    ModelColumnsOrientation()
    { add(m_col_value); add(m_col_name); }

    Gtk::TreeModelColumn&lt;Gtk::Orientation&gt; m_col_value;
    Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_name;
  };

  ModelColumnsOrientation m_ColumnsOrientation;

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

    ModelColumnsStyle()
    { add(m_col_value); add(m_col_name); }

    Gtk::TreeModelColumn&lt;int&gt; m_col_value; //We use int to also allow -1
    Gtk::TreeModelColumn&lt;Glib::ustring&gt; m_col_name;
  };

  ModelColumnsStyle m_ColumnsStyle;


  //Child widgets:
  Gtk::VBox m_VBox;
  Gtk::HBox m_HBox;
  Gtk::ComboBox m_ComboOrientation;
  Glib::RefPtr&lt;Gtk::ListStore&gt; m_refTreeModelOrientation;
  Gtk::ComboBox m_ComboStyle;
  Glib::RefPtr&lt;Gtk::ListStore&gt; m_refTreeModelStyle;
  Gtk::ToolPalette m_ToolPalette;
  Gtk::ScrolledWindow m_ScrolledWindowPalette;
  Gtk::ScrolledWindow m_ScrolledWindowCanvas;
  Canvas m_Canvas;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"

static bool sort_predicate(const Gtk::StockID&amp; a, const Gtk::StockID&amp; b)
{
  return a.get_string() &lt; b.get_string();
}


void ExampleWindow::load_stock_items()
{
  Gtk::ToolItemGroup* group_af = 
    Gtk::manage(new Gtk::ToolItemGroup("Stock Icons (A-F)"));
  m_ToolPalette.add(*group_af);
  Gtk::ToolItemGroup* group_gn = 
    Gtk::manage(new Gtk::ToolItemGroup("Stock Icons (G-N)"));
  m_ToolPalette.add(*group_gn);
  Gtk::ToolItemGroup* group_or = 
    Gtk::manage(new Gtk::ToolItemGroup("Stock Icons (O-R)"));
  m_ToolPalette.add(*group_or);
  Gtk::ToolItemGroup* group_sz = 
    Gtk::manage(new Gtk::ToolItemGroup("Stock Icons (S-Z)"));
  m_ToolPalette.add(*group_sz);

  // Obtain the IDs of all stock items:
  typedef std::vector&lt;Gtk::StockID&gt; type_vecIDs;
  type_vecIDs vecIDs = Gtk::Stock::get_ids();

  std::sort(vecIDs.begin(), vecIDs.end(), &amp;sort_predicate);

  Gtk::ToolItemGroup* group = 0;

  // Iterate through them, populating the ListStore as appropriate:
  for(type_vecIDs::const_iterator iterIDs = vecIDs.begin(); iterIDs != vecIDs.end(); ++iterIDs)
  {
    const Gtk::StockID&amp; stockid = *iterIDs;
    const Glib::ustring str = stockid.get_string();
    if(str.size() &lt; 4)
      continue;

    switch(str[4])
    {
      case 'a':
        group = group_af;
        break;
      case 'g':
        group = group_gn;
        break;
      case 'o':
        group = group_or;
        break;
      case 's':
        group = group_sz;
        break;
      default:
        //Use the previous group
        //(They are sorted.)
        break;
    }

    if(!group)
      continue;

    Gtk::ToolButton* button = Gtk::manage(new Gtk::ToolButton(stockid));
    button-&gt;set_tooltip_text(str);
    button-&gt;set_is_important();
    group-&gt;insert(*button);

    Gtk::StockItem stockitem;
    if(!Gtk::StockItem::lookup(stockid, stockitem) || 
      stockitem.get_label().empty())
        button-&gt;set_label(str);
  }
}


void ExampleWindow::load_toggle_items()
{
  Gtk::ToolItemGroup* group = 
    Gtk::manage(new Gtk::ToolItemGroup("Radio Item"));
  m_ToolPalette.add(*group);

  Gtk::RadioToolButton::Group radio_group;

  for(int i = 1; i &lt;= 10; ++i)
  {
    const Glib::ustring label = Glib::ustring::compose("#%1", i);
    Gtk::RadioToolButton* button = Gtk::manage(new Gtk::RadioToolButton());
    button-&gt;set_group(radio_group);
    button-&gt;set_label(label);
   
    group-&gt;insert(*button);
  }
}


static Gtk::ToolItem* create_entry_item(const Glib::ustring&amp; text)
{
  Gtk::Entry* entry = Gtk::manage(new Gtk::Entry());
  entry-&gt;set_text(text);
  entry-&gt;set_width_chars(5);

  Gtk::ToolItem* item = Gtk::manage(new Gtk::ToolItem());
  item-&gt;add(*entry);

  return item;
}

void ExampleWindow::load_special_items()
{
  Gtk::ToolItemGroup* group = Gtk::manage(new Gtk::ToolItemGroup());

  Gtk::Button *label_button = Gtk::manage(new Gtk::Button("Advanced Features"));
  label_button-&gt;show();
  group-&gt;set_label_widget(*label_button);
  m_ToolPalette.add(*group);

  Gtk::ToolItem* item = create_entry_item ("homogeneous=false");
  group-&gt;insert(*item);
  //TODO: Add Gtk::Container::set_child_property().
  gtk_container_child_set (GTK_CONTAINER (group-&gt;gobj()), GTK_WIDGET (item-&gt;gobj()),
                           "homogeneous", FALSE, NULL);

  item = create_entry_item ("homogeneous=FALSE, expand=TRUE");
  group-&gt;insert(*item);
  gtk_container_child_set (GTK_CONTAINER (group-&gt;gobj()), GTK_WIDGET (item-&gt;gobj()),
                           "homogeneous", FALSE, "expand", TRUE,
                           NULL);

  item = create_entry_item ("homogeneous=FALSE, expand=TRUE, fill=FALSE");
  group-&gt;insert(*item);
  gtk_container_child_set (GTK_CONTAINER (group-&gt;gobj()), GTK_WIDGET (item-&gt;gobj()),
                           "homogeneous", FALSE, "expand", TRUE,
                           "fill", FALSE, NULL);

  item = create_entry_item ("homogeneous=FALSE, expand=TRUE, new-row=TRUE");
  group-&gt;insert(*item);
  gtk_container_child_set (GTK_CONTAINER (group-&gt;gobj()), GTK_WIDGET (item-&gt;gobj()),
                           "homogeneous", FALSE, "expand", TRUE,
                           "new-row", TRUE, NULL);

  item = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::GO_UP));
  item-&gt;set_tooltip_text("Show on vertical palettes only");
  group-&gt;insert(*item);
  item-&gt;set_visible_horizontal(false);

  item = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::GO_FORWARD));
  item-&gt;set_tooltip_text("Show on horizontal palettes only");
  group-&gt;insert(*item);
  item-&gt;set_visible_vertical(false);

  item = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::FULLSCREEN));
  item-&gt;set_tooltip_text("Expanded this item");
  group-&gt;insert(*item);
  gtk_container_child_set (GTK_CONTAINER (group-&gt;gobj()), GTK_WIDGET (item-&gt;gobj()),
                           "homogeneous", FALSE,
                           "expand", TRUE,
                           NULL);

  item = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::HELP));
  item-&gt;set_tooltip_text("A regular item");
  group-&gt;insert(*item);
}

ExampleWindow::ExampleWindow()
: m_VBox(false, 6),
  m_HBox(false, 6)
{
  set_title("Gtk::ToolPalette example");
  set_size_request(600, 600);
  set_border_width(6);

  add(m_VBox);

  //The Orientation ComboBox:
  m_refTreeModelOrientation = Gtk::ListStore::create(m_ColumnsOrientation);
  Gtk::TreeModel::Row row = *(m_refTreeModelOrientation-&gt;append());
  row[m_ColumnsOrientation.m_col_value] = Gtk::ORIENTATION_HORIZONTAL;
  row[m_ColumnsOrientation.m_col_name] = "Horizontal";\
  row = *(m_refTreeModelOrientation-&gt;append());
  row[m_ColumnsOrientation.m_col_value] = Gtk::ORIENTATION_VERTICAL;
  row[m_ColumnsOrientation.m_col_name] = "Vertical";
  m_ComboOrientation.set_model(m_refTreeModelOrientation);
  m_VBox.pack_start(m_ComboOrientation, Gtk::PACK_SHRINK);
  m_ComboOrientation.pack_start(m_ColumnsOrientation.m_col_name);
  m_ComboOrientation.signal_changed().connect(
    sigc::mem_fun(*this, &amp;ExampleWindow::on_combo_orientation_changed) );
  m_ComboOrientation.set_active(row);

  //The Style ComboBox:
  m_refTreeModelStyle = Gtk::ListStore::create(m_ColumnsStyle);
  row = *(m_refTreeModelStyle-&gt;append());
  row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_TEXT;
  row[m_ColumnsStyle.m_col_name] = "Text";\
  row = *(m_refTreeModelStyle-&gt;append());
  row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_BOTH;
  row[m_ColumnsStyle.m_col_name] = "Both";
  row = *(m_refTreeModelStyle-&gt;append());
  row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_BOTH_HORIZ;
  row[m_ColumnsStyle.m_col_name] = "Both: Horizontal";
  row = *(m_refTreeModelStyle-&gt;append());
  row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_ICONS;
  row[m_ColumnsStyle.m_col_name] = "Icons";
  row = *(m_refTreeModelStyle-&gt;append());
  row[m_ColumnsStyle.m_col_value] = -1; // A custom meaning for this demo.
  row[m_ColumnsStyle.m_col_name] = "Default";
  m_ComboStyle.set_model(m_refTreeModelStyle);
  m_VBox.pack_start(m_ComboStyle, Gtk::PACK_SHRINK);
  m_ComboStyle.pack_start(m_ColumnsStyle.m_col_name);
  m_ComboStyle.signal_changed().connect(
    sigc::mem_fun(*this, &amp;ExampleWindow::on_combo_style_changed) );
  m_ComboStyle.set_active(row);

  //Add and fill the ToolPalette:
  load_stock_items();
  load_toggle_items();
  load_special_items();

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

  m_ScrolledWindowPalette.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
  m_ScrolledWindowPalette.set_border_width(6);
  m_ScrolledWindowPalette.add(m_ToolPalette);
  m_HBox.pack_start(m_ScrolledWindowPalette);

  on_combo_orientation_changed();

  m_ScrolledWindowCanvas.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_ALWAYS);
  m_ScrolledWindowCanvas.set_border_width(6);
  m_ScrolledWindowCanvas.add(m_Canvas);
  m_ScrolledWindowCanvas.set_size_request(200, -1);
  m_HBox.pack_start(m_ScrolledWindowCanvas);

  m_ToolPalette.add_drag_dest(m_Canvas,
    Gtk::DEST_DEFAULT_HIGHLIGHT, Gtk::TOOL_PALETTE_DRAG_ITEMS, Gdk::ACTION_COPY);

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_combo_orientation_changed()
{
  Gtk::TreeModel::iterator iter = m_ComboOrientation.get_active();
  if(!iter)
    return;

  Gtk::TreeModel::Row row = *iter;
  const Gtk::Orientation value = row[m_ColumnsOrientation.m_col_value];
 
  m_ToolPalette.set_orientation(value);

  if(value == Gtk::ORIENTATION_HORIZONTAL)
    m_ScrolledWindowPalette.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_NEVER);
  else
    m_ScrolledWindowPalette.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
}

void ExampleWindow::on_combo_style_changed()
{
  Gtk::TreeModel::iterator iter = m_ComboStyle.get_active();
  if(!iter)
    return;

  Gtk::TreeModel::Row row = *iter;
  const int value = row[m_ColumnsStyle.m_col_value];
 
  if(value == -1)
    m_ToolPalette.unset_style();
  else
    m_ToolPalette.set_style((Gtk::ToolbarStyle)value);
}

</programlisting>
<para>File: <filename>canvas.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "canvas.h"
#include &lt;iostream&gt;

Canvas::Canvas()
: m_drag_data_requested_for_drop(false),
  m_drop_item()
{
  set_app_paintable();
}

Canvas::~Canvas()
{
  while(!m_canvas_items.empty())
  {
    type_vec_items::iterator iter = m_canvas_items.begin();
    CanvasItem* item = *iter;
    delete item;
    m_canvas_items.erase(iter);
  }

  if(m_drop_item)
    delete m_drop_item;
}

void Canvas::item_draw(const CanvasItem *item,
  const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr,
  bool preview)
{
  if(!item || !item-&gt;pixbuf)
    return;

  const double cx = item-&gt;pixbuf-&gt;get_width();
  const double cy = item-&gt;pixbuf-&gt;get_height();

  Gdk::Cairo::set_source_pixbuf(cr,
    item-&gt;pixbuf,
    item-&gt;x - cx * 0.5, item-&gt;y - cy * 0.5);

  if(preview)
    cr-&gt;paint_with_alpha(0.6);
  else
    cr-&gt;paint();
}

bool Canvas::on_draw(const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr)
{
  cr-&gt;set_source_rgb(1.0, 1.0, 1.0);
  const Gtk::Allocation allocation = get_allocation();
  cr-&gt;rectangle(0, 0, allocation.get_width(), allocation.get_height());
  cr-&gt;fill();

  for(type_vec_items::iterator iter = m_canvas_items.begin();
    iter != m_canvas_items.end(); ++iter )
  {
    item_draw(*iter, cr, false);
  }

  if(m_drop_item)
    item_draw (m_drop_item, cr, true);

  return true;
}


bool Canvas::on_drag_motion(const Glib::RefPtr&lt;Gdk::DragContext&gt;&amp; context,
  int x, int y, guint time)
{
  m_drag_data_requested_for_drop = false; //It's for drag-motion instead.

  if(m_drop_item)
  {
    // We already have a drop indicator so just update its position.

    m_drop_item-&gt;x = x;
    m_drop_item-&gt;y = y;

    queue_draw();
    context-&gt;drag_status(Gdk::ACTION_COPY, time);
  }
  else
  {
    // Request DnD data for creating a drop indicator.
    // This will cause on_drag_data_received() to be called.
    const Glib::ustring target = drag_dest_find_target(context);

    if (target.empty())
      return false;

    drag_get_data(context, target, time);
  }

  Gtk::DrawingArea::on_drag_motion(context, x, y, time);
  return true;
}


void Canvas::on_drag_data_received(const Glib::RefPtr&lt;Gdk::DragContext&gt;&amp; context, int x, int y, const Gtk::SelectionData&amp; selection_data, guint info, guint time)
{
  // Find the tool button which is the source of this DnD operation.
  Gtk::Widget* widget = drag_get_source_widget(context);

  Gtk::ToolPalette* drag_palette = dynamic_cast&lt;Gtk::ToolPalette*&gt;(widget);
  while(widget &amp;&amp; !drag_palette)
  {
    widget = widget-&gt;get_parent();
    drag_palette = dynamic_cast&lt;Gtk::ToolPalette*&gt;(widget);
  }

  Gtk::ToolItem* drag_item = 0;
  if(drag_palette)
    drag_item = drag_palette-&gt;get_drag_item(selection_data);

  // Create a drop indicator when a tool button was found:
  Gtk::ToolButton* button = dynamic_cast&lt;Gtk::ToolButton*&gt;(drag_item);
  if(!button)
    return;

  if(m_drop_item)
  {
    delete m_drop_item;
    m_drop_item = 0;
  }

  CanvasItem* item = new CanvasItem(this, button, x, y);

  if(m_drag_data_requested_for_drop)
  {
    m_canvas_items.push_back(item);

    // Signal that the item was accepted and then redraw.
    context-&gt;drag_finish(true /* success */, false /* del */, time);
  }
  else
  {
    m_drop_item = item;

    // We are getting this data due to a request in drag_motion,
    // rather than due to a request in drag_drop, so we are just
    // supposed to call gdk_drag_status (), not actually paste in
    // the data.
    context-&gt;drag_status(Gdk::ACTION_COPY, time);
  }

  queue_draw();

  Gtk::DrawingArea::on_drag_data_received(context, x, y, selection_data, info, time);
}


bool Canvas::on_drag_drop(const Glib::RefPtr&lt;Gdk::DragContext&gt;&amp; context, int /* x */, int /* y */, guint time)
{
  // Request DnD data for creating a dopped item.
  // This will cause on_drag_data_received() to be called.
  const Glib::ustring target = drag_dest_find_target(context);

  if (target.empty())
    return false;

  m_drag_data_requested_for_drop = true;
  drag_get_data(context, target, time);

  return true;
}

void Canvas::on_drag_leave(const Glib::RefPtr&lt;Gdk::DragContext&gt;&amp; context, guint time)
{
  //This signal is emitted to clean up the item used for drag-motion,
  //either when the cursor moves out of the widget or when we drop.

  if(!m_drop_item)
    return;

  delete m_drop_item;
  m_drop_item = 0;

  queue_draw();

  Gtk::DrawingArea::on_drag_leave(context, time);
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect1>

</chapter>

<chapter id="chapter-adjustment">
<title>Ajustements</title>

<para><application>gtkmm</application> dispose de nombreux éléments graphiques pouvant être visuellement ajustés avec la souris ou le clavier, tels les éléments graphiques <classname>Range</classname> (décrits dans le paragraphe <link linkend="chapter-range-widgets">Éléments graphiques à plage de réglage</link>). 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 <classname>Viewport</classname>. Tous ces éléments graphiques sont adossés à un objet <classname>Gtk::Adjustment</classname> pour définir cette part commune du comportement de leur API.</para>

<para>Ainsi pour que les applications puissent réagir à une demande de modification, par exemple quand l'utilisateur déplace le curseur dans la barre de défilement, l'objet <classname>Gtk::Adjustment</classname> émet le signal <literal>changed</literal>. Vous pourrez alors utiliser la fonction membre <methodname>get_changed()</methodname> pour connaître la nouvelle valeur.</para>

<sect1 id="sec-creating-adjustment">
<title>Création d'un objet Adjustment</title>

<para>Le constructeur de <classname>Gtk::Adjustment</classname> crée la structure suivante :</para>

<programlisting>Gtk::Adjustment(float value,
                float lower,
                float upper,
                float step_increment = 1,
                float page_increment = 10,
                float page_size = 0);</programlisting>

<para>Le paramètre <parameter>value</parameter> définit la valeur initiale de l'ajustement ; habituellement, elle correspond à la position la plus haute ou la plus à gauche de l'élément graphique à plage de réglage. Les paramètres <parameter>lower</parameter> et <parameter>upper</parameter> bornent la plage des valeurs que l'ajustement est autorisé à gérer. <parameter>step_increment</parameter> est la plus petite valeur de modification incrémentale de <parameter>value</parameter>, <parameter>page_increment</parameter> la plus grande. Le paramètre <parameter>page_size</parameter> correspond communément à quelque chose comme la partie visible d'un élément graphique panneau. Le paramètre <parameter>upper</parameter> représente la coordonnée la plus basse ou la plus à droite pour un enfant d'un élément graphique panneau.</para>

</sect1>

<sect1 id="sec-adjustments-easy">
<title>Facilité d'utilisation des objets Adjustment</title>

<para>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.</para>
<para>Le groupe qui traite ces valeurs comme des nombres arbitraires est celui des éléments graphiques <classname>Range</classname> (les éléments <classname>Scrollbars</classname>, <classname>Scales</classname>, <classname>Progressbar</classname> et <classname>SpinButton</classname>). Ces éléments graphiques sont typiquement ceux qui sont « ajustés » directement par l'utilisateur avec la souris ou le clavier. Ils considèrent les valeurs de <parameter>lower</parameter> et <parameter>upper</parameter> comme étant les bornes de la plage des valeurs dans laquelle l'utilisateur peut définir <parameter>value</parameter>. Par défaut, l'utilisateur ne peut modifier que la grandeur <parameter>value</parameter> de l'ajustement.</para>

<para>L'autre groupe comprend les éléments graphiques <classname>Viewport</classname> et <classname>ScrolledWindow</classname>. Tous ceux-ci utilisent des valeurs en pixels dans leur structure <literal>adjustment</literal>. 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 <literal>adjustement</literal>, 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.</para>

<para>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 :</para>
<programlisting>// crée ses propres ajustements
Gtk::TextView textview;
// utilise également l'ajustement nouvellement créé pour la barre de défilement
Gtk::VScrollbar vscrollbar (*(textview.get_vadjustment()));</programlisting>

</sect1>

<sect1 id="sec-adjustment-internals">
<title>À l'intérieur des ajustements</title>

<para>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 <classname>Range</classname> ou <classname>SpinButton</classname>. Pour avoir accès à la valeur du paramètre <parameter>value</parameter> d'un <classname>Gtk::Adjustment</classname>, utilisez les fonctions membres <methodname>get_value()</methodname> et <methodname>set_value()</methodname>.</para>

<para>Comme mentionné plus haut, <classname>Gtk::Adjustment</classname> peut émettre des signaux. C'est pourquoi, bien entendu, les mises à jour se font automatiquement quand vous partagez un objet ajustement entre un <classname>Scrollbar</classname> et un autre élément graphique ajustable ; tous les éléments graphiques ajustables connectent leurs gestionnaires de signaux au signal <literal>value_changed</literal> de l'ajustement, comme pourrait le faire le programme.</para>

<para>Ainsi, par exemple, avec un élément graphique <classname>Scale</classname>, si vous voulez modifier la rotation d'une image chaque fois que <literal>value</literal> change, vous créez une fonction de rappel du type :</para>
<programlisting>void cb_rotate_picture (Gtk::Widget *picture)
{
  picture-&gt;set_rotation (adj-&gt;value);
...</programlisting>
<para>et la connectez à l'ajustement de l'élément graphique <literal>Scale</literal> ainsi :</para>
<programlisting>adj.value_changed.connect(sigc::bind&lt;Widget*&gt;(sigc::mem_fun(*this,
    &amp;cb_rotate_picture), picture));</programlisting>

<para>Que se passe-t-il quand un élément graphique reconfigure les champs <parameter>upper</parameter> ou <parameter>lower</parameter> de son <classname>Adjustment</classname>, ou bien, quand un utilisateur ajoute du texte dans un élément graphique texte ? Dans ce cas, l'élément graphique émet le signal <literal>changed</literal>.</para>

<para>Les éléments graphiques <classname>Range</classname> 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 <parameter>lower</parameter> et <parameter>upper</parameter> de son <classname>Adjustment</classname>.</para>

<para>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.</para>
<programlisting>adjustment-&gt;changed();</programlisting>

</sect1>

</chapter>

<chapter id="chapter-widgets-without-xwindows">
<title>Éléments graphiques sans fenêtre-X</title>

<para>Certains éléments graphiques n'ont pas de fenêtre-X associée ; ils ne sont donc pas capables de recevoir les notifications des événements X. Autrement dit : les signaux décrits au paragraphe <link linkend="sec-xeventsignals">Signaux d'événements X</link> ne seront pas émis. Si vous souhaitez capturer des événements pour ces éléments graphiques, vous devez utiliser un conteneur spécial nommé <classname>Gtk::EventBox</classname> décrit au paragraphe <link linkend="sec-eventbox">EventBox</link>.</para>

<para>Voici une liste de quelques uns de ces éléments graphiques :</para>
<programlisting>Gtk::Alignment
Gtk::Arrow
Gtk::Bin
Gtk::Box
Gtk::Button
Gtk::CheckButton
Gtk::Fixed
Gtk::Image
Gtk::Item
Gtk::Label
Gtk::MenuItem
Gtk::Notebook
Gtk::Paned
Gtk::Pixmap
Gtk::RadioButton
Gtk::Range
Gtk::ScrolledWindow
Gtk::Separator
Gtk::Table
Gtk::Toolbar
Gtk::AspectFrame
Gtk::Frame
Gtk::VBox
Gtk::HBox
Gtk::VSeparator
Gtk::HSeparator</programlisting>

<para>Ces éléments graphiques sont essentiellement utilisés pour l'agencement ou la décoration ; la plupart du temps, il ne sera donc pas nécessaire de capturer d'événements sur eux. Ils n'ont pas été pourvus d'une fenêtre-X intentionnellement pour améliorer la performance.</para>

<sect1 id="sec-eventbox">
<title>EventBox</title>

<para>Certains éléments graphiques <application>gtkmm</application> n'ont pas de fenêtre-X associée ; ils sont affichés sur les fenêtres parentes. Pour cette raison, ils ne peuvent pas recevoir d'événements. Ainsi, s'ils ne sont pas correctement dimensionnés, ils ne seront pas rognés : vous observez alors des chevauchements désordonnés, etc. Pour recevoir des événements sur un de ces éléments graphiques, placez-le dans un conteneur <classname>EventBox</classname> et faites appel ensuite à <methodname>Gtk::Widget::set_events()</methodname> sur l'objet EventBox avant de l'afficher.</para>

<para>Même si le nom <classname>EventBox</classname> met en valeur l'aspect gestion des événements, cet élément graphique peut être utilisé pour la délimitation des contours (ou plus ; voir l'exemple ci-dessous).</para>
<!--
<para>TODO: Why don't they have X Windows - explain clipping.
Also, how does this affect platform such as Windows and MacOS that don't use X.
</para>
-->

<para>Le constructeur d'un objet <classname>Gtk::EventBox</classname> est :</para>

<programlisting>Gtk::EventBox();</programlisting>

<para>L'ajout d'un élément graphique enfant à un <classname>EventBox</classname> s'effectue avec :</para>

<programlisting>event_box.add(child_widget);</programlisting>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1EventBox.html">Référence</ulink></para>

<sect2 id="eventbox-example">
<title>Exemple</title>
<para>L'exemple suivant montre deux utilisations d'un <classname>EventBox</classname> — création d'une étiquette tronquée dans une petite boîte et configuration pour qu'un clic de souris sur l'étiquette fasse quitter le programme. Le redimensionnement de la fenêtre révèle plus ou moins le contenu de l'étiquette.</para>

<figure id="figure-eventbox">
  <title>EventBox</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/eventbox.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/eventbox?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

protected:
  //Signal handlers:
  virtual bool on_eventbox_button_press(GdkEventButton* event);

  //Child widgets:
  Gtk::EventBox m_EventBox;
  Gtk::Label m_Label;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"

ExampleWindow::ExampleWindow()
: m_Label("Click here to quit, quit, quit, quit, quit")
{
  set_title ("EventBox");
  set_border_width(10);

  add(m_EventBox);

  m_EventBox.add(m_Label);

  //Clip the label short:
  m_Label.set_size_request(110, 20);

  //And bind an action to it:
  m_EventBox.set_events(Gdk::BUTTON_PRESS_MASK);
  m_EventBox.signal_button_press_event().connect(
    sigc::mem_fun(*this, &amp;ExampleWindow::on_eventbox_button_press) );

  m_EventBox.set_tooltip_text("Click me!");

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

bool ExampleWindow::on_eventbox_button_press(GdkEventButton*)
{
  hide();
  return true;
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->
</sect2>

</sect1>

</chapter>

<chapter id="chapter-dialogs">
<title>Boîtes de dialogue</title>

<para>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 <classname>Gtk::Dialog</classname> contiennent des éléments graphiques pré-incorporés pour assurer une certaine cohérence ; elles disposent également d'une fonction membre <methodname>run()</methodname> bloquante jusqu'à ce que l'utilisateur ferme la boîte de dialogue.</para>

<para>Il y a plusieurs classes dérivées de <classname>Dialog</classname> ; vous les trouverez certainement utiles. <classname>Gtk::MessageDialog</classname> 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.</para>

<para>Pour empaqueter des éléments graphiques dans une boîte de dialogue personnalisée, il convient de les placer dans le <classname>Gtk::VBox</classname>, obtenu par l'intermédiaire de la fonction membre <methodname>get_vbox()</methodname>. Pour simplement ajouter un bouton au bas de l'objet <classname>Dialog</classname>, utilisez la fonction membre <methodname>add_button()</methodname>.</para>

<para>La fonction membre <methodname>run()</methodname> renvoie un entier <literal>int</literal>. C'est une valeur du type <literal>Gtk::ResponseType</literal> si l'utilisateur a fermé la fenêtre en cliquant sur un bouton standard, ou bien la valeur de réponse personnalisée définie lors de l'appel à la fonction membre <methodname>add_button()</methodname>.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Dialog.html">Référence</ulink></para>

<sect1 id="sec-dialogs-messagedialog"><title>Boîte de dialogue Message</title>
<para><classname>MessageDialog</classname> 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 <literal>Gtk::ButtonsType</literal>.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1MessageDialog.html">Référence</ulink></para>

<sect2 id="messagedialog-example">
<title>Exemple</title>

<figure id="figure-dialogs-messagedialog">
  <title>Boîte de dialogue Message</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/dialogs_messagedialog.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/dialogs/messagedialog?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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::VButtonBox m_ButtonBox;
  Gtk::Button m_Button_Info, m_Button_Question;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/messagedialog.h&gt;
#include &lt;iostream&gt;


ExampleWindow::ExampleWindow()
: m_Button_Info("Show Info MessageDialog"),
  m_Button_Question("Show Question MessageDialog")
{
  set_title("Gtk::MessageDialog example");

  add(m_ButtonBox);

  m_ButtonBox.pack_start(m_Button_Info);
  m_Button_Info.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_info_clicked) );

  m_ButtonBox.pack_start(m_Button_Question);
  m_Button_Question.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_question_clicked) );

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_button_info_clicked()
{
  Gtk::MessageDialog dialog(*this, "This is an INFO MessageDialog");
  dialog.set_secondary_text(
          "And this is the secondary text that explains things.");

  dialog.run();
}

void ExampleWindow::on_button_question_clicked()
{
  Gtk::MessageDialog dialog(*this, "This is a QUESTION MessageDialog",
          false /* use_markup */, Gtk::MESSAGE_QUESTION,
          Gtk::BUTTONS_OK_CANCEL);
  dialog.set_secondary_text(
          "And this is the secondary text that explains things.");

  int result = dialog.run();

  //Handle the response:
  switch(result)
  {
    case(Gtk::RESPONSE_OK):
    {
      std::cout &lt;&lt; "OK clicked." &lt;&lt; std::endl;
      break;
    }
    case(Gtk::RESPONSE_CANCEL):
    {
      std::cout &lt;&lt; "Cancel clicked." &lt;&lt; std::endl;
      break;
    }
    default:
    {
      std::cout &lt;&lt; "Unexpected button clicked." &lt;&lt; std::endl;
      break;
    }
  }
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->
</sect2>

</sect1>

<sect1 id="sec-dialogs-filechooserdialog"><title>Boîte de dialogue Sélection de fichier</title>
<para>La boîte de dialogue de la classe <classname>FileChooserDialog</classname> convient pour une utilisation avec les éléments de menu « Ouvrir » ou « Enregistrer ».</para>
<para>La plupart des fonctions membres utiles de cette classe sont en fait dans la classe de base <classname>Gtk::FileChooser</classname>.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1FileChooserDialog.html">Référence</ulink></para>

<sect2 id="filechooserdialog-example">
<title>Exemple</title>

<figure id="figure-dialogs-filechooser">
  <title>Boîte de dialogue Sélection de fichier</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/dialogs_filechooser.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/dialogs/filechooserdialog?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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::VButtonBox m_ButtonBox;
  Gtk::Button m_Button_File, m_Button_Folder;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;iostream&gt;


ExampleWindow::ExampleWindow()
: m_Button_File("Choose File"),
  m_Button_Folder("Choose Folder")
{
  set_title("Gtk::FileSelection example");

  add(m_ButtonBox);

  m_ButtonBox.pack_start(m_Button_File);
  m_Button_File.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_file_clicked) );

  m_ButtonBox.pack_start(m_Button_Folder);
  m_Button_Folder.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_folder_clicked) );

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_button_folder_clicked()
{
  Gtk::FileChooserDialog dialog("Please choose a folder",
          Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
  dialog.set_transient_for(*this);

  //Add response buttons the the dialog:
  dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
  dialog.add_button("Select", Gtk::RESPONSE_OK);

  int result = dialog.run();

  //Handle the response:
  switch(result)
  {
    case(Gtk::RESPONSE_OK):
    {
      std::cout &lt;&lt; "Select clicked." &lt;&lt; std::endl;
      std::cout &lt;&lt; "Folder selected: " &lt;&lt; dialog.get_filename()
          &lt;&lt; std::endl;
      break;
    }
    case(Gtk::RESPONSE_CANCEL):
    {
      std::cout &lt;&lt; "Cancel clicked." &lt;&lt; std::endl;
      break;
    }
    default:
    {
      std::cout &lt;&lt; "Unexpected button clicked." &lt;&lt; std::endl;
      break;
    }
  }
}

void ExampleWindow::on_button_file_clicked()
{
  Gtk::FileChooserDialog dialog("Please choose a file",
          Gtk::FILE_CHOOSER_ACTION_OPEN);
  dialog.set_transient_for(*this);

  //Add response buttons the the dialog:
  dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
  dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);

  //Add filters, so that only certain file types can be selected:

  Glib::RefPtr&lt;Gtk::FileFilter&gt; filter_text = Gtk::FileFilter::create();
  filter_text-&gt;set_name("Text files");
  filter_text-&gt;add_mime_type("text/plain");
  dialog.add_filter(filter_text);

  Glib::RefPtr&lt;Gtk::FileFilter&gt; filter_cpp = Gtk::FileFilter::create();
  filter_cpp-&gt;set_name("C/C++ files");
  filter_cpp-&gt;add_mime_type("text/x-c");
  filter_cpp-&gt;add_mime_type("text/x-c++");
  filter_cpp-&gt;add_mime_type("text/x-c-header");
  dialog.add_filter(filter_cpp);

  Glib::RefPtr&lt;Gtk::FileFilter&gt; filter_any = Gtk::FileFilter::create();
  filter_any-&gt;set_name("Any files");
  filter_any-&gt;add_pattern("*");
  dialog.add_filter(filter_any);

  //Show the dialog and wait for a user response:
  int result = dialog.run();

  //Handle the response:
  switch(result)
  {
    case(Gtk::RESPONSE_OK):
    {
      std::cout &lt;&lt; "Open clicked." &lt;&lt; std::endl;

      //Notice that this is a std::string, not a Glib::ustring.
      std::string filename = dialog.get_filename();
      std::cout &lt;&lt; "File selected: " &lt;&lt;  filename &lt;&lt; std::endl;
      break;
    }
    case(Gtk::RESPONSE_CANCEL):
    {
      std::cout &lt;&lt; "Cancel clicked." &lt;&lt; std::endl;
      break;
    }
    default:
    {
      std::cout &lt;&lt; "Unexpected button clicked." &lt;&lt; std::endl;
      break;
    }
  }
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->
</sect2>
</sect1>

<sect1 id="sec-color-selection-dialog"><title>Boîte de dialogue Sélection de couleur</title>
<para>La boîte de dialogue <classname>ColorSelectionDialog</classname> permet à l'utilisateur de choisir une couleur.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1ColorSelectionDialog.html">Référence</ulink></para>

<sect2 id="colorselectiondialog-example">
<title>Exemple</title>

<figure id="figure-dialogs-colorselectiondialog">
  <title>Boîte de dialogue Sélection de couleur</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/dialogs_colorselectiondialog.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/dialogs/colorselectiondialog?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

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

  //Child widgets:
  Gtk::VBox m_VBox;
  Gtk::ColorButton m_Button;
  Gtk::DrawingArea m_DrawingArea; //To show the color.

  Gdk::RGBA m_Color;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;iostream&gt;


ExampleWindow::ExampleWindow()
{
  set_title("Gtk::ColorButton example");
  set_default_size(200, 200);

  add(m_VBox);

  m_VBox.pack_start(m_Button, Gtk::PACK_SHRINK);
  m_Button.signal_color_set().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_color_set) );

  //Set start color:
  m_Color.set_red(0);
  m_Color.set_blue(1);
  m_Color.set_green(0);
  m_Button.set_rgba(m_Color);

  m_DrawingArea.override_background_color(m_Color);

  m_VBox.pack_start(m_DrawingArea);

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_button_color_set()
{
  //Store the chosen color, and show it:
  m_Color = m_Button.get_rgba();
  m_DrawingArea.override_background_color(m_Color);
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->
</sect2>

</sect1>

<sect1 id="sec-font-selection-dialog"><title>Boîte de dialogue Sélection de police</title>
<para>La boîte de dialogue <classname>FontSelectionDialog</classname> permet à l'utilisateur de choisir une police de caractères.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1FontSelectionDialog.html">Référence</ulink></para>

<sect2 id="fontselectiondialog-example">
<title>Exemple</title>

<figure id="figure-dialogs-fontselectiondialog">
  <title>Boîte de dialogue Sélection de police</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/dialogs_fontselectiondialog.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/dialogs/fontselectiondialog?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

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

  //Child widgets:
  Gtk::FontButton m_Button;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;iostream&gt;


ExampleWindow::ExampleWindow()
: m_Button("sans")
{
  set_title("Gtk::FontSelectionDialog example");

  add(m_Button);
  m_Button.signal_font_set().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_font_set) );

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_button_font_set()
{
  Glib::ustring font_name = m_Button.get_font_name();
  std::cout &lt;&lt; "Font chosen: " &lt;&lt; font_name &lt;&lt; std::endl;
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->
</sect2>

</sect1>


</chapter>

<chapter id="chapter-drawingarea">
  <title>L'élément graphique zone de dessin</title>
  <para>L'élément graphique <classname>DrawingArea</classname> est une fenêtre vierge qui vous offre la possibilité de créer librement tous les graphiques voulus. Mais, en contrepartie de cette liberté, il vous incombe la responsabilité de gérer les événements d'exposition sur l'élément graphique. Quand un élément graphique est affiché pour la première fois ou quand il est couvert puis découvert, il est nécessaire de le tracer. La plupart des éléments graphiques sont pourvus de code pour effectuer ces opérations, mais l'élément graphique DrawingArea n'en dispose pas ; il vous laisse le soin d'écrire votre propre gestionnaire des signaux d'événements d'exposition pour définir la façon dont le contenu du widget sera tracé. C'est effectué le plus souvent en surdéfinissant la fonction membre virtuelle <methodname>on_expose_event()</methodname>.</para>

  <para>GTK+ utilise l'API de dessin <ulink url="http://cairographics.org">Cairo</ulink>. Avec gtkmm, vous pouvez faire usage de l'API C++ pour cairo nommée <ulink url="http://www.cairographics.org/cairomm/">cairomm</ulink>.</para>

  <para>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.</para>
  <note>
      <title>Cairo et Pango</title>
      <para>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.</para>
  </note>
  <para>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.</para>
  <sect1 id="sec-cairo-drawing-model">
    <title>Le modèle de tracé Cairo</title>
    <para>Le concept de base du tracé dans Cairo consiste à définir des chemins « invisibles », puis à les tracer ou les remplir pour les rendre visibles.</para>
    <para>Pour effectuer un tracé dans <application>gtkmm</application> avec Cairo, vous devez au préalable créer un objet <classname>Cairo::Context</classname>. Cette classe contient tous les paramètres d'état graphiques décrivant comment le tracé doit être fait. Ces informations comprennent entre autres l'épaisseur du trait, la couleur, le contour à tracer et de nombreuses autres choses. Cela permet aux fonctions effectives de tracé de ne comporter qu'un minimum de paramètres pour simplifier l'interface. Dans <application>gtkmm</application>, un <classname>Cairo::Context</classname> est créé en appelant la fonction <methodname>Gdk::Window::create_cairo_context()</methodname>. Étant donné que les contextes Cairo sont des objets à décompte de référencement, cette fonction renvoie un objet <classname>Cairo::RefPtr&lt;Cairo::Context&gt;</classname>.</para>
    <para>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.</para>
    <programlisting>Gtk::DrawingArea myArea;
Cairo::RefPtr&lt;Cairo::Context&gt; myContext = myArea.get_window()-&gt;create_cairo_context();
myContext-&gt;set_source_rgb(1.0, 0.0, 0.0);
myContext-&gt;set_line_width(2.0);</programlisting>
    <para>Chaque <classname>Cairo::Context</classname> est associé à une fenêtre <classname>Gdk::Window</classname> donnée ; ainsi, la première ligne de l'exemple ci-dessus crée un élément graphique <classname>Gtk::DrawingArea</classname> et la deuxième ligne utilise son objet <classname>Gdk::Window</classname> associé pour créer un objet <classname>Cairo::Context</classname>. Les deux dernières lignes modifient les caractéristiques graphiques du contexte.</para>
    <para>De nombreuses variables d'état graphique peuvent être définies pour un contexte Cairo. Les attributs les plus courants sont la couleur (avec <methodname>set_source_rgb()</methodname> ou <methodname>set_source_rgba()</methodname> pour des couleurs transparentes), l'épaisseur du trait (avec <methodname>set_line_width()</methodname>), le type de pointillé (avec <methodname>set_dash()</methodname>), les bouts de lignes (avec <methodname>set_line_cap()</methodname>), les jonctions de lignes (avec <methodname>set_line_join()</methodname>) et les styles de polices de caractères (avec <methodname>set_font_size()</methodname>, <methodname>set_font_face()</methodname> 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 <ulink url="http://www.cairographics.org/cairomm/">cairomm</ulink>.</para>
    <para>L'état présent d'un <classname>Cairo::Context</classname> peut être enregistré dans une pile interne de contextes enregistrés et ultérieurement rétablis dans leur état antérieur. Pour réaliser cette opération, utilisez les fonctions membres <methodname>save()</methodname> et <methodname>restore()</methodname>. Ce processus est utile si vous avez besoin de modifier temporairement l'épaisseur de trait ou la couleur (ou toute autre caractéristique graphique) pour tracer un élément puis revenir aux réglages antérieurs. Dans ce cas, appelez <methodname>Cairo::Context::save()</methodname>, modifiez les caractéristiques graphiques, effectuez le tracé, puis appelez <methodname>Cairo::Context::restore()</methodname> pour rétablir l'état graphique initial. Des appels multiples à <methodname>save()</methodname> et <methodname>restore()</methodname> peuvent être imbriqués ; chaque appel à <methodname>restore()</methodname> rétablit l'état correspondant à celui qui prévalait lors de l'appel de <methodname>save()</methodname>. <tip>
            <para>Il est de bonne pratique de placer toute modification de l'état graphique entre des appels aux fonctions <methodname>save()</methodname>/<methodname>restore()</methodname>. Par exemple, si vous avez une fonction qui prend en paramètre une référence à un <classname>Cairo::Context</classname>, vous pouvez l'implémenter comme suit :</para>
          <programlisting>void doSomething(Cairo::RefPtr&lt;Cairo::Context&gt; context, int x)
{
    context-&gt;save();
    // modifier l'état graphique
    // réaliser les opérations de tracé
    context-&gt;restore();
}</programlisting>
        </tip></para>
  </sect1>
  <sect1 id="sec-cairo-drawing-lines">
    <title>Tracé de droites</title>
    <para>Maintenant que nous connaissons les bases de la bibliothèque graphique Cairo, nous voilà prêts pour débuter un tracé. Commençons par le plus simple des éléments de tracé : la droite. Mais d'abord, il est nécessaire d'en savoir un peu plus sur le système de coordonnées de Cairo. L'origine du système de coordonnées de Cairo se situe dans l'angle supérieur gauche de la fenêtre avec les valeurs positives de x vers la droite et de y vers le bas. <tip>
            <para>Étant donné que la bibliothèque graphique Cairo a été écrite pour prendre en charge de multiples cibles en sortie (le système de fenêtrage X, les images PNG, Open GL, etc.), une distinction est faite entre les coordonnées dans l'espace-utilisateur et les coordonnées dans l'espace du périphérique d'affichage. La correspondance entre ces deux systèmes de coordonnées est par défaut de un pour un, de sorte que les valeurs entières du premier système correspondent grosso modo à des pixels à l'écran, mais ce réglage peut être modifié si vous le souhaitez. Quelquefois il peut être commode d'échelonner les coordonnées de sorte que la largeur et la hauteur totale d'une fenêtre se situent tous deux dans la plage de 0 à 1 (carré « unité »), ou tout autre correspondance qui fonctionnerait bien pour votre application. Ces modifications d'échelle sont effectuées à l'aide de la fonction <methodname>Cairo::Context::scale()</methodname>.</para>
        </tip></para>

    <sect2 id="cairo-example-lines"><title>Exemple</title>
    <para>Dans cet exemple, nous allons écrire un programme <application>gtkmm</application> 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 <methodname>Cairo::Context::move_to()</methodname> et <methodname>Cairo::Context::line_to()</methodname>. La fonction <methodname>move_to()</methodname> 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 <methodname>line_to()</methodname>.</para>
    <para>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 <methodname>stroke()</methodname> qui dessine le tracé actuel avec une ligne d'épaisseur et de style précisés dans l'objet <classname>Cairo::Context</classname>. Après le traçage, le chemin actuel est effacé ; vous pouvez donc en débuter un nouveau.</para>
        <tip>
            <para>Beaucoup de fonctions de dessin de Cairo disposent d'une variante <methodname>_preserve()</methodname>. Normalement, les fonctions de dessin telles que <methodname>clip()</methodname>, <methodname>fill()</methodname> ou <methodname>stroke()</methodname> effacent le chemin actuel. Si vous utilisez la variante <methodname>_preserve()</methodname>, le chemin actuel sera préservé de sorte que vous pouvez à nouveau l'utiliser avec une autre fonction de dessin.</para>
        </tip>

    <figure id="figure-drawingarea-lines">
      <title>Zone de dessin ‑ Lignes</title>
      <screenshot>
        <graphic format="PNG" fileref="figures/drawingarea_lines.png"/>
      </screenshot>
    </figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/drawingarea/simple?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>myarea.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_MYAREA_H
#define GTKMM_EXAMPLE_MYAREA_H

#include &lt;gtkmm/drawingarea.h&gt;

class MyArea : public Gtk::DrawingArea
{
public:
  MyArea();
  virtual ~MyArea();

protected:
  //Override default signal handler:
  virtual bool on_draw(const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr);
};

#endif // GTKMM_EXAMPLE_MYAREA_H
</programlisting>
<para>File: <filename>myarea.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "myarea.h"
#include &lt;cairomm/context.h&gt;

MyArea::MyArea()
{
}

MyArea::~MyArea()
{
}

bool MyArea::on_draw(const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr)
{
  Gtk::Allocation allocation = get_allocation();
  const int width = allocation.get_width();
  const int height = allocation.get_height();

  // coordinates for the center of the window
  int xc, yc;
  xc = width / 2;
  yc = height / 2;

  cr-&gt;set_line_width(10.0);

  // draw red lines out from the center of the window
  cr-&gt;set_source_rgb(0.8, 0.0, 0.0);
  cr-&gt;move_to(0, 0);
  cr-&gt;line_to(xc, yc);
  cr-&gt;line_to(0, height);
  cr-&gt;move_to(xc, yc);
  cr-&gt;line_to(width, yc);
  cr-&gt;stroke();

  return true;
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "myarea.h"
#include &lt;gtkmm/main.h&gt;
#include &lt;gtkmm/window.h&gt;

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

   Gtk::Window win;
   win.set_title("DrawingArea");

   MyArea area;
   win.add(area);
   area.show();

   Gtk::Main::run(win);

   return 0;
}
</programlisting>
<!-- end inserted example code -->

    <para>Ce programme ne comporte qu'une seule classe, <classname>MyArea</classname>, sous-classe de <classname>Gtk::DrawingArea</classname> avec une fonction membre <methodname>on_expose_event()</methodname>. Cette fonction membre est appelée chaque fois que l'image dans la zone de tracé a besoin d'être retracée. À cette fonction est passé un pointeur sur une structure <classname>GdkEventExpose</classname> définissant la zone ayant besoin d'être redessinée. Nous utilisons ces valeurs pour créer un chemin de rectangle dans Cairo (avec la fonction <methodname>rectangle()</methodname>) puis découper ce chemin avec <methodname>clip()</methodname>. La fonction <methodname>clip()</methodname> définit une zone de découpe. Cette zone affecte toutes les opérations de tracé en occultant effectivement toute modification sur la surface extérieure à la découpe. Cela nous permet de limiter le retraçage à la zone qui le nécessite. Le code de tracé définit la couleur que nous voulons en fait utiliser avec <methodname>set_source_rgb()</methodname> dont les paramètres définissent les composantes rouge, verte et bleue de la couleur voulue (les valeurs correctes sont comprises entre 0 et 1). Après avoir précisé la couleur, nous créons un nouveau chemin avec les fonctions <methodname>move_to()</methodname> et <methodname>line_to()</methodname> et nous le traçons avec <methodname>stroke()</methodname>.</para>
    <tip>
        <title>Tracé en coordonnées relatives</title>
        <para>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 <methodname>Cairo::Context::rel_line_to()</methodname>.</para>
    </tip>
    </sect2>
    <sect2 id="cairo-line-styles">
        <title>Styles de trait</title>
        <para>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.</para>
        <para>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 :</para>
        <figure id="figure-cairo-joins">
            <title>Différents types de raccord dans Cairo</title>
            <screenshot>
                <graphic format="PNG" fileref="figures/cairo_joins.png"/>
            </screenshot>
        </figure>
        <para>Le type de raccord est défini avec la fonction <methodname>Cairo::Context::set_line_join()</methodname>.</para>
        <para>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 <methodname>Cairo::Context::set_line_cap()</methodname>.</para>
        <para>Vous pouvez encore personnaliser d'autres paramètres, y compris la création de pointillés entre autres. Pour plus d'informations, consultez la documentation de l'API Cairo. </para>
    </sect2>
</sect1>
    <sect1 id="sec-cairo-curved-lines">
        <title>Tracé de courbes</title>
        <para>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 <methodname>Cairo::Context::curve_to()</methodname> et <methodname>Cairo::Context::rel_curve_to()</methodname>. 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.</para>
        <sect2 id="cairo-example-curves">
            <title>Exemple</title>
            <para>Cette simple application trace une courbe avec Cairo et affiche les points de contrôle pour chaque extrémité de la courbe.</para>
        <figure id="figure-drawingarea-curve">
            <title>Zone de dessin ‑ Lignes</title>
            <screenshot>
                <graphic format="PNG" fileref="figures/drawingarea_curve.png"/>
            </screenshot>
        </figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/drawingarea/curve?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>myarea.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_MYAREA_H
#define GTKMM_EXAMPLE_MYAREA_H

#include &lt;gtkmm/drawingarea.h&gt;

class MyArea : public Gtk::DrawingArea
{
public:
  MyArea();
  virtual ~MyArea();

protected:
  //Override default signal handler:
  virtual bool on_draw(const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr);
};

#endif // GTKMM_EXAMPLE_MYAREA_H
</programlisting>
<para>File: <filename>myarea.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "myarea.h"
#include &lt;cairomm/context.h&gt;

MyArea::MyArea()
{
}

MyArea::~MyArea()
{
}

bool MyArea::on_draw(const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr)
{
  Gtk::Allocation allocation = get_allocation();
  const int width = allocation.get_width();
  const int height = allocation.get_height();

  double x0=0.1, y0=0.5, // start point
         x1=0.4, y1=0.9,  // control point #1
         x2=0.6, y2=0.1,  // control point #2
         x3=0.9, y3=0.5;  // end point

  // clip to the area indicated by the expose event so that we only redraw
  // the portion of the window that needs to be redrawn
  cr-&gt;rectangle(0, 0, width, height);
  cr-&gt;clip();

  // scale to unit square (0 to 1 with and height)
  cr-&gt;scale(width, height);

  cr-&gt;set_line_width(0.05);
  // draw curve
  cr-&gt;move_to(x0, y0);
  cr-&gt;curve_to(x1, y1, x2, y2, x3, y3);
  cr-&gt;stroke();
  // show control points
  cr-&gt;set_source_rgba(1, 0.2, 0.2, 0.6);
  cr-&gt;move_to(x0, y0);
  cr-&gt;line_to (x1, y1);
  cr-&gt;move_to(x2, y2);
  cr-&gt;line_to (x3, y3);
  cr-&gt;stroke();

  return true;
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "myarea.h"
#include &lt;gtkmm/main.h&gt;
#include &lt;gtkmm/window.h&gt;

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

   Gtk::Window win;
   win.set_title("DrawingArea");

   MyArea area;
   win.add(area);
   area.show();

   Gtk::Main::run(win);

   return 0;
}
</programlisting>
<!-- end inserted example code -->
        <para>La seule différence entre cet exemple et l'exemple des droites réside dans la fonction <methodname>on_expose_event()</methodname>, mais quelques nouveaux concepts et fonctions sont introduits ici ; examinons-les brièvement.</para>
        <para>Notez que nous découpons la surface nécessitant d'être redessinée exactement comme nous l'avions fait dans l'exemple précédent. Après découpe, toutefois, nous faisons appel à <methodname>Cairo::Context::scale()</methodname> en passant à cette fonction la largeur et la hauteur de cette surface de tracé. Le système de coordonnées de l'espace utilisateur est ainsi gradué de telle sorte que la hauteur et la largeur du élément graphique ont tous deux une mesure de 1,0 « unité ». Il n'y avait pas de raison particulière de modifier la graduation du système de coordonnées dans notre cas, mais cela peut quelquefois faciliter les opérations de tracé.</para>
        <para>L'appel à <methodname>Cairo::Context::curve_to()</methodname> est vraiment explicite en soi. Le premier couple de coordonnées définit le point de contrôle au début de la courbe, le deuxième celui à la fin de la courbe. Le dernier groupe de coordonnées indique les extrémités de la courbe. Pour faire en sorte que le concept des points de contrôle soit plus facile à visualiser, nous avons tracé une droite entre extrémité de la courbe et point de contrôle associé. Notez que ces droites (tangentes aux extrémités de la courbe) sont translucides. Ceci est réalisé à l'aide d'une variante de <methodname>set_source_rgb()</methodname> intitulée <methodname>set_source_rgba()</methodname>. Cette fonction prend un quatrième argument indiquant le coefficient alpha de la couleur (les valeurs correctes s'échelonnent entre 0 et 1).</para>
        </sect2>
  </sect1>
  <sect1 id="sec-cairo-drawing-arcs">
      <title>Tracé des arcs et des cercles</title>
      <para>Avec Cairo, on utilise la même fonction pour tracer des arcs, des cercles ou des ellipses : <methodname>Cairo::Context::arc()</methodname>. Cette fonction prend cinq paramètres. Les deux premiers sont les coordonnées du centre de l'arc, le troisième est le rayon et les deux derniers définissent l'angle de début et l'angle de fin de l'arc. Tous les angles sont définis en radians ; ainsi, tracer un cercle est identique au fait de tracer un arc de 0 à 2π radians. L'angle 0 est dans le sens positif des X (dans l'espace utilisateur). L'angle de π/2 radians (90 degrés) est dans le sens positif des Y (dans l'espace utilisateur). Les angles vont croissant en allant de l'axe des X vers l'axe des Y. Ainsi, avec la matrice de transformation par défaut, les angles croissent en tournant dans le sens des aiguilles d'une montre.</para>
      <para>Pour tracer une ellipse, vous graduez la matrice de transformation de façon différente dans le sens des X et dans le sens des Y. Par exemple, pour tracer une ellipse dans la boîte définie par <varname>x</varname>, <varname>y</varname>, <varname>width</varname>, <varname>height</varname> : <programlisting>context-&gt;save();
context-&gt;translate(x, y);
context-&gt;scale(width / 2.0, height / 2.0);
context-&gt;arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI);
context-&gt;restore();</programlisting> Notez que ceci est en contradiction avec la <ulink url="http://www.cairographics.org/manual/cairo-Paths.html#cairo-arc"> directive de la documentation officielle Cairo</ulink>, mais cela semble fonctionner correctement.</para>
      <sect2 id="cairo-example-arcs">
          <title>Exemple</title>
          <para>Voici un exemple de programme simple traçant un arc, un cercle et une ellipse sur une zone de dessin.</para>
          <figure id="figure-drawingarea-arc">
              <title>Zone de dessin ‑ Arcs</title>
              <screenshot>
                  <graphic format="PNG" fileref="figures/drawingarea_arcs.png"/>
              </screenshot>
          </figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/drawingarea/arcs?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>myarea.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_MYAREA_H
#define GTKMM_EXAMPLE_MYAREA_H

#include &lt;gtkmm/drawingarea.h&gt;

class MyArea : public Gtk::DrawingArea
{
public:
  MyArea();
  virtual ~MyArea();

protected:
  //Override default signal handler:
  virtual bool on_draw(const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr);
};

#endif // GTKMM_EXAMPLE_MYAREA_H
</programlisting>
<para>File: <filename>myarea.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "myarea.h"
#include &lt;cairomm/context.h&gt;
#include &lt;cmath&gt;

MyArea::MyArea()
{
}

MyArea::~MyArea()
{
}

bool MyArea::on_draw(const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr)
{
  // This is where we draw on the window
  Gtk::Allocation allocation = get_allocation();
  const int width = allocation.get_width();
  const int height = allocation.get_height();
  const int lesser = MIN(width, height);

  // coordinates for the center of the window
  int xc, yc;
  xc = width / 2;
  yc = height / 2;

  cr-&gt;set_line_width(lesser * 0.02);  // outline thickness changes
                                      // with window size

  // first draw a simple unclosed arc
  cr-&gt;save();
  cr-&gt;arc(width / 3.0, height / 4.0, lesser / 4.0, -(M_PI / 5.0), M_PI);
  cr-&gt;close_path();   // line back to start point
  cr-&gt;set_source_rgb(0.0, 0.8, 0.0);
  cr-&gt;fill_preserve();
  cr-&gt;restore();  // back to opaque black
  cr-&gt;stroke();   // outline it

  // now draw a circle
  cr-&gt;save();
  cr-&gt;arc(xc, yc, lesser / 4.0, 0.0, 2.0 * M_PI); // full circle
  cr-&gt;set_source_rgba(0.0, 0.0, 0.8, 0.6);    // partially translucent
  cr-&gt;fill_preserve();
  cr-&gt;restore();  // back to opaque black
  cr-&gt;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-&gt;save();

  cr-&gt;translate(ex, ey);  // make (ex, ey) == (0, 0)
  cr-&gt;scale(ew / 2.0, eh / 2.0);  // for width: ew / 2.0 == 1.0
                                  // for height: eh / 2.0 == 1.0

  cr-&gt;arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI);  // 'circle' centered at (0, 0)
                                          // with 'radius' of 1.0

  cr-&gt;set_source_rgba(0.8, 0.0, 0.0, 0.7);
  cr-&gt;fill_preserve();
  cr-&gt;restore();  // back to opaque black
  cr-&gt;stroke();

  return true;
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "myarea.h"
#include &lt;gtkmm/main.h&gt;
#include &lt;gtkmm/window.h&gt;

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

   Gtk::Window win;
   win.set_title("DrawingArea");

   MyArea area;
   win.add(area);
   area.show();

   Gtk::Main::run(win);

   return 0;
}
</programlisting>
<!-- end inserted example code -->

          <para>Il y a deux choses à noter concernant cet exemple de code. À nouveau, la seule différence entre cet exemple et les précédents se situe dans la fonction <methodname>on_expose_event()</methodname> ; nous limitons donc nos remarques à cette fonction. En outre, la première partie de la fonction est pratiquement identique aux exemples précédents, nous ne la commentons donc pas.</para>
          <para>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 <methodname>save()</methodname>/<methodname>restore()</methodname> pour revenir à un état bien défini après chaque tracé.</para>
          <para>La partie concernant le tracé de l'arc comporte une nouvelle fonction : <methodname>close_path()</methodname>. 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 <methodname>close_path()</methodname> et le tracé à la main d'une ligne jusqu'au point de départ. Si vous utilisez <methodname>close_path()</methodname>, les lignes seront proprement jointes. Si vous utilisez <methodname>line_to()</methodname> à la place, les lignes se rejoindront, mais Cairo ne fera rien de spécial pour les joindre.</para>
          <note>
              <title>Tracé en sens inverse des aiguilles d'une montre</title>
              <para>La fonction <methodname>Cairo::Context::arc_negative()</methodname> est identique à <methodname>Cairo::Context::arc()</methodname> mais les angles tournent dans le sens opposé.</para>
          </note>

      </sect2>
  </sect1>
  <sect1 id="sec-drawing-text">
      <title>Tracé de textes</title>
      <sect2 id="drawing-text-pango">
          <title>Tracé de texte avec Pango</title>
          <para>Le texte est tracé par l'intermédiaire des objets « layout » tracé de Pango. Le moyen le plus facile pour créer un objet <classname>Pango::Layout</classname> est d'utiliser <methodname>create_pango_layout</methodname>. Une fois créé, le tracé peut être manipulée de diverses manières en modifiant le texte, les polices, etc. Finalement, le tracé est affiché à l'aide de la fonction membre <methodname>draw_layout</methodname> de la classe <classname>Gdk::Drawable</classname> ; il prend comme paramètres un objet <classname>Gdk::GC</classname>, une position x, une position y et un pointeur sur le tracé lui-même.</para>
      </sect2>

      <!--
      <sect2 id="drawing-text-cairo">
          <title>Drawing Text with Cairo</title>
          <warning>TODO: Add Cairo content.</warning>
      </sect2>
      -->
  </sect1>
  <sect1 id="sec-draw-images">
      <title>Affichage d'images</title>
      <sect2 id="drawing-images-gdk">
          <title>Affichage d'images avec Gdk</title>
          <para>Il y a deux ou trois fonctions membres de tracé pour positionner les données d'une image dans une zone de dessin. <methodname>draw_pixmap()</methodname> peut copier dans une zone de dessin le contenu d'un objet <classname>Gdk::Drawable</classname> (la fenêtre d'une zone de dessin fait partie de cette classe). <methodname>draw_bitmap()</methodname> permet d'afficher une image bicolore dans une zone de tracé ; utilisez <methodname>draw_image()</methodname> si l'image comporte plus de deux couleurs.</para>
          <para>Pour chacune de ces fonctions membres, le premier paramètre est le <classname>Gdk::GC</classname>. Le second est l'objet de type approprié à copier : <classname>Gdk::Drawable</classname>, <classname>Gdk::Bitmap</classname> ou <classname>Gdk::Image</classname>. Les deux paramètres suivants sont les coordonnées x et y du point de départ de la copie dans l'image à copier , puis les coordonnées x et y du point de destination de la copie dans la zone de dessin et enfin la largeur et la hauteur de la région à copier.</para>
          <para>Il y a également une fonction membre pour dessiner à partir d'un objet <classname>Gdk::Pixbuf</classname>. Un tampon <classname>Gdk::Pixbuf</classname> est une enveloppe commode pour un ensemble de pixels. Il peut être lu à partir d'un fichier et manipulé de diverses manières.</para>
          <para>La façon la plus courante pour créer un objet <classname>Gdk::Pixbuf</classname> est d'utiliser la fonction <methodname>Gdk::Pixbuf::create_from_file()</methodname>. Elle peut lire un fichier d'image, comme un fichier .png dans un tampon <classname>Gdk::Pixbuf</classname> prêt à être rendu.</para>
          <para>L'objet <classname>Gdk::Pixbuf</classname> peut être rendu à l'aide de la fonction membre <methodname>render_to_drawable</methodname> ; elle prend peu de paramètres. Cette fonction est une fonction membre de la classe <classname>Gdk::Pixbuf</classname> (et non <classname>Gdk::Drawable</classname>) ; elle diffère des fonctions <methodname>draw_*</methodname> décrites plus haut. Ainsi, son premier paramètre est l'objet à tracer. Le deuxième est encore le contexte <classname>Gdk::GC</classname>. Les deux paramètres suivants définissent le point de départ dans l'image à copier, suivis par le point de destination dans la zone de tracé ainsi que par la largeur et la hauteur à tracer effectivement (ce n'est pas forcément la totalité de l'image, spécialement si vous répondez à un événement d'exposition d'une partie de la fenêtre). Pour terminer, il y a les paramètres de diffusion de l'image. Si vous prenez comme type de diffusion Gdk::RGB_DITHER_NONE, les paramètres de décalage de diffusion seront tous deux égaux à 0.</para>
          <para>Voici un petit bout de code pour lier l'ensemble : (notez qu'habituellement, vous ne procédez pas au chargement de l'image à chaque fois dans le gestionnaire de l'événement d'exposition ! Ici, c'est uniquement pour que le code soit complet)</para>
          <programlisting>bool myarea::on_expose_event(GdkEventExpose* ev)
{
Glib::RefPtr&lt;Gdk::Pixbuf&gt; image = Gdk::Pixbuf::create_from_file("myimage.png");
image-&gt;render_to_drawable(get_window(), get_style()-&gt;get_black_gc(),
0, 0, 100, 80, image-&gt;get_width(), image-&gt;get_height(),
// tracer la totalité de l'image (de 0,0 à toute la largeur,hauteur) à 100,80
// dans la fenêtre
Gdk::RGB_DITHER_NONE, 0, 0);
return true;
}</programlisting>
      </sect2>
      <!--
      <sect2 id="drawing-images-cairo">
          <title>Drawing images with Cairo</title>
          <warning>TODO: Add Cairo content.</warning>
      </sect2>
      -->
  </sect1>
  <!--
  <sect1 id="sec-drawing-fill">
      <title>Gradients and other fill techniques</title>
      <warning>TODO: Add content.</warning>
  </sect1>
  <sect1 id="sec-drawing-transformations">
      <title>Transformations with Cairo</title>
      <warning>TODO: Add content.</warning>
  </sect1>
  -->
  <sect1 id="sec-drawing-clock-example">
      <title>Exemple d'application : création d'un cadran d'horloge avec Cairo</title>
      <para>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 <classname>Clock</classname> classique. L'horloge dispose d'aiguilles pour les secondes, les minutes et les heures ; elle se met à jour toutes les secondes.</para>
      <screenshot>
          <graphic format="PNG" fileref="figures/cairo_clock.png"/>
      </screenshot>
<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/drawingarea/clock?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>clock.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_CLOCK_H
#define GTKMM_EXAMPLE_CLOCK_H

#include &lt;gtkmm/drawingarea.h&gt;

class Clock : public Gtk::DrawingArea
{
public:
  Clock();
  virtual ~Clock();

protected:
  //Override default signal handler:
  virtual bool on_draw(const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr);

  bool on_timeout();

  double m_radius;
  double m_line_width;

};

#endif // GTKMM_EXAMPLE_CLOCK_H
</programlisting>
<para>File: <filename>clock.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;ctime&gt;
#include &lt;cmath&gt;
#include &lt;cairomm/context.h&gt;
#include "clock.h"

Clock::Clock()
: m_radius(0.42), m_line_width(0.05)
{
  Glib::signal_timeout().connect( sigc::mem_fun(*this, &amp;Clock::on_timeout), 1000 );

  #ifndef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  //Connect the signal handler if it isn't already a virtual method override:
  signal_draw().connect(sigc::mem_fun(*this, &amp;Clock::on_draw), false);
  #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
}

Clock::~Clock()
{
}

bool Clock::on_draw(const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr)
{
  Gtk::Allocation allocation = get_allocation();
  const int width = allocation.get_width();
  const int height = allocation.get_height();

  // scale to unit square and translate (0, 0) to be (0.5, 0.5), i.e.
  // the center of the window
  cr-&gt;scale(width, height);
  cr-&gt;translate(0.5, 0.5);
  cr-&gt;set_line_width(m_line_width);

  cr-&gt;save();
  cr-&gt;set_source_rgba(0.337, 0.612, 0.117, 0.9);   // green
  cr-&gt;paint();
  cr-&gt;restore();
  cr-&gt;arc(0, 0, m_radius, 0, 2 * M_PI);
  cr-&gt;save();
  cr-&gt;set_source_rgba(1.0, 1.0, 1.0, 0.8);
  cr-&gt;fill_preserve();
  cr-&gt;restore();
  cr-&gt;stroke_preserve();
  cr-&gt;clip();

  //clock ticks
  for (int i = 0; i &lt; 12; i++)
  {
    double inset = 0.05;

    cr-&gt;save();
    cr-&gt;set_line_cap(Cairo::LINE_CAP_ROUND);

    if(i % 3 != 0)
    {
      inset *= 0.8;
      cr-&gt;set_line_width(0.03);
    }

    cr-&gt;move_to(
      (m_radius - inset) * cos (i * M_PI / 6),
      (m_radius - inset) * sin (i * M_PI / 6));
    cr-&gt;line_to (
      m_radius * cos (i * M_PI / 6),
      m_radius * sin (i * M_PI / 6));
    cr-&gt;stroke();
    cr-&gt;restore(); /* stack-pen-size */
  }

  // store the current time
  time_t rawtime;
  time(&amp;rawtime);
  struct tm * timeinfo = localtime (&amp;rawtime);

  // compute the angles of the indicators of our clock
  double minutes = timeinfo-&gt;tm_min * M_PI / 30;
  double hours = timeinfo-&gt;tm_hour * M_PI / 6;
  double seconds= timeinfo-&gt;tm_sec * M_PI / 30;

  cr-&gt;save();
  cr-&gt;set_line_cap(Cairo::LINE_CAP_ROUND);

  // draw the seconds hand
  cr-&gt;save();
  cr-&gt;set_line_width(m_line_width / 3);
  cr-&gt;set_source_rgba(0.7, 0.7, 0.7, 0.8); // gray
  cr-&gt;move_to(0, 0);
  cr-&gt;line_to(sin(seconds) * (m_radius * 0.9),
    -cos(seconds) * (m_radius * 0.9));
  cr-&gt;stroke();
  cr-&gt;restore();

  // draw the minutes hand
  cr-&gt;set_source_rgba(0.117, 0.337, 0.612, 0.9);   // blue
  cr-&gt;move_to(0, 0);
  cr-&gt;line_to(sin(minutes + seconds / 60) * (m_radius * 0.8),
    -cos(minutes + seconds / 60) * (m_radius * 0.8));
  cr-&gt;stroke();

  // draw the hours hand
  cr-&gt;set_source_rgba(0.337, 0.612, 0.117, 0.9);   // green
  cr-&gt;move_to(0, 0);
  cr-&gt;line_to(sin(hours + minutes / 12.0) * (m_radius * 0.5),
    -cos(hours + minutes / 12.0) * (m_radius * 0.5));
  cr-&gt;stroke();
  cr-&gt;restore();

  // draw a little dot in the middle
  cr-&gt;arc(0, 0, m_line_width / 3.0, 0, 2 * M_PI);
  cr-&gt;fill();

  return true;
}


bool Clock::on_timeout()
{
    // force our program to redraw the entire clock.
    Glib::RefPtr&lt;Gdk::Window&gt; win = get_window();
    if (win)
    {
        Gdk::Rectangle r(0, 0, get_allocation().get_width(),
                get_allocation().get_height());
        win-&gt;invalidate_rect(r, false);
    }
    return true;
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "clock.h"
#include &lt;gtkmm/main.h&gt;
#include &lt;gtkmm/window.h&gt;

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

   Gtk::Window win;
   win.set_title("Cairomm Clock");

   Clock c;
   win.add(c);
   c.show();

   Gtk::Main::run(win);

   return 0;
}
</programlisting>
<!-- end inserted example code -->
      <para>Comme auparavant, la plupart des choses intéressantes se passent dans le gestionnaire des événements d'exposition <methodname>on_expose_event()</methodname>. Avant de creuser ce gestionnaire, notez que le constructeur de l'élément graphique <classname>Clock</classname> connecte sa fonction de rappel <methodname>onSecondElapsed()</methodname> à un séquenceur qui se déclenche toutes les 1000 millisecondes (1 seconde). Cela signifie que <methodname>onSecondElapsed()</methodname> sera appelée toutes les secondes. La seule responsabilité de cette fonction consiste à invalider la fenêtre de façon à ce que <application>gtkmm</application> soit obligé de la retracer.</para>
      <para>Regardons maintenant le code qui effectue en fait le tracé. La première partie de <methodname>on_expose_event()</methodname> doit maintenant vous être familière car il s'agit de code « standardisé » pour obtenir le <classname>Gdk::Window</classname>, créer le <classname>Cairo::Context</classname> et découper la zone que nous souhaitons retracer. À nouveau cet exemple inscrit son système de coordonnées dans un carré unité : il est ainsi plus facile de tracer le cadran en proportion de la taille de la fenêtre qui est automatiquement mise à l'échelle en cas de redimensionnement. Mieux, le système de coordonnées est gradué de façon à ce que l'origine (0, 0) soit situé au centre réel de la fenêtre.</para>
      <para>La fonction <methodname>Cairo::Context::paint()</methodname> est ici utilisée pour définir la couleur d'arrière-plan de la fenêtre. Cette fonction ne prend aucun paramètre et remplit la surface actuelle (ou la partie tronquée de la surface) avec la couleur source actuellement active. Après avoir défini la couleur de fond, nous traçons un cercle pour délimiter le cadran, le remplissons en blanc et soulignons le pourtour de noir. Notez que ces actions utilisent la variante <methodname>_preserve</methodname> pour conserver le chemin en cours, puis ce même chemin est découpé pour s'assurer que nos prochains tracés ne sortiront pas du pourtour du cadran.</para>
      <para>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.</para>
  </sect1>
</chapter>

<chapter id="chapter-draganddrop">
<title>Glisser-déposer</title>
<para><classname>Gtk::Widget</classname> dispose de plusieurs fonctions membres et signaux préfixés par « drag_ » qui sont utilisés pour le glisser-déposer.</para>
<sect1 id="sec-dnd-sources-destinations">
<title>Sources et destinations</title>
<para>Les objets sont glissés à partir de <literal>sources</literal> pour être déposés sur des <literal>destinations</literal>. Chaque source et chaque destination dispose d'informations à propos du format des données qu'elle peut recevoir ou envoyer, informations fournies par les éléments <classname>Gtk::TargetEntry</classname>. Une destination de dépôt n'accepte un élément glissé que s'ils partagent un élément <classname>Gtk::TargetEntry</classname> compatible. Les signaux appropriés sont alors émis, indiquant au gestionnaire de signaux le <classname>Gtk::TargetEntry</classname> qui a été utilisé.</para>
<para>Les objets <classname>Gtk::TargetEntry</classname> contiennent ces informations : <itemizedlist>
<listitem><para>cible : un nom, tel que « STRING »</para></listitem>
<listitem><para>info : un identifiant envoyé aux signaux pour indiquer quel TargetEntry a été utilisé.</para></listitem>
<listitem><para>drapeaux : utilisé seulement pour le glisser-déposer, il indique si les données peuvent être glisser vers d'autres éléments graphiques et applications ou seulement vers les mêmes éléments graphiques.</para></listitem>
</itemizedlist></para>

</sect1>

<sect1 id="sec-dnd-methods">
<title>Fonctions membres</title>
<para>Les <classname>éléments graphiques</classname> sont identifiés en tant que sources ou destinations à l'aide des fonctions membres <classname>Gtk::Widget</classname> suivantes :</para>
<programlisting>void drag_source_set(const ArrayHandle_TargetEntry&amp; targets,
      GdkModifierType start_button_mask, GdkDragAction actions);</programlisting>

<itemizedlist>
<listitem>
    <para><literal>targets</literal> est un conteneur pour éléments <classname>Gtk::TargetEntry</classname> (<classname>std::list&lt;Gtk::TargetEntry&gt;</classname> ou <classname>std::vector&lt;Gtk::TargetEntry&gt;</classname>, par exemple).</para>
</listitem>
<listitem>
    <para><literal>start_button_mask</literal> 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.</para>
</listitem>
<listitem>
    <para><literal>actions</literal> est une combinaison de valeurs liées avec l'opérateur binaire OR ; elle précise les opérations de glisser-déposer possibles à partir de cette source — par exemple, copier, déplacer ou lier. L'utilisateur peut choisir le type d'opérations avec les touches modificatrices ; ainsi, <keycap>Maj</keycap> permet de transformer la « <literal>copie</literal> » en « <literal>déplacement</literal> » ; ce changement est indiqué par la modification de la forme du pointeur de souris.</para>
</listitem>
</itemizedlist>

<programlisting>void drag_dest_set(const ArrayHandle_TargetEntry&amp; targets,
    GtkDestDefaults flags, GdkDragAction actions);</programlisting>

<itemizedlist>
<listitem>
    <para><literal>flags</literal> 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.</para>
</listitem>
<listitem>
    <para><literal>actions</literal> indique les actions de glisser-déposer que cette destination peut accepter — voir la description plus haut.</para>
</listitem>
</itemizedlist>
</sect1>

<sect1 id="sec-dnd-signals">
<title>Signaux</title>
<para>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 <keycap>Maj</keycap> pour indiquer un <literal>déplacement</literal> plutôt qu'une <literal>copie</literal>. Souvenez-vous que l'utilisateur ne peut sélectionner que les actions définies dans vos appels à <methodname>drag_dest_set()</methodname> et <methodname>drag_source_set()</methodname>.</para>

<sect2 id="sec-dnd-signals-copy">
<title>Copie</title>
<para>L'élément graphique source va émettre ces signaux, dans cet ordre : <itemizedlist>
<listitem><para><literal>drag_begin</literal> : fournit un objet DragContext.</para></listitem>
<listitem><para><literal>drag_motion</literal> : fournit un objet DragContext et les coordonnées. Vous pouvez appeler la fonction membre drag_status() de l'objet DragContext pour faire savoir les cibles acceptées.</para></listitem>
<listitem><para><literal>drag_get</literal> : fournit un objet <literal>info</literal> concernant le format des données glissées et une structure <literal>GtkSelectionData</literal> dans laquelle vous pouvez mettre les données requises.</para></listitem>
<listitem><para><literal>drag_drop</literal> : fournit un objet DragContext et les coordonnées.</para></listitem>
<listitem><para><literal>drag_end</literal> : fournit un objet DragContext.</para></listitem>
</itemizedlist></para>
<para>L'élément graphique destination émet ce signal après que l'élément source a émis le signal <literal>drag_get</literal> : <itemizedlist>
<listitem>
    <para><literal>drag_data_received</literal> : fournit un objet <literal>info</literal> concernant le format des données glissées et une structure <literal>GtkSelectionData</literal> contenant les données déposées. Vous pouvez appeller la fonction membre <methodname>drag_finish()</methodname> sur l'objet <literal>DragContext</literal> pour savoir si l'opération a réussi ou non.</para>
</listitem>
</itemizedlist></para>

</sect2>

<sect2 id="dnd-signal-move">
<title>Déplacement</title>
<para>Pendant un <literal>déplacement</literal>, l'élément graphique source émet également le signal : <itemizedlist>
<listitem><para><literal>drag_delete</literal> : offre à la source la possibilité de détruire les données initiales si c'est approprié.</para></listitem>
</itemizedlist></para>
</sect2>

<!--
<sect2 id="dnd-signal-link">
<title>Link</title>
<para>TODO: Find an example or documentation.</para>
</sect2>
-->
</sect1>

<sect1 id="sec-dragcontext">
<title>DragContext</title>
<para>Les signaux de glisser-déposer fournissent un objet  DragContext contenant certaines informations à propos de l'opération de glisser-déposer ; ces informations peuvent être utilisées pour influer sur le processus. Par exemple, vous pouvez faire apparaître l'élément graphique source ou modifier l'icône de glisser-déposer avec <methodname>set_icon()</methodname>. Plus important, vous pouvez faire appel à la fonction membre <methodname>drag_finish()</methodname> dans le gestionnaire du signal <literal>drag_data_received</literal> pour savoir si le dépôt a réussi ou non.</para>
</sect1>

<sect1 id="sec-dnd-example">
<title>Exemple</title>
<para>Voici un exemple très simple montrant une opération de glisser-déposer avec <literal>copie</literal> :</para>

<figure id="figure-drag-and-drop">
  <title>Glisser-déposer</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/drag_and_drop.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/drag_and_drop?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>dndwindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_DNDWINDOW_H
#define GTKMM_EXAMPLE_DNDWINDOW_H

#include &lt;gtkmm/box.h&gt;
#include &lt;gtkmm/label.h&gt;
#include &lt;gtkmm/window.h&gt;
#include &lt;gtkmm/button.h&gt;

class DnDWindow : public Gtk::Window
{

public:
  DnDWindow();
  virtual ~DnDWindow();

protected:
  //Signal handlers:
  void on_button_drag_data_get(
          const Glib::RefPtr&lt;Gdk::DragContext&gt;&amp; context,
          Gtk::SelectionData&amp; selection_data, guint info, guint time);
  void on_label_drop_drag_data_received(
          const Glib::RefPtr&lt;Gdk::DragContext&gt;&amp; context, int x, int y,
          const Gtk::SelectionData&amp; selection_data, guint info, guint time);

  //Member widgets:
  Gtk::HBox m_HBox;
  Gtk::Button m_Button_Drag;
  Gtk::Label m_Label_Drop;
};

#endif // GTKMM_EXAMPLE_DNDWINDOW_H
</programlisting>
<para>File: <filename>dndwindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "dndwindow.h"
#include &lt;iostream&gt;

DnDWindow::DnDWindow()
: m_Button_Drag("Drag Here\n"),
  m_Label_Drop("Drop here\n")
{
  set_title("DnD example");

  add(m_HBox);

  //Targets:
  std::vector&lt;Gtk::TargetEntry&gt; listTargets;
  listTargets.push_back( Gtk::TargetEntry("STRING") );
  listTargets.push_back( Gtk::TargetEntry("text/plain") );

  //Drag site:

  //Make m_Button_Drag a DnD drag source:
  m_Button_Drag.drag_source_set(listTargets);

  //Connect signals:
  m_Button_Drag.signal_drag_data_get().connect(sigc::mem_fun(*this,
              &amp;DnDWindow::on_button_drag_data_get));

  m_HBox.pack_start(m_Button_Drag);

  //Drop site:

  //Make m_Label_Drop a DnD drop destination:
  m_Label_Drop.drag_dest_set(listTargets);

  //Connect signals:
  m_Label_Drop.signal_drag_data_received().connect(sigc::mem_fun(*this,
              &amp;DnDWindow::on_label_drop_drag_data_received) );

  m_HBox.pack_start(m_Label_Drop);

  show_all();
}

DnDWindow::~DnDWindow()
{
}

void DnDWindow::on_button_drag_data_get(
        const Glib::RefPtr&lt;Gdk::DragContext&gt;&amp;,
        Gtk::SelectionData&amp; selection_data, guint, guint)
{
  selection_data.set(selection_data.get_target(), 8 /* 8 bits format */,
          (const guchar*)"I'm Data!",
          9 /* the length of I'm Data! in bytes */);
}

void DnDWindow::on_label_drop_drag_data_received(
        const Glib::RefPtr&lt;Gdk::DragContext&gt;&amp; context, int, int,
        const Gtk::SelectionData&amp; selection_data, guint, guint time)
{
  const int length = selection_data.get_length();
  if((length &gt;= 0) &amp;&amp; (selection_data.get_format() == 8))
  {
    std::cout &lt;&lt; "Received \"" &lt;&lt; selection_data.get_data_as_string()
        &lt;&lt; "\" in label " &lt;&lt; std::endl;
  }

  context-&gt;drag_finish(false, false, time);
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "dndwindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

<para>Dans le dossier examples/dnd, vous pouvez trouver un exemple un peu plus élaboré.</para>

</sect1>

</chapter>

<chapter id="chapter-clipboard">
<title>Le presse-papier</title>
<para>La fonctionnalité de copier-coller du texte brut est incorporée par construction pour des éléments graphiques tels que Gtk::Entry et Gtk::TextView, mais vous devez prévoir un code adapté pour faire des échanges dans le cas de vos propres formats de données. Par exemple, un programme de dessin a besoin de code spécialisé pour permettre le copier-coller dans une vue ou entre documents.</para>

<para>L'objet <classname>Gtk::Clipboard</classname> est un singleton. Vous ne pourrez en obtenir qu'une seule et unique instance avec <methodname>Gtk::Clipboard::get()</methodname>.</para>

<para>Ainsi votre application n'a pas besoin d'attendre pendant les opérations avec le presse-papier, en particulier, entre le moment où l'utilisateur sélectionne Copier et celui plus tard où il fait Coller ; la plupart des fonctions membres <classname>Gtk::Clipboard</classname> prennent comme paramètre <classname>sigc::slot</classname> qui définit les fonctions de rappel. Quand <classname>Gtk::Clipboard</classname> est prêt, il fait appel à ces fonctions membres, soit pour fournir les données requises, soit pour les demander.</para>

<para><ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Clipboard.html">Référence</ulink></para>

<sect1 id="sec-clipboard-targets">
<title>Cibles</title>
<para>Diverses applications contiennent divers types de données ; elles peuvent mettre ces données à disposition sous des formats variés. <application>gtkmm</application> appelle ces types de données des « <literal>targets</literal> » (cibles).</para>

<para>Par exemple, <application>gedit</application> peut fournir et recevoir la cible <literal>« UTF8_STRING »</literal> ; vous pouvez donc coller dans <application>gedit</application> des données de toute application fournissant cette cible. Ou bien, deux applications différentes de modification d'images peuvent fournir et recevoir divers formats d'image en tant que cibles. Tant qu'une application peut recevoir une des cibles que l'autre fournit, vous pouvez copier des données de l'une vers l'autre.</para>

<para>Une cible peut se présenter sous des formats binaires divers. Ce chapitre, et ses exemples, supposent que les données sont du texte 8 bits. Cela vous permet d'utiliser un format XML pour les données du presse-papier. Toutefois ce format ne sera certainement pas approprié pour des données binaires comme les images. La classe <classname>Gtk::Clipboard</classname> autorise des sur-définitions permettant de spécifier le format de façon plus détaillée si nécessaire.</para>

<para>L'API du <link linkend="chapter-draganddrop">glisser-déposer</link> utilise les mêmes mécanismes. Vous utiliserez probablement les mêmes formats et cibles de données à la fois pour les opérations avec le presse-papier et pour le glisser-déposer.</para>
</sect1>

<sect1 id="sec-clipboard-copy">
<title>Copie</title>
<para>Quand l'utilisateur demande de copier des données, vous devez indiquer à l'objet <classname>Clipboard</classname> quelles sont les cibles disponibles et fournir les fonctions de rappel à utiliser pour obtenir les données. À ce stade, vous stockez une copie des données à fournir quand le presse-papier appelle votre fonction de rappel en réponse à un coller.</para>
<para>Par exemple,</para>
<programlisting>Glib::RefPtr&lt;Gtk::Clipboard&gt; refClipboard = Gtk::Clipboard::get();

// Cibles :
std::list&lt;Gtk::TargetEntry&gt; listTargets;
listTargets.push_back( Gtk::TargetEntry("example_custom_target") );
listTargets.push_back( Gtk::TargetEntry("UTF8_STRING") );

refClipboard-&gt;set( listTargets,
    sigc::mem_fun(*this, &amp;ExampleWindow::on_clipboard_get),
    sigc::mem_fun(*this, &amp;ExampleWindow::on_clipboard_clear) );</programlisting>

<para>Votre fonction de rappel fournit alors les données enregistrées quand l'utilisateur décide de coller les données. Par exemple :</para>
<programlisting>void ExampleWindow::on_clipboard_get(
    Gtk::SelectionData&amp; selection_data, guint info)
{
  const Glib::ustring target = selection_data.get_target();

  if(target == "example_custom_target")
    selection_data.set("example_custom_target", m_ClipboardStore);
}</programlisting>
<para>L'exemple « <literal>idéal</literal> » ci-après peut fournir plus d'une cible de presse-papier.</para>

<para>La fonction de rappel de nettoyage libère la mémoire utilisée par le stockage de vos données quand le presse-papier remplace ses données par d'autres.</para>

</sect1>

<sect1 id="sec-clipboard-paste">
<title>Coller</title>
<para>Quand l'utilisateur demande à coller des données à partir du <classname>Clipboard</classname>, vous devez demander un format défini et fournir une fonction de rappel qui est appelée avec les vraies données. Par exemple :</para>
<programlisting>refClipboard-&gt;request_contents("example_custom_target",
    sigc::mem_fun(*this, &amp;ExampleWindow::on_clipboard_received) );</programlisting>

<para>Voici un exemple de fonction de rappel :</para>
<programlisting>void ExampleWindow::on_clipboard_received(
    const Gtk::SelectionData&amp; selection_data)
{
  Glib::ustring clipboard_data = selection_data.get_data_as_string();
  // Faire quelque choses avec les données collées.
}</programlisting>

<sect2 id="dnd-discovering-targets">
<title>Détermination des cibles admissibles</title>
<para>Pour retrouver quelles sont les cibles actuellement admissibles dans <classname>Clipboard</classname> pour le collage, appelez la fonction membre <methodname>request_targets()</methodname> en indiquant une fonction membre à appeler avec l'information. Par exemple :</para>
<programlisting>refClipboard-&gt;request_targets( sigc::mem_fun(*this,
    &amp;ExampleWindow::on_clipboard_received_targets) );</programlisting>

<para>Dans votre fonction de rappel, comparez la liste des cibles disponibles avec celle des cibles que votre application prend en charge pour le collage. Vous pouvez activer ou désactiver un élément de menu Coller selon que le collage est ou n'est pas actuellement possible. Par exemple :</para>
<programlisting>void ExampleWindow::on_clipboard_received_targets(
  const Glib::StringArrayHandle&amp; targets_array)
{
  // Obtenir la liste des cibles disponibles dans le presse-papier :
  std::list&lt;std::string&gt; targets = targets_array;

  const bool bPasteIsPossible =
    std::find(targets.begin(), targets.end(),
      example_target_custom) != targets.end();

  // Activer/désactiver le bouton Coller de manière appropriée :
  m_Button_Paste.set_sensitive(bPasteIsPossible);
}</programlisting>
</sect2>

</sect1>

<sect1 id="sec-clipboard-examples"><title>Exemples</title>

<sect2 id="sec-clipboard-example-simple"><title>Simple</title>
<para>Cet exemple permet le copier-coller de données propres à une application, avec une cible texte standard. Il est simple, mais il n'est pas idéal parce qu'il n'identifie pas les données <classname>Clipboard</classname> comme étant d'un type donné.</para>

<figure id="figure-clipboard-simple">
  <title>Presse-papier - Simple</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/clipboard_simple.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/clipboard/simple/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

protected:
  //Signal handlers:
  void on_button_copy();
  void on_button_paste();
  void on_clipboard_text_received(const Glib::ustring&amp; text);

  //Child widgets:
  Gtk::VBox m_VBox;

  Gtk::Label m_Label;
  
  Gtk::Table m_Table;
  Gtk::ToggleButton m_ButtonA1, m_ButtonA2, m_ButtonB1, m_ButtonB2;

  Gtk::HButtonBox m_ButtonBox;
  Gtk::Button m_Button_Copy, m_Button_Paste;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"

ExampleWindow::ExampleWindow()
: m_Label("Select cells in the table, click Copy, then open a second "
        "instance of this example to try pasting the copied data."),
  m_Table(2, 2, true),
  m_ButtonA1("A1"), m_ButtonA2("A2"), m_ButtonB1("B1"), m_ButtonB2("B2"),
  m_Button_Copy(Gtk::Stock::COPY), m_Button_Paste(Gtk::Stock::PASTE)
{
  set_title("Gtk::Clipboard example");
  set_border_width(12);

  add(m_VBox);

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

  //Fill Table:
  m_VBox.pack_start(m_Table);
  m_Table.attach(m_ButtonA1, 0, 1, 0, 1);
  m_Table.attach(m_ButtonA2, 1, 2, 0, 1);
  m_Table.attach(m_ButtonB1, 0, 1, 1, 2);
  m_Table.attach(m_ButtonB2, 1, 2, 1, 2);

  //Add ButtonBox to bottom:
  m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);
  m_VBox.set_spacing(6);

  //Fill ButtonBox:
  m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
  m_ButtonBox.pack_start(m_Button_Copy, Gtk::PACK_SHRINK);
  m_Button_Copy.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_copy) );
  m_ButtonBox.pack_start(m_Button_Paste, Gtk::PACK_SHRINK);
  m_Button_Paste.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_paste) );

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_button_copy()
{
  //Build a string representation of the stuff to be copied:
  //Ideally you would use XML, with an XML parser here:
  Glib::ustring strData;
  strData += m_ButtonA1.get_active() ? "1" : "0";
  strData += m_ButtonA2.get_active() ? "1" : "0";
  strData += m_ButtonB1.get_active() ? "1" : "0";
  strData += m_ButtonB2.get_active() ? "1" : "0";

  Glib::RefPtr&lt;Gtk::Clipboard&gt; refClipboard = Gtk::Clipboard::get();
  refClipboard-&gt;set_text(strData);
}

void ExampleWindow::on_button_paste()
{
  //Tell the clipboard to call our method when it is ready:
  Glib::RefPtr&lt;Gtk::Clipboard&gt; refClipboard = Gtk::Clipboard::get();
  refClipboard-&gt;request_text(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_clipboard_text_received) );
}

void ExampleWindow::on_clipboard_text_received(const Glib::ustring&amp; text)
{
  //See comment in on_button_copy() about this silly clipboard format.
  if(text.size() &gt;= 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' );
  }
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

<sect2 id="sec-clipboard-example-ideal"><title>Idéal</title>
<para>Il est identique à l'exemple simple, mais il <orderedlist>
<listitem><simpara>définit une cible de presse-papier personnalisée, même si le format de cette cible est toujours du texte,</simpara></listitem>
<listitem><simpara>prend en charge le collage de 2 cibles — d'une part la cible personnalisée, d'autre part une cible texte créant un représentation textuelle arbitraire des données personnalisées,</simpara></listitem>
<listitem><simpara>utilise <methodname>request_targets()</methodname> et le signal <literal>owner_change</literal> et désactive le bouton Coller s'il ne peut pas utiliser les données du presse-papier.</simpara></listitem>
</orderedlist></para>

<figure id="figure-clipboard-ideal">
  <title>Presse-papier - Idéal</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/clipboard_ideal.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/clipboard/ideal/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

protected:
  //Signal handlers:
  void on_button_copy();
  void on_button_paste();

  void on_clipboard_owner_change(GdkEventOwnerChange* event);
  void on_clipboard_get(Gtk::SelectionData&amp; selection_data, guint info);
  void on_clipboard_clear();

  void on_clipboard_received(const Gtk::SelectionData&amp; selection_data);
  void on_clipboard_received_targets(const Glib::StringArrayHandle&amp; targets_array);
   
  virtual void update_paste_status(); //Disable the paste button if there is nothing to paste.

  //Child widgets:
  Gtk::VBox m_VBox;

  Gtk::Label m_Label;
  
  Gtk::Table m_Table;
  Gtk::ToggleButton m_ButtonA1, m_ButtonA2, m_ButtonB1, m_ButtonB2;

  Gtk::HButtonBox m_ButtonBox;
  Gtk::Button m_Button_Copy, m_Button_Paste;

  Glib::ustring m_ClipboardStore; //Keep copied stuff here, until it is pasted. This could be a big complex data structure.
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;algorithm&gt;

namespace
{

//These should usually be MIME types.
const char example_target_custom[] = "gtkmmclipboardexample";
const char example_target_text[]   = "UTF8_STRING";

} // anonymous namespace


ExampleWindow::ExampleWindow()
: m_Label("Select cells in the table, click Copy, then open a second instance "
          "of this example to try pasting the copied data.\nOr try pasting the "
          "text representation into gedit."),
  m_Table(2, 2, true),
  m_ButtonA1("A1"), m_ButtonA2("A2"), m_ButtonB1("B1"), m_ButtonB2("B2"),
  m_Button_Copy(Gtk::Stock::COPY), m_Button_Paste(Gtk::Stock::PASTE)
{
  set_title("Gtk::Clipboard example");
  set_border_width(12);

  add(m_VBox);

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

  //Fill Table:
  m_VBox.pack_start(m_Table);
  m_Table.attach(m_ButtonA1, 0, 1, 0, 1);
  m_Table.attach(m_ButtonA2, 1, 2, 0, 1);
  m_Table.attach(m_ButtonB1, 0, 1, 1, 2);
  m_Table.attach(m_ButtonB2, 1, 2, 1, 2);

  //Add ButtonBox to bottom:
  m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);
  m_VBox.set_spacing(6);

  //Fill ButtonBox:
  m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
  m_ButtonBox.pack_start(m_Button_Copy, Gtk::PACK_SHRINK);
  m_Button_Copy.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_copy) );
  m_ButtonBox.pack_start(m_Button_Paste, Gtk::PACK_SHRINK);
  m_Button_Paste.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_paste) );

  //Connect a signal handler that will be called when the contents of
  //the clipboard change.
  Gtk::Clipboard::get()-&gt;signal_owner_change().connect(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_clipboard_owner_change) );

  show_all_children();

  update_paste_status();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_button_copy()
{
  //Build a string representation of the stuff to be copied:
  //Ideally you would use XML, with an XML parser here:
  Glib::ustring strData;
  strData += m_ButtonA1.get_active() ? "1" : "0";
  strData += m_ButtonA2.get_active() ? "1" : "0";
  strData += m_ButtonB1.get_active() ? "1" : "0";
  strData += m_ButtonB2.get_active() ? "1" : "0";

  Glib::RefPtr&lt;Gtk::Clipboard&gt; refClipboard = Gtk::Clipboard::get();

  //Targets:
  std::vector&lt;Gtk::TargetEntry&gt; listTargets;

  listTargets.push_back( Gtk::TargetEntry(example_target_custom) );
  listTargets.push_back( Gtk::TargetEntry(example_target_text) );

  refClipboard-&gt;set(listTargets, sigc::mem_fun(*this,
              &amp;ExampleWindow::on_clipboard_get), sigc::mem_fun(*this,
                  &amp;ExampleWindow::on_clipboard_clear) );

  //Store the copied data until it is pasted:
  //(Must be done after the call to refClipboard-&gt;set, because that call
  //may trigger a call to on_clipboard_clear.)
  m_ClipboardStore = strData;

  update_paste_status();
}

void ExampleWindow::on_button_paste()
{
  //Tell the clipboard to call our method when it is ready:
  Glib::RefPtr&lt;Gtk::Clipboard&gt; refClipboard = Gtk::Clipboard::get();

  refClipboard-&gt;request_contents(example_target_custom, 
    sigc::mem_fun(*this, &amp;ExampleWindow::on_clipboard_received) );

  update_paste_status();
}

void ExampleWindow::on_clipboard_owner_change(GdkEventOwnerChange*)
{
  update_paste_status();
}

void ExampleWindow::on_clipboard_get(Gtk::SelectionData&amp; selection_data, guint)
{
  //info is meant to indicate the target, but it seems to be always 0,
  //so we use the selection_data's target instead.

  const std::string target = selection_data.get_target();

  if(target == example_target_custom)
  {
    // This set() override uses an 8-bit text format for the data.
    selection_data.set(example_target_custom, m_ClipboardStore);
  }
  else if(target == example_target_text)
  {
    //Build some arbitrary text representation of the data,
    //so that people see something when they paste into a text editor:
    Glib::ustring text_representation;

    text_representation += m_ButtonA1.get_active() ? "A1, " : "";
    text_representation += m_ButtonA2.get_active() ? "A2, " : "";
    text_representation += m_ButtonB1.get_active() ? "B1, " : "";
    text_representation += m_ButtonB2.get_active() ? "B2, " : "";

    selection_data.set_text(text_representation);
  }
  else
  {
    g_warning("ExampleWindow::on_clipboard_get(): "
            "Unexpected clipboard target format.");
  }
}

void ExampleWindow::on_clipboard_clear()
{
  //This isn't really necessary. I guess it might save memory.
  m_ClipboardStore.clear();
}

void ExampleWindow::on_clipboard_received(
        const Gtk::SelectionData&amp; selection_data)
{
  const std::string target = selection_data.get_target();

  //It should always be this, because that' what we asked for when calling
  //request_contents().
  if(target == example_target_custom)
  {
    Glib::ustring clipboard_data = selection_data.get_data_as_string();

    //See comment in on_button_copy() about this silly clipboard format.
    if(clipboard_data.size() &gt;= 4)
    {
      m_ButtonA1.set_active( clipboard_data[0] == '1' );
      m_ButtonA2.set_active( clipboard_data[1] == '1' );
      m_ButtonB1.set_active( clipboard_data[2] == '1' );
      m_ButtonB2.set_active( clipboard_data[3] == '1' );
    }
  }
}

void ExampleWindow::update_paste_status()
{
  //Disable the paste button if there is nothing to paste.

  Glib::RefPtr&lt;Gtk::Clipboard&gt; refClipboard = Gtk::Clipboard::get();

  //Discover what targets are available:
  refClipboard-&gt;request_targets(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_clipboard_received_targets) );
}

void ExampleWindow::on_clipboard_received_targets(
  const Glib::StringArrayHandle&amp; targets_array)
{
  // Get the list of available clipboard targets:
  std::vector&lt;std::string&gt; targets = targets_array;

  const bool bPasteIsPossible =
    std::find(targets.begin(), targets.end(),
      example_target_custom) != targets.end();

  // Enable/Disable the Paste button appropriately:
  m_Button_Paste.set_sensitive(bPasteIsPossible);
}

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

</sect1>


</chapter>

<chapter id="chapter-printing">
<title>Impression</title>

<para>Au niveau développement d'une application, l'API impression de <application>gtkmm</application> fournit des boîtes de dialogue cohérentes entre applications et autorise l'API de dessin courant de Cairo avec un moteur de rendu de texte piloté par Pango. Pour l'implémentation courante de cette API, sont utilisés des moteurs de traitement particuliers à la plate-forme et des pilotes d'imprimantes spécifiques au périphérique.</para>

<sect1 id="sec-printoperation">
<title>Objet PrintOperation</title>

<para>L'objet principal est <classname>Gtk::PrintOperation</classname>, 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.  <classname>PrintOperation</classname> gère automatiquement tous les paramètres affectant la boucle d'impression.</para>

<sect2 id="sec-printoperation-signals">
<title>Signaux</title>

<para>La fonction membre <methodname>PrintOperation::run()</methodname> démarre la boucle d'impression au cours de laquelle divers signaux sont émis : <itemizedlist>
  <listitem>
    <para><literal>begin_print</literal> : vous devez gérer ce signal car c'est à cet instant que vous créez et définissez un objet <classname>Pango::Layout</classname> en utilisant le <classname>Gtk::PrintContext</classname> fourni et que vous y divisez la sortie d'impression en plusieurs pages.</para>
  </listitem>

  <listitem>
    <para><literal>paginate</literal> : la pagination est en règle générale lente, donc si vous voulez la contrôler, vous pouvez appeler la fonction membre <methodname>PrintOperation::set_show_progress()</methodname> et gérer ce signal.</para>
  </listitem>

  <listitem>
    <para>Pour chaque page devant être imprimée, les signaux suivants sont émis : <itemizedlist>
        <listitem>
          <para><literal>request_page_setup</literal> : fournit un objet <classname>PrintContext</classname>, un numéro de page et un objet <classname>Gtk::PageSetup</classname>. Gérez ce signal si vous voulez modifier page par page les réglages de la page.</para>
        </listitem>

        <listitem>
          <para><literal>draw_page</literal> : vous devez gérer ce signal qui fournit un objet <classname>PrintContext</classname> et un numéro de page. L'objet <classname>PrintContext</classname> sera utilisé pour créer un <classname>Cairo::Context</classname> dans lequel la page donnée sera dessinée. Pour le rendu du texte, itérez sur le <classname>Pango::Layout</classname> que vous avez créé dans le gestionnaire du signal <literal>begin_print</literal>.</para>
        </listitem>
      </itemizedlist></para>
  </listitem>

  <listitem>
    <para><literal>end_print</literal> : un gestionnaire pour ce signal est une place sûre pour libérer les ressources relatives à <classname>PrintOperation</classname>. Si vous avez une classe personnalisée dérivée de <classname>PrintOperation</classname>, il est évidemment plus simple de faire cela dans le destructeur.</para>
  </listitem>

  <listitem>
    <para><literal>done</literal> : ce signal est émis quand l'impression est terminée, cela signifie que les données de l'impression ont été placées en file d'attente. Notez que la valeur <literal>Gtk::PrintOperationResult</literal> renvoyée peut indiquer qu'une erreur est survenue. Dans tous les cas, vous souhaiterez probablement avertir l'utilisateur du résultat final.</para>
  </listitem>

  <listitem>
    <para><literal>status_changed</literal> : ce signal est émis chaque fois que l'état d'une tâche d'impression change jusqu'à ce qu'elle soit terminée. Appelez la fonction membre <methodname>PrintOperation::set_track_print_status()</methodname> pour contrôler l'état de la tâche après qu'elle a été placée en file d'attente. Pour afficher l'état, utilisez <methodname>get_status()</methodname> ou <methodname>get_status_string()</methodname>.</para>
  </listitem>
</itemizedlist></para>

<para>
<ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1PrintOperation.html">Référence</ulink>
</para>

</sect2>

</sect1>

<sect1 id="sec-page-setup">
<title>Mise en page</title>

<para>La classe <classname>PrintOperation</classname> dispose d'une fonction membre nommée <methodname>set_default_page_setup()</methodname> 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 <methodname>Gtk::run_page_setup_dialog()</methodname> qui renvoie un objet <classname>Gtk::PageSetup</classname> avec les réglages choisis. Utilisez cet objet pour mettre à jour un <classname>PrintOperation</classname> et avoir accès aux variables <classname>Gtk::PaperSize</classname>, <literal>Gtk::PageOrientation</literal> choisies ainsi qu'aux marges particulières à l'imprimante.</para>
<para>Enregistrez l'objet <classname>Gtk::PageSetup</classname> avec vos choix, ainsi vous pourrez l'utiliser à nouveau si la boîte de dialogue de mise en page est à nouveau affichée.</para>

<para>Par exemple, <programlisting>
// Dans une classe dérivée de Gtk::Window 
// avec m_refPageSetup et m_refSettings comme membres...
Glib::RefPtr&lt;Gtk::PageSetup&gt; new_page_setup = Gtk::run_page_setup_dialog(*this,
                                                      m_refPageSetup, m_refSettings);
m_refPageSetup = new_page_setup;
</programlisting></para>

<para>
<ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1PageSetup.html">Référence</ulink>
</para>

<para>Le système de coordonnées de Cairo, dans le gestionnaire de <literal>draw_page</literal>, 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 <methodname>PrintOperation::set_use_full_page()</methodname>. 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 <methodname>PrintOperation::set_unit()</methodname>.</para>

</sect1>

<sect1 id="sec-printing-rendering-text">
<title>Rendu de texte</title>

<para>Le rendu du texte s'effectue avec Pango. L'objet <classname>Pango::Layout</classname> pour l'impression est créé en appelant la fonction membre <methodname>PrintContext::create_pango_layout()</methodname>. L'objet <classname>PrintContext</classname> indique également la métrique de la page par l'intermédiaire des fonctions <methodname>get_width()</methodname> et <methodname>get_height()</methodname>. Le nombre de pages peut être fixé à l'aide de <methodname>PrintOperation::set_n_pages()</methodname>. Pour effectuer le rendu effectif du texte Pango dans <literal>on_draw_page</literal>, obtenez un <classname>Cairo::Context</classname> avec la fonction membre <methodname>PrintContext::get_cairo_context()</methodname> et affichez les objets <classname>Pango::LayoutLine</classname> qui apparaissent dans le nombre de pages demandées.</para>

<para>Pour voir exactement comment réaliser ceci, consultez <link linkend="sec-printing-example-simple">cet exemple</link>.</para>

</sect1>

<sect1 id="sec-async-printing-ops">
<title>Opérations asynchrones</title>

<para>Par défaut, <methodname>PrintOperation::run()</methodname> rend la main quand l'opération d'impression est terminée. Si vous voulez lancer une opération d'impression non-bloquante, appelez <methodname>PrintOperation::set_allow_async()</methodname>. Notez que <methodname>set_allow_async()</methodname> n'est pas pris en charge sur toutes les plates-formes, bien que le signal <literal>done</literal> soit toujours émis.</para>

<para>Il se peut que la fonction membre <methodname>run()</methodname> renvoie <literal>PRINT_OPERATION_RESULT_IN_PROGRESS</literal>. Pour suivre l'état et gérer le résultat ou une erreur, vous devez implémenter des gestionnaires pour les signaux <literal>done</literal> et <literal>status_changed</literal> :</para>

<para>Par exemple, <programlisting>
// dans la fonction membre de la classe ExampleWindow...
Glib::RefPtr&lt;PrintOperation&gt; op = PrintOperation::create();
// ...paramétrer op...
op-&gt;signal_done().connect(sigc::bind(sigc::mem_fun(*this, 
                &amp;ExampleWindow::on_printoperation_done), op));
// lancer op
</programlisting></para>

<para>Ensuite, vérifiez si une erreur est survenue et connectez le signal <literal>status_changed</literal>. Par exemple : <programlisting>
void ExampleWindow::on_printoperation_done(Gtk::PrintOperationResult result,
                           const Glib::RefPtr&lt;PrintOperation&gt;&amp; op)
{
  if (result == Gtk::PRINT_OPERATION_RESULT_ERROR)
    // avertir l'utilisateur
  else if (result == Gtk::PRINT_OPERATION_RESULT_APPLY)
    // mettre à jour PrintSettings avec ceux de cette PrintOperation

  if (! op-&gt;is_finished())
    op-&gt;signal_status_changed().connect(sigc::bind(sigc::mem_fun(*this,
              &amp;ExampleWindow::on_printoperation_status_changed), op));
}
</programlisting></para>

<para>Pour terminer, vérifiez l'état. Par exemple : <programlisting>
void ExampleWindow::on_printoperation_status_changed(
            const Glib::RefPtr&lt;PrintFormOperation&gt;&amp; op)
{
  if (op-&gt;is_finished())
    // la tâche d'impression est terminée 
  else
    // obtenir l'état avec get_status() ou get_status_string()

  // mettre à jour l'UI
}
</programlisting></para>

</sect1>

<sect1 id="sec-printing-export-to-pdf">
<title>Exportation au format PDF</title>
<para>L'option « Imprimer dans un fichier » est disponible dans la boîte de dialogue d'impression sans qu'il soit nécessaire de réaliser d'autres implémentations. Toutefois, il est quelquefois utile de générer un fichier .pdf directement dans le code. Par exemple, <programlisting>
Glib::RefPtr&lt;Gtk::PrintOperation&gt; op = Gtk::PrintOperation::create();
// ...configurer op...
op-&gt;set_export_filename("test.pdf");
Gtk::PrintOperationResult res = op-&gt;run(Gtk::PRINT_OPERATION_ACTION_EXPORT);
</programlisting></para>

</sect1>

<sect1 id="sec-extending-print-dialog">
<title>Extension de la boîte de dialogue d'impression</title>

<para>Vous pouvez ajouter un onglet personnalisé à la boîte de dialogue d'impression : <itemizedlist>
  <listitem>
    <para>définissez l'intitulé de l'onglet avec <methodname>PrintOperation::set_custom_tab_label()</methodname>, créez un nouvel élément graphique et renvoyez un pointeur sur celui-ci dans le gestionnaire de signal <literal>create_custom_widget</literal>. Vous souhaiterez probablement que ce soit un élément graphique conteneur en empaquetant quelques autres.</para>
  </listitem>

  <listitem>
    <para>recueillez les données des éléments graphiques dans le gestionnaire de signal <literal>custom_widget_apply</literal>.</para>
  </listitem>
</itemizedlist></para>

<para>Bien que le signal <literal>custom_widget_apply</literal> fournisse un pointeur sur l'élément graphique précédemment créé, pour simplifier les choses, vous pouvez conserver en tant que membres de la classe, les éléments graphiques présumés contenir des entrées utilisateur. Par exemple, disons que nous avons un <classname>Gtk::Entry</classname> nommé <literal>m_Entry</literal> membre de votre classe <classname>CustomPrintOperation</classname> : <programlisting>
Gtk::Widget* CustomPrintOperation::on_create_custom_widget()
{
  set_custom_tab_label("Onglet personnalisé");

  Gtk::HBox* hbox = new Gtk::HBox(false, 8);
  hbox-&gt;set_border_width(6);

  Gtk::Label* label = Gtk::manage(new Gtk::Label("Saisissez du texte : "));
  hbox-&gt;pack_start(*label, false, false);
  label-&gt;show();

  hbox-&gt;pack_start(m_Entry, false, false);
  m_Entry.show();

  return hbox;
}

void CustomPrintOperation::on_custom_widget_apply(Gtk::Widget* /* widget */)
{
  Glib::ustring user_input = m_Entry.get_text();
  //...
}
</programlisting></para>

<para>L'exemple dans le dossier <filename>examples/book/printing/advanced</filename> démontre cette façon d'opérer.</para>

</sect1>

<sect1 id="sec-printing-preview">
<title>Aperçu</title>

<para>La boîte de dialogue d'impression native de GTK+ dispose d'un bouton d'aperçu, mais vous pouvez également lancer l'aperçu directement à partir de l'application : <programlisting>
// dans une classe qui hérite de Gtk::Window...
Glib::RefPtr&lt;PrintOperation&gt; op = PrintOperation::create();
// ...paramétrer op...
op-&gt;run(Gtk::PRINT_OPERATION_ACTION_PREVIEW, *this);
</programlisting></para>

<para>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 <filename>/examples/book/printing/advanced</filename>.</para>

</sect1>

<sect1 id="sec-printing-example">
<title>Exemple</title>

<sect2 id="sec-printing-example-simple">
<title>Simple</title>

<para>L'exemple suivant montre comment imprimer une saisie à partir d'une interface utilisateur. Il montre comment implémenter <literal>on_begin_print</literal> et <literal>on_draw_page</literal>, de même que suivre l'état de l'impression et mettre à jour les réglages.</para>

<figure id="figure-printing-simple">
  <title>Impression - Simple</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/printing.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/printing/simple/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>printformoperation.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_PRINT_FORM_OPERATION_H
#define GTKMM_PRINT_FORM_OPERATION_H

#include &lt;pangomm.h&gt;
#include &lt;gtkmm.h&gt;
#include &lt;vector&gt;

//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&lt;PrintFormOperation&gt; create();
  virtual ~PrintFormOperation();

  void set_name(const Glib::ustring&amp; name) { m_Name = name; }
  void set_comments(const Glib::ustring&amp; comments) { m_Comments = comments; }

 protected:
  PrintFormOperation();

  //PrintOperation default signal handler overrides:
  virtual void on_begin_print(const Glib::RefPtr&lt;Gtk::PrintContext&gt;&amp; context);
  virtual void on_draw_page(const Glib::RefPtr&lt;Gtk::PrintContext&gt;&amp; context, int page_nr);

  Glib::ustring m_Name;
  Glib::ustring m_Comments;
  Glib::RefPtr&lt;Pango::Layout&gt; m_refLayout;
  std::vector&lt;int&gt; m_PageBreaks; // line numbers where a page break occurs
};

#endif // GTKMM_PRINT_FORM_OPERATION_H
</programlisting>
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;memory&gt;
#include &lt;vector&gt;

#include &lt;pangomm.h&gt;
#include &lt;gtkmm.h&gt;

class PrintFormOperation;

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

protected:

  void build_main_menu();

  void print_or_preview(Gtk::PrintOperationAction print_action);

  //PrintOperation signal handlers.
  //We handle these so can get necessary information to update the UI or print settings.
  //Our derived PrintOperation class also overrides some default signal handlers.
  void on_printoperation_status_changed(const Glib::RefPtr&lt;PrintFormOperation&gt;&amp; operation);

  void on_printoperation_done(Gtk::PrintOperationResult result, const Glib::RefPtr&lt;PrintFormOperation&gt;&amp; operation);

  //Action signal handlers:
  void on_menu_file_new();
  void on_menu_file_page_setup();
  void on_menu_file_print_preview();
  void on_menu_file_print();
  void on_menu_file_quit();

  //Printing-related objects:
  Glib::RefPtr&lt;Gtk::PageSetup&gt; m_refPageSetup;
  Glib::RefPtr&lt;Gtk::PrintSettings&gt; m_refSettings;


  //Child widgets:
  Gtk::VBox m_VBox;
  Gtk::Table m_Table;

  Gtk::Label m_NameLabel;
  Gtk::Entry m_NameEntry;

  Gtk::Label m_SurnameLabel;
  Gtk::Entry m_SurnameEntry;

  Gtk::Label m_CommentsLabel;
  Gtk::ScrolledWindow m_ScrolledWindow;
  Gtk::TextView m_TextView;
  
  Glib::RefPtr&lt;Gtk::TextBuffer&gt; m_refTextBuffer;

  unsigned m_ContextId;
  Gtk::Statusbar m_Statusbar;

  Glib::RefPtr&lt;Gtk::UIManager&gt; m_refUIManager;
  Glib::RefPtr&lt;Gtk::ActionGroup&gt; m_refActionGroup;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>printformoperation.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "printformoperation.h"

PrintFormOperation::PrintFormOperation()
{
}

PrintFormOperation::~PrintFormOperation()
{
}

Glib::RefPtr&lt;PrintFormOperation&gt; PrintFormOperation::create()
{
  return Glib::RefPtr&lt;PrintFormOperation&gt;(new PrintFormOperation());
}

void PrintFormOperation::on_begin_print(
        const Glib::RefPtr&lt;Gtk::PrintContext&gt;&amp; 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-&gt;create_pango_layout();

  Pango::FontDescription font_desc("sans 12");
  m_refLayout-&gt;set_font_description(font_desc);

  const double width = print_context-&gt;get_width();
  const double height = print_context-&gt;get_height();

  m_refLayout-&gt;set_width(static_cast&lt;int&gt;(width * Pango::SCALE));

  //Set and mark up the text to print:
  Glib::ustring marked_up_form_text;
  marked_up_form_text += "&lt;b&gt;Name&lt;/b&gt;: " + m_Name + "\n\n";
  marked_up_form_text += "&lt;b&gt;Comments&lt;/b&gt;: " + m_Comments;

  m_refLayout-&gt;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-&gt;get_line_count();

  Glib::RefPtr&lt;Pango::LayoutLine&gt; layout_line;
  double page_height = 0;

  for (int line = 0; line &lt; line_count; ++line)
  {
    Pango::Rectangle ink_rect, logical_rect;

    layout_line = m_refLayout-&gt;get_line(line);
    layout_line-&gt;get_extents(ink_rect, logical_rect);

    const double line_height = logical_rect.get_height() / 1024.0;

    if (page_height + line_height &gt; 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&lt;Gtk::PrintContext&gt;&amp; 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 &lt; static_cast&lt;int&gt;(m_PageBreaks.size()))
  {
    end_page_line = m_PageBreaks[page_nr];
  }
  else
  {
    end_page_line = m_refLayout-&gt;get_line_count();
  }

  //Get a Cairo Context, which is used as a drawing board:
  Cairo::RefPtr&lt;Cairo::Context&gt; cairo_ctx = print_context-&gt;get_cairo_context();

  //We'll use black letters:
  cairo_ctx-&gt;set_source_rgb(0, 0, 0);

  //Render Pango LayoutLines over the Cairo context:
  Pango::LayoutIter iter = m_refLayout-&gt;get_iter();

  double start_pos = 0;
  int line_index = 0;

  do
  {
    if(line_index &gt;= start_page_line)
    {
      Glib::RefPtr&lt;Pango::LayoutLine&gt; layout_line = iter.get_line();
      Pango::Rectangle logical_rect = iter.get_line_logical_extents();
      int baseline = iter.get_baseline();

      if (line_index == start_page_line)
      {
        start_pos = logical_rect.get_y() / 1024.0;
      }

      cairo_ctx-&gt;move_to(logical_rect.get_x() / 1024.0,
        baseline / 1024.0 - start_pos);

      layout_line-&gt;show_in_cairo_context(cairo_ctx);
    }

    line_index++;
  }
  while(line_index &lt; end_page_line &amp;&amp; iter.next_line());
}

</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include "printformoperation.h"

#include &lt;iostream&gt;

#include &lt;pangomm.h&gt;

const Glib::ustring app_title = "gtkmm Printing Example";

ExampleWindow::ExampleWindow()
  :
  m_Table(3, 2),
  m_NameLabel("Name"),
  m_SurnameLabel("Surname"),
  m_CommentsLabel("Comments")
{
  m_refPageSetup = Gtk::PageSetup::create();
  m_refSettings = Gtk::PrintSettings::create();

  m_ContextId = m_Statusbar.get_context_id(app_title);

  set_title(app_title);
  set_default_size(400, 300);

  add(m_VBox);

  build_main_menu();

  m_VBox.pack_start(m_Table);

  //Arrange the widgets inside the table:
  m_Table.attach(m_NameLabel, 0, 1, 0, 1);
  m_Table.attach(m_NameEntry, 1, 2, 0, 1);

  m_Table.attach(m_SurnameLabel, 0, 1, 1, 2, Gtk::SHRINK);
  m_Table.attach(m_SurnameEntry, 1, 2, 1, 2);

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

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

  m_Table.attach(m_CommentsLabel, 0, 1, 2, 3, Gtk::SHRINK);
  m_Table.attach(m_ScrolledWindow, 1, 2, 2, 3);

  m_refTextBuffer = Gtk::TextBuffer::create();
  m_TextView.set_buffer(m_refTextBuffer);

  m_VBox.pack_start(m_Statusbar);

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::build_main_menu()
{
  //Create actions for menus and toolbars:
  m_refActionGroup = Gtk::ActionGroup::create();

  //File menu:
  m_refActionGroup-&gt;add(
    Gtk::Action::create("FileMenu", "_File"));

  m_refActionGroup-&gt;add(
    Gtk::Action::create("New", Gtk::Stock::NEW),
    sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_new));

  m_refActionGroup-&gt;add(
    Gtk::Action::create("PageSetup", "Page _Setup"),
    sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_page_setup));

  m_refActionGroup-&gt;add(
    Gtk::Action::create("PrintPreview", "Print Preview"),
    sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_print_preview));

  m_refActionGroup-&gt;add(
    Gtk::Action::create("Print", Gtk::Stock::PRINT),
    sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_print));

  m_refActionGroup-&gt;add(
    Gtk::Action::create("Quit", Gtk::Stock::QUIT),
    sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_quit));

  m_refUIManager = Gtk::UIManager::create();
  m_refUIManager-&gt;insert_action_group(m_refActionGroup);

  add_accel_group(m_refUIManager-&gt;get_accel_group());

  //Layout the actions in a menubar and toolbar:

  Glib::ustring ui_info =
        "&lt;ui&gt;"
        "  &lt;menubar name='MenuBar'&gt;"
        "    &lt;menu action='FileMenu'&gt;"
        "      &lt;menuitem action='New'/&gt;"
        "      &lt;menuitem action='PageSetup'/&gt;"
        "      &lt;menuitem action='PrintPreview'/&gt;"
        "      &lt;menuitem action='Print'/&gt;"
        "      &lt;separator/&gt;"
        "      &lt;menuitem action='Quit'/&gt;"
        "    &lt;/menu&gt;"
        "  &lt;/menubar&gt;"
        "  &lt;toolbar  name='ToolBar'&gt;"
        "    &lt;toolitem action='New'/&gt;"
        "    &lt;toolitem action='Print'/&gt;"
        "      &lt;separator/&gt;"
        "    &lt;toolitem action='Quit'/&gt;"
        "  &lt;/toolbar&gt;"
        "&lt;/ui&gt;";

  try
  {
    m_refUIManager-&gt;add_ui_from_string(ui_info);
  }
  catch(const Glib::Error&amp; ex)
  {
    std::cerr &lt;&lt; "building menus failed: " &lt;&lt; ex.what();
  }

  //Get the menubar and toolbar widgets, and add them to a container widget:
  Gtk::Widget* pMenubar = m_refUIManager-&gt;get_widget("/MenuBar");
  if(pMenubar)
    m_VBox.pack_start(*pMenubar, Gtk::PACK_SHRINK);

  Gtk::Widget* pToolbar = m_refUIManager-&gt;get_widget("/ToolBar") ;
  if(pToolbar)
    m_VBox.pack_start(*pToolbar, Gtk::PACK_SHRINK);
}

void ExampleWindow::on_printoperation_status_changed(
        const Glib::RefPtr&lt;PrintFormOperation&gt;&amp; operation)
{
  Glib::ustring status_msg;

  if (operation-&gt;is_finished())
  {
    status_msg = "Print job completed.";
  }
  else
  {
    //You could also use get_status().
    status_msg = operation-&gt;get_status_string();
  }

  m_Statusbar.push(status_msg, m_ContextId);
}

void ExampleWindow::on_printoperation_done(Gtk::PrintOperationResult result,
        const Glib::RefPtr&lt;PrintFormOperation&gt;&amp; operation)
{
  //Printing is "done" when the print data is spooled.

  if (result == Gtk::PRINT_OPERATION_RESULT_ERROR)
  {
    Gtk::MessageDialog err_dialog(*this, "Error printing form", false,
            Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
    err_dialog.run();
  }
  else if (result == Gtk::PRINT_OPERATION_RESULT_APPLY)
  {
    //Update PrintSettings with the ones used in this PrintOperation:
    m_refSettings = operation-&gt;get_print_settings();
  }

  if (! operation-&gt;is_finished())
  {
    //We will connect to the status-changed signal to track status
    //and update a status bar. In addition, you can, for example,
    //keep a list of active print operations, or provide a progress dialog.
    operation-&gt;signal_status_changed().connect(sigc::bind(sigc::mem_fun(*this,
                    &amp;ExampleWindow::on_printoperation_status_changed),
                operation));
  }
}

void ExampleWindow::print_or_preview(Gtk::PrintOperationAction print_action)
{
  //Create a new PrintOperation with our PageSetup and PrintSettings:
  //(We use our derived PrintOperation class)
  Glib::RefPtr&lt;PrintFormOperation&gt; print = PrintFormOperation::create();

  print-&gt;set_name(m_NameEntry.get_text() + " " + m_SurnameEntry.get_text());
  print-&gt;set_comments(m_refTextBuffer-&gt;get_text(false /*Don't include hidden*/));

  print-&gt;set_track_print_status();
  print-&gt;set_default_page_setup(m_refPageSetup);
  print-&gt;set_print_settings(m_refSettings);

  print-&gt;signal_done().connect(sigc::bind(sigc::mem_fun(*this,
                  &amp;ExampleWindow::on_printoperation_done), print));
  try
  {
    print-&gt;run(print_action /* print or preview */, *this);
  }
  catch (const Gtk::PrintError&amp; ex)
  {
    //See documentation for exact Gtk::PrintError error codes.
    std::cerr &lt;&lt; "An error occurred while trying to run a print operation:"
        &lt;&lt; ex.what() &lt;&lt; std::endl;
  }
}

void ExampleWindow::on_menu_file_new()
{
  //Clear entries and textview:
  m_NameEntry.set_text("");
  m_SurnameEntry.set_text("");
  m_refTextBuffer-&gt;set_text("");
  m_TextView.set_buffer(m_refTextBuffer);
}

void ExampleWindow::on_menu_file_page_setup()
{
  //Show the page setup dialog, asking it to start with the existing settings:
  Glib::RefPtr&lt;Gtk::PageSetup&gt; new_page_setup =
      Gtk::run_page_setup_dialog(*this, m_refPageSetup, m_refSettings);

  //Save the chosen page setup dialog for use when printing, previewing, or
  //showing the page setup dialog again:
  m_refPageSetup = new_page_setup;
}

void ExampleWindow::on_menu_file_print_preview()
{
  print_or_preview(Gtk::PRINT_OPERATION_ACTION_PREVIEW);
}

void ExampleWindow::on_menu_file_print()
{
  print_or_preview(Gtk::PRINT_OPERATION_ACTION_PRINT_DIALOG);
}

void ExampleWindow::on_menu_file_quit()
{
  hide();
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

</sect1>

</chapter>

<chapter id="chapter-recent-documents">
  <title>Documents récents</title>

  <para><application>gtkmm</application> fournit un moyen simple pour gérer les documents récemment utilisés. Les classes impliquées dans cette fonctionnalité sont <classname>RecentManager</classname>, <classname>RecentChooserDialog</classname>, <classname>RecentChooserMenu</classname>, <classname>RecentChooserWidget</classname> et <classname>RecentFilter</classname>.</para>
  <para>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.</para>
  <sect1 id="sec-recentmanager">
    <title>La classe RecentManager</title>
    <para>La classe <classname>RecentManager</classname> joue le rôle de base de donnée centrale des fichiers récemment utilisés. Vous utilisez cette classe pour enregistrer de nouveaux fichiers, enlever des fichiers de la liste ou rechercher les fichiers récemment utilisés.</para>
    <para>Il est possible de créer une nouvelle classe <classname>RecentManager</classname>, 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 <methodname>get_default()</methodname>.</para>
    <sect2 id="recent-files-adding">
      <title>Ajout d'éléments à la liste des fichiers récents</title>
      <para>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 :</para>
      <programlisting>Glib::RefPtr&lt;Gtk::RecentManager&gt; recent_manager = Gtk::RecentManager::get_default();
recent_manager-&gt;add_item(uri);</programlisting>
      <para>Si vous voulez enregistrer un fichier avec ses métadonnées, passez un paramètre <classname>RecentManager::Data</classname> à la fonction membre <methodname>add_item()</methodname>. Les métadonnées pouvant être définies sur un élément fichier donné sont :</para>
      <itemizedlist>
        <listitem>
          <para><varname>app_exec</varname> : 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.</para>
        </listitem>
        <listitem>
          <para><varname>app_name</varname> : le nom de l'application qui a enregistré la ressource.</para>
        </listitem>
        <listitem>
          <para><varname>description</varname> : une courte description de la ressource sous forme d'une chaîne UTF-8.</para>
        </listitem>
        <listitem>
          <para><varname>display_name</varname> : le nom de la ressource à utiliser pour l'affichage sous forme d'une chaîne UTF-8.</para>
        </listitem>
        <listitem>
          <para><varname>groups</varname> : 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.</para>
        </listitem>
        <listitem>
          <para><varname>is_private</varname> : indique si la ressource ne doit être visible que des applications qui l'ont enregistrée ou non.</para>
        </listitem>
        <listitem>
          <para><varname>mime_type</varname> : le type MIME de la ressource.</para>
        </listitem>
      </itemizedlist>
      <para>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.</para>
    </sect2>
    <sect2 id="recent-files-lookup">
      <title>Examen des éléments de la liste des fichiers récents</title>
      <para>Pour chercher les fichiers récemment utilisés, <classname>RecentManager</classname> dispose de plusieurs fonctions. Pour chercher un élément donné par son URI, utilisez la fonction <methodname>lookup_item()</methodname> qui renvoie un objet de la classe <classname>RecentInfo</classname>. Si l'URI indiqué n'existe pas dans la liste des fichiers récents, l'objet <classname>RecentInfo</classname> sera non valide. <classname>RecentInfo</classname> implémente <methodname>operator bool()</methodname> que vous pouvez utiliser pour tester la validité. Par exemple :</para>
<programlisting>Gtk::RecentInfo info = recent_manager-&gt;lookup_item(uri);
if (info)
{
  // l'élément a été trouvé
}</programlisting>
      <para>Un objet <classname>RecentInfo</classname> est essentiellement un objet contenant toutes les métadonnées à propos d'un seul fichier récemment utilisé. Vous pouvez utiliser cet objet pour chercher l'une quelconque des propriétés listées ci-dessus. FIXME — ajouter les références croisées.</para>
      <para>Si vous ne voulez pas rechercher un URI donné, mais au lieu de cela, voulez obtenir la liste de tous les éléments récemment utilisés, <classname>RecentManager</classname> dispose de la fonction <methodname>get_items()</methodname>. La valeur renvoyée peut être assignée à n'importe quel conteneur standard C++ (par exemple, <classname>std::vector</classname>, <classname>std::list</classname>, etc) ; elle contient la liste de tous les fichiers récemment utilisés jusqu'à la limite indiquée par l'utilisateur [FIXME : quelle est la limite par défaut ?]. Le code ci-après montre comment obtenir une liste des fichiers récemment utilisés :</para>
      <programlisting>std::vector&lt;Gtk::RecentInfo&gt; info_list = recent_manager-&gt;get_items();</programlisting>
      <para>La fonction membre <methodname>set_limit()</methodname> fixe le nombre limite d'éléments renvoyés ; <methodname>get_limit()</methodname> permet d'en prendre connaissance.</para>
    </sect2>
    <sect2 id="recent-files-modifying">
      <title>Modification de la liste des fichiers récents</title>
      <para>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 <methodname>move_item()</methodname>.</para>
      <para>En plus de modifier l'URI d'un fichier, vous pouvez enlever des éléments de la liste, soit un à un, soit tous à la fois. La première opération s'effectue avec <methodname>remove_item()</methodname>, la dernière avec <methodname>purge_items()</methodname>.</para>
      <note>
        <para>Les fonctions <methodname>move_item()</methodname>, <methodname>remove_item()</methodname> et <methodname>purge_items()</methodname> n'ont aucun effet concret sur les fichiers auxquels les URI se référent ; elles ne font que modifier la liste.</para>
      </note>
    </sect2>
  </sect1>

  <sect1 id="sec-recentchooser">
    <title>La classe RecentChooser</title>
    <para><classname>RecentChooser</classname> est une interface pouvant être implémentée par les éléments graphiques affichant la liste des fichiers récemment utilisés. <application>gtkmm</application> met à votre disposition trois implémentations intégrées pour le choix des fichiers récents : <classname>RecentChooserWidget</classname>, <classname>RecentChooserDialog</classname> et <classname>RecentChooserMenu</classname>.</para>
    <para><classname>RecentChooserWidget</classname> est un simple élément graphique pour un affichage de la liste des fichiers récemment utilisés. <classname>RecentChooserWidget</classname> est l'élément de base de la classe <classname>RecentChooserDialog</classname>, mais vous pouvez l'incorporer dans votre interface utilisateur si vous le souhaitez.</para>
    <para>La dernière classe implémentant l'interface <classname>RecentChooser</classname> est <classname>RecentChooserMenu</classname>. Cette classe vous permet de lister les fichiers récemment utilisés comme un menu.</para>
    <sect2 id="recenchooserwidget-example">
      <title>Exemple simple de l'utilisation de RecentChooserWidget</title>
      <para>Voici un exemple simple sur la manière d'utiliser la classe <classname>RecentChooserDialog</classname> dans un programme. Ce programme élémentaire a une barre de menus avec un élément de menu « Boîte de dialogue fichiers récents ». Quand vous choisissez cet élément de menu, une boîte apparaît : elle affiche les fichiers récemment utilisés.</para>
      <note>
        <para>À 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.</para>
      </note>
      <para>Après avoir sélectionné l'élément de menu <guimenuitem>Boîte de dialogue fichiers récents</guimenuitem>, vous voyez quelque chose de semblable à la fenêtre ci-après.</para>
      <screenshot>
          <graphic format="PNG" fileref="figures/recentchooserdialog.png"/>
      </screenshot>
<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/recent_files?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;

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

protected:
  //Signal handlers:
  void on_menu_file_recent_files_dialog();
  void on_menu_file_quit();
  void on_menu_file_new();

  //Child widgets:
  Gtk::VBox m_Box;

  Glib::RefPtr&lt;Gtk::UIManager&gt; m_refUIManager;
  Glib::RefPtr&lt;Gtk::ActionGroup&gt; m_refActionGroup;

  Glib::RefPtr&lt;Gtk::RecentManager&gt; m_refRecentManager;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/stock.h&gt;
#include &lt;iostream&gt;

ExampleWindow::ExampleWindow()
: m_refRecentManager(Gtk::RecentManager::get_default())
{
  set_title("recent files example");
  set_default_size(200, 200);

  //We can put a MenuBar at the top of the box and other stuff below it.
  add(m_Box);

  //Create actions for menus and toolbars:
  m_refActionGroup = Gtk::ActionGroup::create();

  //File menu:
  m_refActionGroup-&gt;add( Gtk::Action::create("FileMenu", "_File") );
  m_refActionGroup-&gt;add( Gtk::Action::create("FileNew", Gtk::Stock::NEW),
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_new));

  /* A recent-files sub-menu: */
  //TODO: Shouldn't this have a default constructor?: 
  //See bug #450032.
  //m_refActionGroup-&gt;add( Gtk::RecentAction::create() );
  m_refActionGroup-&gt;add( Gtk::RecentAction::create("FileRecentFiles",
              "_Recent Files"));

  /* A menu item to open the recent-files dialog: */
  m_refActionGroup-&gt;add( Gtk::Action::create("FileRecentDialog",
              "Recent Files _Dialog"), sigc::mem_fun(*this,
                  &amp;ExampleWindow::on_menu_file_recent_files_dialog) );

  m_refActionGroup-&gt;add( Gtk::Action::create("FileQuit", Gtk::Stock::QUIT),
          sigc::mem_fun(*this, &amp;ExampleWindow::on_menu_file_quit) );


  m_refUIManager = Gtk::UIManager::create();
  m_refUIManager-&gt;insert_action_group(m_refActionGroup);

  add_accel_group(m_refUIManager-&gt;get_accel_group());

  //Layout the actions in a menubar and toolbar:
  Glib::ustring ui_info =
        "&lt;ui&gt;"
        "  &lt;menubar name='MenuBar'&gt;"
        "    &lt;menu action='FileMenu'&gt;"
        "      &lt;menuitem action='FileNew'/&gt;"
        "      &lt;menuitem action='FileRecentFiles'/&gt;"
        "      &lt;menuitem action='FileRecentDialog'/&gt;"
        "      &lt;separator/&gt;"
        "      &lt;menuitem action='FileQuit'/&gt;"
        "    &lt;/menu&gt;"
        "  &lt;/menubar&gt;"
        "  &lt;toolbar  name='ToolBar'&gt;"
        "    &lt;toolitem action='FileNew'/&gt;"
        "    &lt;toolitem action='FileQuit'/&gt;"
        "  &lt;/toolbar&gt;"
        "&lt;/ui&gt;";

  try
  {
    m_refUIManager-&gt;add_ui_from_string(ui_info);
  }
  catch(const Glib::Error&amp; ex)
  {
    std::cerr &lt;&lt; "building menus failed: " &lt;&lt;  ex.what();
  }

  //Get the menubar and toolbar widgets, and add them to a container widget:
  Gtk::Widget* pMenubar = m_refUIManager-&gt;get_widget("/MenuBar");
  if(pMenubar)
    m_Box.pack_start(*pMenubar, Gtk::PACK_SHRINK);

  Gtk::Widget* pToolbar = m_refUIManager-&gt;get_widget("/ToolBar") ;
  if(pToolbar)
    m_Box.pack_start(*pToolbar, Gtk::PACK_SHRINK);

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_menu_file_new()
{
    std::cout &lt;&lt; " New File" &lt;&lt; std::endl;
}

void ExampleWindow::on_menu_file_quit()
{
  hide(); //Closes the main window to stop the Gtk::Main::run().
}

void ExampleWindow::on_menu_file_recent_files_dialog()
{
  Gtk::RecentChooserDialog dialog(*this, "Recent Files", m_refRecentManager);
  dialog.add_button("Select File", Gtk::RESPONSE_OK);
  dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);

  const int response = dialog.run();
  dialog.hide();
  if(response == Gtk::RESPONSE_OK)
  {
     std::cout &lt;&lt; "URI selected = " &lt;&lt; dialog.get_current_uri() &lt;&lt; std::endl;
  }
}

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->
      <para>Le constructeur de <classname>ExampleWindow</classname> crée le menu en utilisant <classname>UIManager</classname> (consultez le <xref linkend="chapter-menus-and-toolbars"/> pour plus d'informations). Ensuite il ajoute le menu et la barre d'outils à la fenêtre.</para>
    </sect2>
    <sect2 id="recent-files-filtering">
      <title>Filtrage des fichiers récents</title>
      <para>Pour chacune des classes <classname>RecentChooser</classname>, si vous ne souhaitez pas afficher tous les éléments de la liste des fichiers récents, vous pouvez filtrer la liste pour ne montrer que ce que vous souhaitez. Vous pouvez filtrer la liste avec l'aide de la classe <classname>RecentFilter</classname>. Cette classe vous permet de filtrer les fichiers par le nom (<methodname>add_pattern()</methodname>), leur type MIME (<methodname>add_mime_type()</methodname>), l'application qui les a enregistrés (<methodname>add_application()</methodname>) ou par une fonction de filtrage personnalisée (<methodname>add_custom()</methodname>). Elle offre aussi la possibilité de filtrer sur la date de dernière modification et sur les groupes dont le fichier fait partie.</para>
      <para>Après avoir créé et réglé le filtre pour qu'il corresponde uniquement aux fichiers souhaités, vous pouvez appliquer le filtre à l'élément graphique de sélection avec la fonction <methodname>RecentChooser::add_filter()</methodname>.</para>
    </sect2>
  </sect1>
</chapter>

<chapter id="chapter-plugs-sockets">
  <title>Greffons et connecteurs</title>
  <sect1 id="sec-plugs-sockets-overview">
    <title>Aperçu</title>
    <para>Parfois, il peut se révéler utile de pouvoir incorporer un élément graphique d'une autre application dans votre propre application. <application>gtkmm</application> permet cela grâce aux classes <classname>Gtk::Socket</classname> et <classname>Gtk::Plug</classname>. Il est peu vraisemblable que beaucoup d'applications aient besoin de cette fonctionnalité, mais dans les rares cas où vous auriez besoin d'afficher un élément graphique fonctionnant dans un processus tout à fait différent, ces classes peuvent être d'une grande aide.</para>
    <para>La communication entre un objet <classname>Socket</classname> et un objet <classname>Plug</classname> s'effectue suivant le protocole XEmbed. Ce protocole a aussi été implémenté dans d'autres boîtes à outils (par exemple, Qt) ; cela permet un niveau d'intégration identique lorsqu'on incorpore un élément graphique Qt dans GTK+ ou vice versa.</para>
    <para>Les <classname>Sockets</classname> et <classname>Plugs</classname> collaborent par l'intermédiaire des identifiants de leurs fenêtres. Un objet <classname>Socket</classname> et un objet <classname>Plug</classname> ont tous deux des ID que l'on peut retrouver avec leurs fonctions membres <methodname>get_id()</methodname>. L'utilisation de ces ID sera explicitée plus bas dans la <xref linkend="sec-connecting-plugs-sockets"/>.</para>
    <sect2 id="sec-sockets">
      <title>Connecteurs</title>
      <para>Un objet <classname>Socket</classname> est une sorte d'élément graphique conteneur spécial qui autorise la possibilité d'incorporer des éléments graphiques d'un processus dans un autre de manière totalement transparente pour l'utilisateur.</para>
    </sect2>
    <sect2 id="sec-plugs">
      <title>Greffons</title>
      <para>Un objet <classname>Plug</classname> est une variété de fenêtre particulière qu'il est possible de greffer dans un objet <classname>Socket</classname>. Outre les propriétés et les fonctions membres habituelles de la classe <classname>Gtk::Window</classname>, l'objet <classname>Plug</classname> fournit un constructeur qui prend comme paramètre l'ID d'un objet <classname>Socket</classname> ; l'objet <classname>Plug</classname> va automatiquement s'incorporer dans l'objet <classname>Socket</classname> qui a l'ID correspondant.</para>
      <para>Comme un objet <classname>Plug</classname> n'est qu'un type spécial de classe <classname>Gtk::Window</classname>, vous pouvez lui ajouter des conteneurs ou des éléments graphiques exactement comme vous auriez fait pour une autre fenêtre.</para>
    </sect2>
    <sect2 id="sec-connecting-plugs-sockets">
      <title>Branchement des greffons et des connecteurs</title>
      <para>Après la création d'objets <classname>Socket</classname> ou <classname>Plug</classname>, vous pouvez obtenir leur ID avec la fonction <methodname>get_id()</methodname>. Cet ID peut ensuite être partagé avec d'autres processus afin que ces processus sachent comment se connecter les uns aux autres.</para>
      <para>Il y a deux stratégies de base utilisables : <itemizedlist>
          <listitem>
            <para>créer un objet <classname>Socket</classname> dans un processus et passer l'ID de ce <classname>Socket</classname> à un autre processus pour qu'il puisse créer un objet <classname>Plug</classname> en précisant ledit ID du <classname>Socket</classname> dans son constructeur. Il n'est pas possible d'attribuer un <classname>Plug</classname> à un <classname>Socket</classname> après sa création, il faut donc transmettre l'ID du <classname>Socket</classname> au constructeur du <classname>Plug</classname>.</para>
          </listitem>
          <listitem>
            <para>créer un objet <classname>Plug</classname> de manière indépendante de tout <classname>Socket</classname> particulier et passer l'ID du <classname>Plug</classname> aux processus qui souhaitent l'utiliser. L'ID de l'objet <classname>Plug</classname> peut être associé à un objet <classname>Socket</classname> donné avec la fonction <methodname>Socket::add_id()</methodname>. C'est l'approche utilisée dans l'exemple qui suit.</para>
          </listitem>
        </itemizedlist></para>
    </sect2>
  </sect1>
  <sect1 id="sec-plugs-sockets-example">
    <title>Exemple greffons et connecteurs</title>
    <para>L'exemple suivant est une utilisation simple de greffons et connecteurs. La fonction membre de communication entre processus est volontairement sommaire : l'objet <classname>Plug</classname> écrit son ID dans un fichier texte nommé <filename>plug.id</filename> et le processus avec le connecteur lit cet ID à partir de ce fichier. Dans un « vrai » programme, vous utiliseriez certainement des fonctions membres de communication entre processus plus perfectionnées.</para>
<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/socket/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>socket.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include &lt;fstream&gt;
#include &lt;gtkmm.h&gt;
#include &lt;gtkmm/socket.h&gt;

using namespace std;

const char* id_filename = "plug.id";

void plug_added()
{
  cout &lt;&lt; "A plug was added" &lt;&lt; endl;
}

bool plug_removed()
{
  cout &lt;&lt; "A Plug was removed" &lt;&lt; endl;
  return true;
}

class MySocketWindow : public Gtk::Window
{
  public:
    MySocketWindow()
    {
      ifstream infile(id_filename);
      if (infile)
      {
        Gtk::Socket* socket = Gtk::manage(new Gtk::Socket());
        add(*socket);
        socket-&gt;signal_plug_added().connect(sigc::ptr_fun(plug_added));
        socket-&gt;signal_plug_removed().connect(sigc::ptr_fun(plug_removed));
        ::Window plug_id = 0;
        infile &gt;&gt; plug_id;
        infile.close();
        socket-&gt;add_id(plug_id);
      }
      else
      {
        Gtk::Label* label = Gtk::manage(
            new Gtk::Label(
              "Plug id file not found.\n Make sure plug is running."));
        add(*label);
        set_size_request(150, 50);
      }
      show_all();
    }
};

int main(int argc, char** argv)
{
  Gtk::Main app(argc, argv);
  MySocketWindow win;
  app.run(win);
  return 0;
}
</programlisting>
<para>File: <filename>plug.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include &lt;fstream&gt;
#include &lt;gtkmm.h&gt;
#include &lt;gtkmm/plug.h&gt;
#include &lt;glib/gstdio.h&gt;

using namespace std;

const char* id_filename = "plug.id";

void on_embed()
{
  cout &lt;&lt; "I've been embedded." &lt;&lt; endl;
}

class MyPlug : public Gtk::Plug
{
  public:
    MyPlug() :
      m_label("I am the plug")
  {
    set_size_request(150, 100);
    add(m_label);
    signal_embedded().connect(sigc::ptr_fun(on_embed));
    show_all();
  }

  private:
    Gtk::Label m_label;
};


int main(int argc, char** argv)
{
  Gtk::Main app(argc, argv);
  MyPlug plug;

  ofstream out(id_filename);
  out &lt;&lt; plug.get_id();
  out.close();
  cout &lt;&lt; "The window ID is: " &lt;&lt; plug.get_id() &lt;&lt; endl;

  app.run(plug);

  // remove the ID file when the program exits
  g_remove(id_filename);
  return 0;
}
</programlisting>
<!-- end inserted example code -->
    <para>Cet exemple crée deux exécutables : <filename>socket</filename> et <filename>plug</filename>. L'idée est que <filename>socket</filename> ait une fenêtre d'application qui accueille un élément graphique issu du programme <filename>plug</filename>. Compte tenu de la manière dont cet exemple est conçu, <filename>plug</filename> doit être lancé avant que <filename>socket</filename> ne démarre. Pour voir cet exemple en action, exécutez les commandes suivantes dans l'ordre indiqué à partir du répertoire de l'exemple :</para>
    <para>Lancez le programme <filename>plug</filename> et envoyez-le en arrière-plan (ou simplement utilisez un terminal différent) :</para>
    <screen>$ ./plug &amp;</screen>
    <para>Après cette action, vous devriez voir s'afficher :</para>
    <screen>The window ID is: 69206019</screen>
    <para>puis lancez le programme <filename>socket</filename> :</para>
    <screen>$ ./socket</screen>
    <para>Après avoir lancé <filename>socket</filename>, vous devriez voir les sorties suivantes sur le terminal :</para>
    <screen>I've been embedded.
A plug was added</screen>
    <para>La première ligne correspond à la sortie du programme <filename>plug</filename>, après qu'il a reçu notification qu'il a été incorporé dans l'objet <classname>Socket</classname>. La deuxième ligne a été émise par l'objet <filename>socket</filename> en réponse au signal <methodname>plug_added</methodname>. Si tout a été effectuée comme indiqué ci-dessus, la fenêtre <filename>socket</filename> doit ressembler grosso modo à quelque chose comme :</para>
    <screenshot>
      <graphic format="PNG" fileref="figures/socket.png"/>
    </screenshot>
    <para>Si, pour une quelconque raison, l'objet <classname>Socket</classname> ne peut pas recevoir l'objet <classname>Plug</classname>, la fenêtre ressemblera à :</para>
    <screenshot>
      <graphic format="PNG" fileref="figures/socket-fail.png"/>
    </screenshot>
  </sect1>
</chapter>

<chapter id="chapter-chapter-timeouts">
<title>Fonctions à délai échu, d'entrées/sorties et de temporisation</title>

<sect1 id="sec-timeouts">
<title>Fonctions à délai échu</title>

<para>Peut-être vous demandez-vous comment faire en sorte que <application>gtkmm</application> fasse un travail utile pendant sa période d'inactivité (disons, de sommeil en fait) dans la boucle <methodname>Gtk::Main::run()</methodname>. Il y a heureusement plusieurs possibilités pour cela. En utilisant les fonctions membres suivantes, vous pouvez créer une fonction à délai échu ; elle sera régulièrement appelée avec une périodicité de quelques millisecondes.</para>

<para>
<programlisting>
sigc::connection Glib::SignalTimeout::connect(
                         const sigc::slot&lt;bool&gt;&amp; slot,
                         unsigned int interval,
                         int priority = Glib::PRIORITY_DEFAULT);
</programlisting>
</para>

<para>Le premier paramètre est un objet <classname>slot</classname> 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 <classname>sigc::connection</classname> qu'il est possible d'utiliser pour désactiver la connexion à l'aide de sa fonction membre <methodname>disconnect()</methodname> :</para>

<para>

<programlisting>
my_connection.disconnect();
</programlisting>
</para>

<para>L'autre façon d'interrompre la connexion est fournie par le gestionnaire de signal qui doit être du type <classname>sigc::slot&lt;bool&gt;</classname>.Comme vous le voyez dans la définition, le gestionnaire de signal doit renvoyer une valeur du type <literal>bool</literal>. Une définition d'une fonction exemple pourrait ressembler à quelque chose comme : <programlisting>
bool MyCallback() { std::cout &lt;&lt; "Hello World!\n" &lt;&lt; std::endl; return true; }
</programlisting></para>

<para>Vous pouvez arrêter l'appel périodique de la fonction en renvoyant <literal>false</literal> à partir du gestionnaire de signal. Mais si vous voulez que la fonction soit réitérée, il faut qu'elle renvoie <literal>true</literal>.</para>

<para>Voici un exemple de cette technique :</para>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/timeout/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>timerexample.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_TIMEREXAMPLE_H
#define GTKMM_EXAMPLE_TIMEREXAMPLE_H

#include &lt;gtkmm.h&gt;
#include &lt;iostream&gt;
#include &lt;map&gt;

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::HBox 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&lt;int, sigc::connection&gt; 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&lt;int, int&gt; m_counters;
};

#endif // GTKMM_EXAMPLE_TIMEREXAMPLE_H
</programlisting>
<para>File: <filename>timerexample.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "timerexample.h"

TimerExample::TimerExample() :
  m_Box(true, 10),
    // use Gtk::Stock wherever possible for buttons, etc.
  m_ButtonAddTimer(Gtk::Stock::ADD),
  m_ButtonDeleteTimer(Gtk::Stock::REMOVE),
  m_ButtonQuit(Gtk::Stock::QUIT),
  m_timer_number(0), // start numbering the timers at 0
  count_value(5), // each timer will count down 5 times before disconnecting
  timeout_value(1500) // 1500 ms = 1.5 seconds
{
  set_border_width(10);

  add(m_Box);
  m_Box.pack_start(m_ButtonAddTimer);
  m_Box.pack_start(m_ButtonDeleteTimer);
  m_Box.pack_start(m_ButtonQuit);

  // Connect the three buttons:
  m_ButtonQuit.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;TimerExample::on_button_quit));
  m_ButtonAddTimer.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;TimerExample::on_button_add_timer));
  m_ButtonDeleteTimer.signal_clicked().connect(sigc::mem_fun(*this,
              &amp;TimerExample::on_button_delete_timer));

  show_all_children();
}

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

void TimerExample::on_button_add_timer()
{
  // Creation of a new object prevents long lines and shows us a little
  // how slots work.  We have 0 parameters and bool as a return value
  // after calling sigc::bind.
  sigc::slot&lt;bool&gt; my_slot = sigc::bind(sigc::mem_fun(*this,
              &amp;TimerExample::on_timeout), m_timer_number);

  // This is where we connect the slot to the Glib::signal_timeout()
  sigc::connection conn = Glib::signal_timeout().connect(my_slot,
          timeout_value);

  // Remember the connection:
  m_timers[m_timer_number] = conn;

  // Initialize timer count:
  m_counters[m_timer_number] = count_value + 1;

  // Print some info to the console for the user:
  std::cout &lt;&lt; "added timeout " &lt;&lt; m_timer_number++ &lt;&lt; std::endl;
}

void TimerExample::on_button_delete_timer()
{
  // any timers?
  if(m_timers.empty())
  {
    // no timers left
    std::cout &lt;&lt; "Sorry, there are no timers left." &lt;&lt; std::endl;
  }
  else
  {
    // get the number of the first timer
    int timer_number = m_timers.begin()-&gt;first;

    // Give some info to the user:
    std::cout &lt;&lt; "manually disconnecting timer " &lt;&lt; timer_number
        &lt;&lt; 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 &lt;&lt; "This is timer " &lt;&lt; timer_number;

  // decrement and check counter value
  if (--m_counters[timer_number] == 0)
  {
    std::cout &lt;&lt; " being disconnected" &lt;&lt;  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 &lt;&lt; " - " &lt;&lt; m_counters[timer_number] &lt;&lt; "/"
      &lt;&lt; count_value &lt;&lt; std::endl;

 // Keep going (do not disconnect yet):
  return true;
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "timerexample.h"
#include &lt;gtkmm/main.h&gt;

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

  TimerExample example;
  Gtk::Main::run(example);

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect1>

<sect1 id="sec-monitoring-io">
<title>Fonctions de contrôle des entrées/sorties</title>

<para>Une des caractéristiques intéressantes de GLib (une des bibliothèques sous-jacentes à <application>gtkmm</application>) 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 :</para>

<para>
<programlisting>
sigc::connection Glib::SignalInput::connect(
             const sigc::slot&lt;bool,Glib::IOCondition&gt;&amp; slot,
             int fd,
             Glib::IOCondition condition,
             int priority = Glib::PRIORITY_DEFAULT);
</programlisting>
</para>

<para>Le premier paramètre est un connecteur qui est sollicité quand survient, sur le descripteur de fichier précisé en second paramètre, l'événement indiqué en troisième paramètre. Ce dernier définit une valeur ou plusieurs (liées avec <literal>|</literal>) parmi les suivantes :</para>

<itemizedlist>
<listitem>

<para>Glib::IO_IN - appelle la fonction membre quand il y a des données prêtes en lecture dans le descripteur de fichier.</para>
</listitem>
<listitem>

<para>Glib::IO_OUT - appelle la fonction membre quand le descripteur de fichier est prêt pour l'écriture.</para>
</listitem>
<listitem>

<para>Glib::IO_PRI - appelle la fonction membre quand le descripteur de fichier a des données à lire d'urgence.</para>
</listitem>
<listitem>

<para>Glib::IO_ERR - appelle la fonction membre quand une erreur est arrivée sur le descripteur de fichier.</para>
</listitem>
<listitem>

<para>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).</para>
</listitem>

</itemizedlist>

<para>La valeur de retour qui est du type <classname>sigc::connection</classname> peut être utilisée pour arrêter le contrôle sur ce descripteur de fichier avec la fonction membre <methodname>disconnect()</methodname>. Le gestionnaire de signal de <parameter>slot</parameter> doit être déclaré comme suit :</para>

<para>
<programlisting>
bool input_callback(Glib::IOCondition condition);
</programlisting>
</para>

<para>où le paramètre <parameter>condition</parameter> est tel que précisé ci-dessus. Comme d'habitude, le connecteur est créé avec <function>sigc::mem_fun()</function> (pour une fonction membre d'un objet) ou <function>sigc::ptr_fun()</function> (pour une fonction).</para>

<para>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é <literal>testfifo</literal> dans le répertoire actuel. Puis, lancez un autre instance de terminal et saisissez <literal>echo "Hello" &gt; testfifo</literal>. Le terminal de l'exemple affiche chaque ligne saisie dans l'autre instance jusqu'à ce que vous saisissiez <literal>echo "Q" &gt; testfifo</literal>.</para>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/input/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;build/config.h&gt;
#include &lt;gtkmm/main.h&gt;
#include &lt;fcntl.h&gt;
#include &lt;iostream&gt;

#include &lt;unistd.h&gt; //The SUN Forte compiler puts F_OK here.

//The SUN Forte compiler needs these for mkfifo:
#include &lt;sys/types.h&gt;
#include &lt;sys/stat.h&gt;

int read_fd;
Glib::RefPtr&lt;Glib::IOChannel&gt; iochannel;

/*
  send to the fifo with:
  echo "Hello" &gt; testfifo

  quit the program with:
  echo "Q" &gt; 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 &amp; Glib::IO_IN) == 0) {
    std::cerr &lt;&lt; "Invalid fifo response" &lt;&lt; std::endl;
  }
  else {
   Glib::ustring buf;

   iochannel-&gt;read_line(buf);
   std::cout &lt;&lt; buf;
   if (buf == "Q\n")
       Gtk::Main::quit ();

  }
  return true;
}


int main(int argc, char *argv[])
{
  // the usual Gtk::Main object
  Gtk::Main app(argc, argv);

  if (access("testfifo", F_OK) == -1) {
    // fifo doesn't exit - create it
    #ifdef HAVE_MKFIFO
    if (mkfifo("testfifo", 0666) != 0) {
      std::cerr &lt;&lt; "error creating fifo" &lt;&lt; std::endl;
      return -1;
    }
    #else
      std::cerr &lt;&lt; "error creating fifo: This platform does not have mkfifo()"
          &lt;&lt; std::endl;
    #endif //HAVE_MKFIFO
  }

  read_fd = open("testfifo", O_RDONLY);
  if (read_fd == -1)
  {
    std::cerr &lt;&lt; "error opening fifo" &lt;&lt; std::endl;
    return -1;
  }

  // connect the signal handler
  Glib::signal_io().connect(sigc::ptr_fun(MyCallback), read_fd, Glib::IO_IN);

  // Creates a iochannel from the file descriptor
  iochannel = Glib::IOChannel::create_from_fd(read_fd);

  // and last but not least - run the application main loop
  app.run();

  // now remove the temporary fifo
  if(unlink("testfifo"))
    std::cerr &lt;&lt; "error removing fifo" &lt;&lt; std::endl;

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect1>

<sect1 id="sec-idle-functions">
<title>Fonctions de temporisation</title>

<para>Si vous voulez définir une fonction membre appelée quand il n'y aucune autre activité en cours, utilisez :</para>

<para>
<programlisting>
sigc::connection  Glib::SignalIdle::connect(
                      const sigc::slot&lt;bool&gt;&amp; slot,
                      int priority = Glib::PRIORITY_DEFAULT_IDLE);
</programlisting>
</para>

<para>Cela demande à <application>gtkmm</application> 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 <methodname>disconnect()</methodname> sur l'objet <classname>sigc::connection</classname> ou en renvoyant <literal>false</literal> dans le gestionnaire du signal, qui doit être déclaré ainsi :</para>

<para>
<programlisting>
bool idleFunc();
</programlisting>
</para>

<para>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 :</para>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/idle/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>idleexample.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_IDLEEXAMPLE_H
#define GTKMM_EXAMPLE_IDLEEXAMPLE_H

#include &lt;gtkmm.h&gt;
#include &lt;iostream&gt;

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

protected:
  // Signal Handlers:
  bool on_timer();
  bool on_idle();
  void on_button_clicked();

  // Member data:
  Gtk::VBox m_Box;
  Gtk::Button m_ButtonQuit;
  Gtk::ProgressBar m_ProgressBar_c;
  Gtk::ProgressBar m_ProgressBar_d;
};

#endif // GTKMM_EXAMPLE_IDLEEXAMPLE_H
</programlisting>
<para>File: <filename>idleexample.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "idleexample.h"

IdleExample::IdleExample() :
  m_Box(false, 5),
  m_ButtonQuit(Gtk::Stock::QUIT)
{
  set_border_width(5);

  // Put buttons into container

  // Adding a few widgets:
  add(m_Box);
  m_Box.pack_start( *Gtk::manage(new Gtk::Label("Formatting Windows drive C:")));
  m_Box.pack_start( *Gtk::manage(new Gtk::Label("100 MB")) );
  m_Box.pack_start(m_ProgressBar_c);

  m_Box.pack_start( *Gtk::manage(new Gtk::Label("")) );

  m_Box.pack_start( *Gtk::manage(new Gtk::Label("Formatting Windows drive D:")));
  m_Box.pack_start( *Gtk::manage(new Gtk::Label("5000 MB")) );
  m_Box.pack_start(m_ProgressBar_d);

  Gtk::HBox* hbox = Gtk::manage( new Gtk::HBox(false,10));
  m_Box.pack_start(*hbox);
  hbox-&gt;pack_start(m_ButtonQuit, Gtk::PACK_EXPAND_PADDING);

  // Connect the signal handlers:
  m_ButtonQuit.signal_clicked().connect( sigc::mem_fun(*this,
              &amp;IdleExample::on_button_clicked) );

  // formatting drive c in timeout signal handler - called once every 50ms
  Glib::signal_timeout().connect( sigc::mem_fun(*this, &amp;IdleExample::on_timer),
          50 );

  // formatting drive d in idle signal handler - called as quickly as possible
  Glib::signal_idle().connect( sigc::mem_fun(*this, &amp;IdleExample::on_idle) );

  show_all_children();
}


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

// this timer callback function is executed once every 50ms (set in connection
// above).  Use timeouts when speed is not critical. (ie periodically updating
// something).
bool IdleExample::on_timer()
{
  double value = m_ProgressBar_c.get_fraction();

  // Update progressbar 1/500th each time:
  m_ProgressBar_c.set_fraction(value + 0.002);
 
  return value &lt; 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 &lt; 0.99;  // return false when done
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "idleexample.h"
#include &lt;gtkmm/main.h&gt;

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

  IdleExample example;
  Gtk::Main::run(example);

  return 0;
}
</programlisting>
<!-- end inserted example code -->

<para>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.</para>

<para>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.</para>

</sect1>

</chapter>

<chapter id="chapter-memory">
<title>Gestion de la mémoire</title>

<sect1 id="sec-memory-widgets">
<title>Éléments graphiques</title>

<sect2 id="memory-normal">
<title>Gestion classique de la mémoire en C++</title>

<para><application>gtkmm</application> 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 <literal>new</literal> et <literal>delete</literal> 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++.</para>

<para>Voici quelques exemples de gestion traditionnelle de la mémoire en C++ :</para>

<sect3 id="memory-class-scope">
<title>Éléments graphiques à portée de classe</title>

<para>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 <literal>delete</literal> sur un élément graphique.</para>

<para>Les principaux inconvénients proviennent du fait que l'utilisation d'éléments graphiques à portée de classe sont en rapport avec l'implémentation de la classe plus que de son interfaçage dans l'en-tête de classe. Les éléments graphiques à portée de classe sont créés automatiquement et souffrent des mêmes inconvénients que n'importe quelle autre variable automatique à portée de classe.</para>

<para>
<programlisting>
#include &lt;gtkmm/button.h&gt;
class Foo
{
private:
  Gtk::Button theButton;
  // sera détruit en même temps que l'objet Foo
};
</programlisting>
</para>
</sect3>

<sect3 id="memory-function-scope">
<title>Éléments graphiques à portée de fonction</title>

<para>Si un programmeur ne souhaite pas utiliser d'élément graphique à portée de classe, il peut aussi se servir d'éléments graphiques à portée de fonction. Les avantages de la portée de fonction par rapport à la portée de classe sont un masquage accru des données et une réduction des dépendances. <programlisting>
{
  Gtk::Button aButton;
  aButton.show();
  ...
  kit.run();
}
</programlisting></para>
</sect3>

<sect3 id="memory-dynamic-allocation">
<title>Allocation dynamique avec new et delete</title>

<para>Même si, dans la plupart des cas, le programmeur préfére allouer des conteneurs pour détruire automatiquement leur contenu avec la fonction <function>manage()</function> (voir ci-dessous), l'utilisation de cette fonction n'est pas obligatoire. Les opérateurs traditionnels <literal>new</literal> et <literal>delete</literal> peuvent également être utilisés.</para>

<para><programlisting>
Gtk::Button* pButton = new Gtk::Button("Test");

// faire quelque chose d'utile avec pButton

delete pButton;
</programlisting> Ici, le programmeur détruit pButton pour prévenir une fuite de mémoire.</para>
</sect3>

</sect2>

<sect2 id="memory-managed-widgets">
<title>Éléments graphiques gérés</title>

<para>Sinon, vous pouvez confier au conteneur d'élément graphique le contrôle du moment où il sera détruit. Dans la plupart des cas, vous voulez qu'un élément graphique dure aussi longtemps que son conteneur. Pour déléguer la gestion de la durée de vie d'un élément graphique à son conteneur, créez-le avec <function>manage()</function> et empaquetez-le dans son conteneur avec <methodname>add()</methodname>. Ainsi, l'élément graphique sera détruit au moment où son conteneur sera détruit.</para>

<sect3 id="memory-managed-dynamic">
<title>Allocation dynamique avec manage() et add()</title>

<para><application>gtkmm</application> met à votre disposition les fonctions <function>manage()</function> et <methodname>add()</methodname> pour créer et détruire les éléments graphiques. Tout élément graphique, excepté la fenêtre principale, doit être ajouté ou empaqueté dans un conteneur pour être affiché. La fonction <function>manage()</function> marque l'élément graphique empaqueté de sorte que, lorsqu'il est ajouté dans un conteneur, ce conteneur devient responsable de sa destruction.</para>

<para><programlisting>
MyWidget::MyWidget()
{
  Gtk::Button* pButton = manage(new Gtk::Button("Test"));
  add(*pButton); //ajoute aButton à MyWidget
}
</programlisting> Ainsi, quand des objets du type <classname>MyWidget</classname> sont détruits, le bouton est également détruit. Il n'est plus nécessaire à l'avenir de détruire pButton pour libérer la mémoire occupée par le bouton ; cette opération a été déléguée à l'objet <classname>MyWidget</classname>.</para>

<para><application>gtkmm</application> fournit également la fonction membre <methodname>set_manage()</methodname> pour tous les éléments graphiques. Il est possible de l'utiliser pour obtenir le même résultat qu'avec <function>manage()</function>, mais c'est plus délicat :</para>

<para>foo.add( (w=new Gtk::Label("Hello"), w-&gt;set_manage(), &amp;w) );</para>

<para>est équivalent à</para>

<para>foo.add( manage(new Gtk::Label("Hello")) );</para>

<para>Bien entendu, le conteneur de haut niveau n'est pas intégré dans un autre conteneur. Le programmeur est responsable de la destruction du conteneur de haut niveau en utilisant les techniques habituelles du C++. Ainsi, votre fenêtre principale ne peut être qu'une instance dans votre fonction <function>main()</function>.</para>

</sect3>
</sect2>
</sect1>

<sect1 id="sec-memory-shared-resources">
<title>Ressources partagées</title>

<para>Certains objets, tels que les <classname>Gdk::Pixmap</classname> et <classname>Pango::Font</classname>, s'obtiennent à partir d'un stockage partagé. Ainsi, vous ne pouvez pas créer vos propres exemplaires de ces classes. Elles héritent généralement de <classname>Glib::Object</classname>. Plutôt que vous demander de référencer et déréférencer ces objets, <application>gtkmm</application> utilise le « pointeur intelligent » <classname>RefPtr&lt;&gt;</classname>.</para>

<para>Les objets du type <classname>Gdk::Bitmap</classname> ne peuvent être instanciés qu'avec la fonction <methodname>create()</methodname>. Par exemple, <programlisting>
Glib::RefPtr&lt;Gdk::Bitmap&gt; bitmap = Gdk::Bitmap::create(window, data, width, height);
</programlisting></para>

<para>Il n'y a pas de moyen d'obtenir un objet <classname>Gdk::Bitmap</classname> vide. Dans l'exemple, <varname>bitmap</varname> est un pointeur intelligent, vous pouvez donc faire ceci, tout comme avec un pointeur normal : <programlisting>
if(bitmap)
{
  int depth = bitmap-&gt;get_depth().
}
</programlisting></para>

<para>Quand le <varname>bitmap</varname> est hors de portée, une fonction <methodname>unref()</methodname> se produit en arrière-plan et vous n'avez pas besoin de vous en soucier plus longtemps. Il n'y a pas d'opérateur <literal>new</literal>, il n'est donc pas nécessaire d'appeler <literal>delete</literal>.</para>
<para>Si vous copiez un <classname>RefPtr</classname>, par exemple <programlisting>
Glib::RefPtr&lt;Gdk::Bitmap&gt; bitmap2 = bitmap.
</programlisting> ou si vous le passez en tant que paramètre de fonction ou en tant que type de retour, alors le pointeur <classname>RefPtr</classname> fera tout référencement nécessaire pour assurer que cette instance ne soit pas détruite avant que le <classname>RefPtr</classname> ne soit pas hors de portée.</para>
<para>Consultez cette <link linkend="chapter-refptr">annexe</link> pour une information détaillée concernant les RefPtr.</para>
<para>Si vous voulez en savoir plus à propos des pointeurs intelligents, vous pouvez consulter les ouvrages suivants : <itemizedlist>
<listitem><para>Bjarne Stroustrup, « The C++ Programming Language » - chapitre 14.4.2</para></listitem>
<listitem><para>Nicolai M. Josuttis, « The C++ Standard Library » - chapitre 4.2</para></listitem>
</itemizedlist></para>

</sect1>

</chapter>

<chapter id="chapter-builder">
<title>Glade et Gtk::Builder</title>
<para>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 <application>Glade</application> 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 <application>Gtk::Builder</application> 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é.</para>

<para>Cette fonction membre présente les avantages suivants : <orderedlist>
<listitem><simpara>elle requiert moins de code C++,</simpara></listitem>
<listitem><simpara>les modifications apportées à l'UI sont visibles plus rapidement, donc plus facilement améliorables,</simpara></listitem>
<listitem><simpara>des concepteurs sans capacité particulière de programmation peuvent créer et modifier des UI.</simpara></listitem>
</orderedlist></para>

<para>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 <application>Gtk::Builder</application> pour la disposition des éléments graphiques vous permet de vous concentrer sur l'implémentation des fonctionnalités.</para>

<sect1 id="sec-builder-loading-glade-file">
<title>Chargement du fichier .glade</title>
<para><classname>Gtk::Builder</classname> doit être utilisé avec un pointeur <classname>Glib::RefPtr</classname>. Comme toutes les classes de ce type, vous aurez besoin de faire appel à la fonction membre <methodname>create()</methodname> pour en créer un exemplaire. Par exemple, <programlisting>
Glib::RefPtr&lt;Gtk::Builder&gt; builder = 
                Gtk::Builder::create_from_file("basic.glade");
</programlisting> Ceci va initialiser la fenêtre définie dans le fichier .glade, même si elle n'est pas immédiatement affichée à moins que vous ayez défini cette action par l'intermédiaire de la fenêtre <guilabel>Propriétés</guilabel> dans <application>Glade</application>.</para>

<para>Pour créer juste un exemplaire d'une fenêtre ou d'un élément graphique enfant, vous pouvez indiquer le nom d'un élément graphique en tant que deuxième paramètre. Par exemple, <programlisting>
Glib::RefPtr&lt;Gtk::Builder&gt; builder = 
                Gtk::Builder::create_from_file(
                              "basic.glade",
                              "treeview_products");
</programlisting></para>

</sect1>

<sect1 id="sec-builder-accessing-widgets">
<title>Accès aux éléments graphiques</title>

<para>Pour accéder à un élément graphique, par exemple pour appeler la fonction <methodname>show()</methodname> sur une boîte de dialogue, utilisez la fonction membre <methodname>get_widget()</methodname> en fournissant le nom de l'élément graphique en paramètre. Ce nom doit avoir été indiqué dans la fenêtre Propriétés de <application>Glade</application>. Si l'élément graphique est introuvable, ou n'est pas d'un type correct, le pointeur sera initialisé à 0. <programlisting>
Gtk::Dialog* pDialog = 0;
builder-&gt;get_widget("DialogBasic", pDialog);
</programlisting></para>

<para><application>Gtk::Builder</application> 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.</para>

<para>Souvenez-vous que <methodname>get_widget()</methodname> 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 <methodname>get_widget()</methodname> sur le même <classname>Gtk::Builder</classname>, avec le même nom d'élément graphique. Les éléments graphiques sont créés pendant l'appel à <methodname>Gtk::Builder::create_from_file()</methodname>.</para>

<para><methodname>get_widget()</methodname> renvoie des éléments graphiques enfants marqués (voir le chapitre sur la <link linkend="chapter-memory">Gestion de la mémoire</link>) par la fonction <function>manage()</function> ; ils seront donc détruits quand leur conteneur parent sera détruit. Donc, si vous n'obtenez qu'un seul élément graphique de <application>Gtk::Builder</application>, au lieu de la totalité de la fenêtre, alors vous devez, soit le placer dans un objet <classname>Container</classname>, soit le détruire. Les objets <classname>Windows</classname> (tout comme les objets <classname>Dialogs</classname>) 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é.</para>

<sect2 id="builder-example-loading">
<title>Exemple</title>
<para>Cet exemple simple montre comment charger un fichier <application>Glade</application> au cours de l'exécution et accéder aux éléments graphiques avec <application>Gtk::Builder</application>.</para>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/builder/basic?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;gtkmm.h&gt;
#include &lt;iostream&gt;

Gtk::Dialog* pDialog = 0;

static
void on_button_clicked()
{
  if(pDialog)
    pDialog-&gt;hide(); //hide() will cause main::run() to end.
}

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

  //Load the GtkBuilder file and instantiate its widgets:
  Glib::RefPtr&lt;Gtk::Builder&gt; refBuilder = Gtk::Builder::create();
  try
  {
    refBuilder-&gt;add_from_file("basic.ui");
  }
  catch(const Glib::FileError&amp; ex)
  {
    std::cerr &lt;&lt; "FileError: " &lt;&lt; ex.what() &lt;&lt; std::endl;
    return 1;
  }
  catch(const Gtk::BuilderError&amp; ex)
  {
    std::cerr &lt;&lt; "BuilderError: " &lt;&lt; ex.what() &lt;&lt; std::endl;
    return 1;
  }

  //Get the GtkBuilder-instantiated Dialog:
  refBuilder-&gt;get_widget("DialogBasic", pDialog);
  if(pDialog)
  {
    //Get the GtkBuilder-instantiated Button, and connect a signal handler:
    Gtk::Button* pButton = 0;
    refBuilder-&gt;get_widget("quit_button", pButton);
    if(pButton)
    {
      pButton-&gt;signal_clicked().connect( sigc::ptr_fun(on_button_clicked) );
    }

    kit.run(*pDialog);
  }

  return 0;
}
</programlisting>
<!-- end inserted example code -->

</sect2>

</sect1>


<sect1 id="sec-builder-using-derived-widgets">
<title>Utilisation d'éléments graphiques dérivés</title>
<para>Vous pouvez utilisez <application>Glade</application> pour placer vos propres éléments graphiques personnalisés, dérivés à partir d'une classe d'élément graphique <application>gtkmm</application>. 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 <application>Glade</application>, mais vous pouvez indiquer son emplacement, ses éléments graphiques enfants et les propriétés de la classe <application>gtkmm</application> de base.</para>

<para>Utilisez <methodname>Gtk::Builder::get_widget_derived()</methodname> ainsi : <programlisting>
DerivedDialog* pDialog = 0;
builder-&gt;get_widget_derived("DialogBasic", pDialog);
</programlisting></para>

<para>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 <classname>Gtk::Builder</classname>. Toutes les classes <application>gtkmm</application> en rapport définissent leurs types C sous-jacents en tant qu'objets <classname>BaseObjectType</classname> (par exemple <classname>Gtk::Dialog</classname> défini son type <classname>BaseObjectType</classname> comme <literal>GtkDialog</literal>).</para>
<para>Vous devez faire appel au constructeur de la classe de base dans la liste d'initialisation, en fournissant le pointeur C. Par exemple, <programlisting>
DerivedDialog::DerivedDialog(BaseObjectType* cobject,
                             const Glib::RefPtr&lt;Gtk::Builder&gt;&amp; builder)
: Gtk::Dialog(cobject)
{
}
</programlisting></para>

<para>Vous pouvez ensuite encapsuler les manipulations des éléments graphiques enfants dans le constructeur de la classe dérivée, avec peut-être <methodname>get_widget()</methodname> ou <methodname>get_widget_derived()</methodname> à nouveau. Par exemple, <programlisting>
DerivedDialog::DerivedDialog(BaseObjectType* cobject,
                             const Glib::RefPtr&lt;Gtk::Builder&gt;&amp; builder)
: Gtk::Dialog(cobject),
  m_builder(builder),
  m_pButton(0)
{
  // Obtenir le bouton instancié par Glade 
  // et le connecter au gestionnaire de signal :
  m_builder-&gt;get_widget("quit_button", m_pButton);
  if(m_pButton)
  {
    m_pButton-&gt;signal_clicked().connect( sigc::mem_fun(*this,
                                   &amp;DerivedDialog::on_button_quit) );
  }
}
</programlisting></para>

<sect2 id="builder-example-accessing">
<title>Exemple</title>
<para>Cet exemple montre comment charger un fichier <application>Glade</application> au lancement et accéder aux éléments graphiques par l'intermédiaire d'une classe dérivée.</para>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/builder/derived?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>deriveddialog.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_DERIVED_DIALOG_H
#define GTKMM_EXAMPLE_DERIVED_DIALOG_H

#include &lt;gtkmm.h&gt;


class DerivedDialog : public Gtk::Dialog
{
public:
  DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr&lt;Gtk::Builder&gt;&amp; refGlade);
  virtual ~DerivedDialog();

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

  Glib::RefPtr&lt;Gtk::Builder&gt; m_refGlade;
  Gtk::Button* m_pButton;
};

#endif //GTKMM_EXAMPLE_DERIVED_WINDOW_H
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "deriveddialog.h"
#include &lt;iostream&gt;

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

  //Load the Glade file and instiate its widgets:
  Glib::RefPtr&lt;Gtk::Builder&gt; refBuilder = Gtk::Builder::create();
  try
  {
    refBuilder-&gt;add_from_file("basic.ui");
  }
  catch(const Glib::FileError&amp; ex)
  {
    std::cerr &lt;&lt; "FileError: " &lt;&lt; ex.what() &lt;&lt; std::endl;
    return 1;
  }
  catch(const Gtk::BuilderError&amp; ex)
  {
    std::cerr &lt;&lt; "BuilderError: " &lt;&lt; ex.what() &lt;&lt; std::endl;
    return 1;
  }

  //Get the GtkBuilder-instantiated dialog::
  DerivedDialog* pDialog = 0;
  refBuilder-&gt;get_widget_derived("DialogBasic", pDialog);
  if(pDialog)
  {
    //Start:
    kit.run(*pDialog);
  }

  delete pDialog;
    

  return 0;
}
</programlisting>
<para>File: <filename>deriveddialog.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "deriveddialog.h"

DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr&lt;Gtk::Builder&gt;&amp; refGlade)
: Gtk::Dialog(cobject),
  m_refGlade(refGlade),
  m_pButton(0)
{
  //Get the Glade-instantiated Button, and connect a signal handler:
  m_refGlade-&gt;get_widget("quit_button", m_pButton);
  if(m_pButton)
  {
    m_pButton-&gt;signal_clicked().connect( sigc::mem_fun(*this, &amp;DerivedDialog::on_button_quit) ); 
  }
}

DerivedDialog::~DerivedDialog()
{
}

void DerivedDialog::on_button_quit()
{
  hide(); //hide() will cause main::run() to end.
}
</programlisting>
<!-- end inserted example code -->

</sect2>

</sect1>

</chapter>

<chapter id="chapter-internationalization">
  <title>Internationalisation et adaptation locale</title>

  <para>Les applications <application>gtkmm</application> 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 <application>gtkmm</application> écrite et traduite de manière appropriée, utilise lors de son exécution la langue définie par l'environnement utilisateur.</para>
  <para>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.</para>

  <para>Le processus consistant à écrire un code source autorisant la traduction s'appelle l'<literal>internationalisation</literal>, souvent abrégé en <literal>i18n</literal>. Le processus d'<literal>adaptation locale</literal> (localisation) quelquefois abrégé en <literal>l10n</literal>, met à disposition du texte, fondé sur ce code source, traduit dans d'autres langues.</para>

  <para>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.</para>

  <para>Les chaînes littérales doivent être saisies en anglais dans le code source, mais englobées dans une macro. L'utilitaire <application>gettext</application> (ou intltool) extrait les chaînes marquées pour traduction et substitue le texte traduit lors de l'exécution.</para>

  <sect1 id="sec-internationalization-intro">
    <title>Préparation du projet</title>

    <note>
      <para>Dans les directives ci-dessous, nous supposons que vous n'utilisez pas <application>gettext</application> directement, mais <application>intltool</application> qui a été spécialement écrit pour <literal>GNOME</literal>. <application>intltool</application> utilise <function>gettext()</function> pour extraire les chaînes du code source, mais <application>intltool</application> peut aussi combiner, dans les fichiers standards <filename>.pot/.po</filename> de <application>gettext</application>, les chaînes provenant d'autres fichiers : par exemple, des détails de menu du bureau ou de ressources d'interface utilisateur comme les fichiers <application>Glade</application>.</para>
      <para>Nous supposons également que vous utilisez autotools (c'est-à-dire, <application>automake</application> et <application>autoconf</application>) pour construire le projet et que vous vous servez de <ulink url="http://svn.gnome.org/viewcvs/gnome-common/trunk/autogen.sh?view=markup"><literal>./autogen.sh</literal></ulink> de <application>gnome-common</application>, qui, entre autres choses, effectue certaines initialisations pour <application>intltool</application>.</para>
    </note>

    <para>Créez un sous-répertoire nommé <literal>po</literal> 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é <literal>LINGUAS</literal> et un fichier nommé <literal>POTFILES.in</literal>. Il est aussi de pratique courante de créer un fichier <literal>ChangeLog</literal> dans le répertoire <literal>po</literal> pour que les traducteurs puissent garder trace des modifications de traduction.</para>

    <para><literal>LINGUAS</literal> 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 <literal>#</literal> sont ignorées). Chaque code de langue listé dans <literal>LINGUAS</literal> doit avoir un fichier <literal>.po</literal> correspondant. Ainsi, si votre programme a des traductions en allemand et en japonais, le fichier <literal>LINGUAS</literal> ressemblera à :</para>
    <programlisting># keep this file sorted alphabetically, one language code per line
de
ja</programlisting>
    <para>(en outre, vous devez avoir dans le dossier <literal>po</literal> des fichiers <literal>ja.po</literal> et <literal>de.po</literal> contenant respectivement la traduction japonaise et allemande).</para>

    <para><literal>POTFILES.in</literal> 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é <literal>src</literal> et si vous avez deux fichiers contenant des chaînes à traduire, votre fichier <literal>POTFILES.in</literal> ressemble à quelque chose comme :</para>

    <programlisting>src/main.cc
src/other.cc</programlisting>

    <para>Si vous utilisez <application>gettext</application> 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 <application>intltool</application>, vous pouvez marquer des chaînes pour traduction dans divers autres formats de fichier, y compris les fichiers d'interface utilisateur <application>Glade</application>, xml, <ulink url="http://standards.freedesktop.org/desktop-entry-spec/latest/">.desktop</ulink> et de nombreux autres. Donc si vous avez conçu une partie des interfaces utilisateur du projet à l'aide de <application>Glade</application>, ajoutez également vos fichiers <filename>.glade</filename> dans la liste du fichier <literal>POTFILES.in</literal>.</para>

    <para>Maintenant que vous disposez d'un endroit où mettre vos traductions, il est nécessaire d'initialiser <application>intltool</application> et <application>gettext</application>. Ajoutez le code ci-après dans votre fichier <literal>configure.ac</literal>, en mettant le nom de votre programme à la place de « nom_programme » :</para>

    <programlisting>IT_PROG_INTLTOOL([0.35.0])

GETTEXT_PACKAGE=nom_programme
AC_SUBST(GETTEXT_PACKAGE)
AC_DEFINE_UNQUOTED([GETTEXT_PACKAGE], ["$GETTEXT_PACKAGE"],
                   [Domaine de portée de gettext])
AM_GLIB_GNU_GETTEXT

PROGRAMNAME_LOCALEDIR=[${datadir}/locale]
AC_SUBST(PROGRAMNAME_LOCALEDIR)</programlisting>

    <para>La variable <varname>PROGRAMNAME_LOCALEDIR</varname> sera utilisée plus tard dans le fichier <literal>Makefile.am</literal> pour définir une macro utilisée quand vous initialisez <application>gettext</application> dans votre code source.</para>

    <para>Dans le fichier Makefile.am principal : <itemizedlist>
        <listitem>
          <para>ajoutez <literal>po</literal> à la variable <literal>SUBDIRS</literal>. Sans cela, vos traductions ne seraient pas construites et installées lors de la construction du programme.</para>
        </listitem>
        <listitem>
          <para>définissez <literal>INTLTOOL_FILES</literal> égal à : <programlisting>INTLTOOL_FILES = intltool-extract.in \
                 intltool-merge.in \
                 intltool-update.in</programlisting></para>
        </listitem>
        <listitem>
          <para>ajoutez <literal>INTLTOOL_FILES</literal> à la liste <literal>EXTRA_DIST</literal> de fichiers. Ceci assure que ces commandes seront incluses dans l'archive source quand vous effectuerez <command>make dist</command>.</para>
        </listitem>
        <listitem>
          <para>mettez à jour vos <literal>DISTCLEANFILES</literal> : <programlisting>DISTCLEANFILES = ... intltool-extract \
                 intltool-merge \
                 intltool-update \
                 po/.intltool-merge-cache</programlisting></para>
        </listitem>
      </itemizedlist></para>

    <para>Dans votre <literal>src/Makefile.am</literal>, mettez à jour votre variable <literal>AM_CPPFLAGS</literal> en ajoutant la définition de macro préprocesseur suivante :</para>
    <programlisting>AM_CPPFLAGS = ... -DPROGRAMNAME_LOCALEDIR=\"${PROGRAMNAME_LOCALEDIR}\"</programlisting>
    <para>Cette macro sert quand vous initialisez <literal>gettext</literal> dans votre code source.</para>
  </sect1>

<sect1 id="sec-i18n-marking-strings">
  <title>Marquage des chaînes à traduire</title>

  <para>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 <function>gettext()</function>. 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.</para>

  <para>Le paquetage <application>GNU gettext</application> 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.</para>

  <para>Toutefois, <application>Glib</application> définit des macros de prise en charge de <function>gettext()</function> qui sont des enveloppes plus brèves et de forme plus commode à utiliser. Pour utiliser ces macros, incluez <literal>&lt;glibmm/i18n.h&gt;</literal>, puis, par exemple, remplacez : <programlisting>display_message("Getting ready for i18n.");</programlisting> par : <programlisting>display_message(_("Getting ready for i18n."));</programlisting></para>

  <para>À titre de référence, il est possible de générer un fichier qui contienne toutes les chaînes apparaissant dans votre code, même si elles ne sont pas marquées pour la traduction, avec le nom du fichier et le numéro de la ligne où elles se situent. Pour générer ce fichier que nous appelons <literal>my-strings</literal>, exécutez la commande suivante dans le répertoire du code source : <programlisting>xgettext -a -o my-strings --omit-header *.cc *.h</programlisting></para>

  <para>Pour terminer, pour permettre à votre programme d'utiliser la traduction pour l'adaptation locale en cours, ajoutez ce code au début de votre fichier <filename>main.cc</filename> pour initialiser gettext : <programlisting>bindtextdomain(GETTEXT_PACKAGE, PROGRAMNAME_LOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);</programlisting></para>

  <sect2 id="sec-i18n-gettext">
    <title>Comment fonctionne gettext</title>

    <para>Le script <application>intltool</application> / <application>xgettext</application> extrait les chaînes et les place dans un fichier <filename>mon_paquet.pot</filename>. Les traducteurs de votre application créent leur traduction en faisant d'abord une copie du fichier <filename>.pot</filename> dans un fichier <filename>nom_de_locale.po</filename>. Une « locale » identifie une langue et un codage pour cette langue, y compris les formats numériques et de date. Ultérieurement, si le texte de votre code source a été modifié, le script <literal>msmerge</literal> sera utilisé pour mettre à jour les fichiers <filename>nom_de_locale.po</filename> à partir d'une nouvelle génération du fichier <filename>.pot</filename>.</para>

    <para>Au moment de l'installation, les fichiers <filename>.po</filename> sont convertis dans un format binaire (avec l'extension <filename>.mo</filename>) et placés dans un répertoire système pour les fichiers d'environnement linguistique, par exemple <filename>/usr/share/locale/</filename>.</para>

    <para>Quand l'application est lancée, la bibliothèque <application>gettext</application> vérifie dans le répertoire système s'il y a un fichier <filename>.mo</filename> 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 <literal>gettext</literal>, 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.</para>
  </sect2>

  <sect2 id="sec-i18n-testing">
    <title>Vérification et ajout de traductions</title>

    <para>Pour vérifier que vous avez bien opéré, peut-être voudrez-vous ajouter une traduction pour un nouvel environnement linguistique. Pour réaliser cela, allez dans le sous-répertoire <filename>po</filename> de votre projet et exécutez les commandes suivantes : <programlisting>intltool-update --pot</programlisting></para>

    <para>Cette commande crée un fichier nommé <filename>nom_du_programme.pot</filename>. Copiez ensuite ce fichier en lui donnant le nom <filename>code_langue.po</filename>, comme <filename>de.po</filename> ou <filename>hu.po</filename>. Ajoutez également ce code langue dans le fichier <literal>LINGUAS</literal>. Le fichier <filename>.po</filename> 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é <literal>UTF-8</literal> comme codage du fichier <filename>.po</filename> (comme défini dans l'en-tête, mais utilisé dans le contenu).</para>

    <!-- TODO: This need more explanation. What's the point of the fuzzy tag then? murrayc -->
    <note>
      <para>Il est possible que certaines chaînes soient marquées <literal>fuzzy</literal> (approximatives) dans le fichier <filename>.po</filename>. Les traductions ainsi marquées ne se substituent pas à la chaîne originelle. Pour qu'elles apparaissent, enlevez simplement la marque <literal>fuzzy</literal>.</para>
    </note>
  </sect2>

  <sect2 id="sec-i18n-resources">
    <title>Ressources</title>

    <para>Des informations supplémentaires sur le processus d'internationalisation et de localisation sont présentées et commentées dans : <itemizedlist>
        <listitem>
          <para>
            <ulink url="http://www.gnome.org/~malcolm/i18n/index.html">Internationalisation des applications GNOME</ulink>
          </para>
        </listitem>

        <listitem>
          <para>
            <ulink url="http://svn.gnome.org/viewcvs/intltool/trunk/README?view=markup">Fichier README de Intltool</ulink>
          </para>
        </listitem>

        <listitem>
          <para>
            <ulink url="http://developer.gnome.org/doc/tutorials/gnome-i18n/translator.html">Comment utiliser GNOME CVS pour traduire</ulink>
          </para>
        </listitem>

        <listitem>
          <para>
            <ulink url="http://www.gnu.org/software/gettext/manual/gettext.html">Manuel gettext</ulink>
          </para>
        </listitem>

        <listitem>
          <para>
            <ulink url="http://ftp.gnome.org/pub/GNOME/sources/gtkmm_hello/">Exemple de paquet logiciel <literal>gtkmm_hello</literal></ulink>
          </para>
        </listitem>

        <listitem>
          <para>
            <ulink url="http://ftp.gnome.org/pub/GNOME/sources/gnomemm_hello/">Exemple de paquet logiciel <literal>gnomemm_hello</literal></ulink>
          </para>
        </listitem>
      </itemizedlist></para>
  </sect2>

</sect1>

<sect1 id="sec-i18n-expecting-utf8">
<title>En attendant UTF8</title>
<para>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 <classname>std::string</classname> ou de fonctions C standard telles que <function>strlen()</function> car elle se fondent sur de telles suppositions pour effectuer leurs calculs.</para>
<para>Même si vous avez certainement déjà délaissé les tableaux de <literal>char*</literal> vides et l'arithmétique des pointeurs en vous servant de <classname>std::string</classname>, vous devez maintenant utiliser à la place des objets <classname>Glib::ustring</classname>. Voyez le chapitre concernant les <classname>Glib::ustring</classname> dans les <link linkend="sec-basics-ustring">Fondamentaux</link>.</para>

<sect2 id="i18n-ustring-iostreams"><title>Glib::ustring et std::iostreams</title>
<!-- <para>TODO: This section is not clear - it needs to spell things out more clearly and obviously.</para> -->
<para>Malheureusement, l'intégration avec les flux d'entrée-sortie standards n'est pas d'une utilisation très simple. Si vous dirigez la sortie du flux standard vers un <classname>ostream</classname> avec l'opérateur <function>operator&lt;&lt;</function>, <application>gtkmm</application> convertit les <classname>Glib::ustring</classname> dans un encodage spécifique à l'environnement linguistique (qui généralement n'est pas UTF-8). De la même façon, en récupérant des objets <classname>Glib::ustring</classname> à partir d'un flux <classname>istream</classname> avec l'opérateur <function>operator&gt;&gt;</function>, vous déclenchez la conversion inverse. Mais ce schéma s'effondre si vous passez par un <classname>std::string</classname>, par exemple en dirigeant un flux de texte vers un  <classname>std::string</classname> puis en le convertissant de manière implicite en <classname>Glib::ustring</classname>. Si la chaîne contenait des caractères non-ASCII et que l'environnement linguistique local n'est pas codé en UTF-8, il en résulte un objet <classname>Glib::ustring</classname> corrompu. Vous pouvez contourner ce problème avec une conversion manuelle. Par exemple, pour retrouver l'objet <classname>std::string</classname> à partir d'un <classname>ostringstream</classname> : <programlisting>std::ostringstream output;
output.imbue(std::locale("")); // utiliser la locale de l'utilisateur pour ce flux
output &lt;&lt; percentage &lt;&lt; " % done";
label-&gt;set_text(Glib::locale_to_utf8(output.str()));</programlisting></para>
</sect2>

</sect1>

<sect1 id="sec-i18n-pitfalls">
      <title>Embûches</title>

      <para>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.</para>

<sect2 id="i18n-string-semantics">
        <title>Mêmes chaînes, sémantiques différentes</title>

        <para>Quelquefois deux chaînes en anglais sont identiques, mais ont des significations différentes selon le contexte ; elles ne mériteraient donc probablement pas d'être traduites de la même façon. Comme les chaînes en anglais sont utilisées comme clés de recherche, cela pose problème.</para>

<para>Dans ce cas, vous pouvez ajouter des caractères supplémentaires à la chaîne. Par exemple, écrivez <literal>"jumps[noun]"</literal> et <literal>"jumps[verb]"</literal> au lieu de <literal>"jumps"</literal> uniquement et extrayez-les à nouveau avec un appel à <function>gettext</function>. Si vous ajoutez des caractères supplémentaires, vous devez également ajouter un commentaire pour les traducteurs avant l'appel de <function>gettext</function>. De tels commentaires s'affichent dans les fichiers <filename>.po</filename>. Par exemple :</para>

<programlisting>// 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]");</programlisting>
      </sect2>

<sect2 id="i18n-composition">
  <title>Composition de chaînes</title>

<para>Les programmeurs C se servent de la fonction <function>sprintf()</function> 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.</para>

<para>Par exemple, ce code risque d'être sujet à problèmes :</para>

<programlisting>std::cout &lt;&lt; _("Current amount: ") &lt;&lt; amount
          &lt;&lt; _(" Future: ") &lt;&lt; future &lt;&lt; std::endl;

label.set_text(_("Really delete ") + filename + _(" now?"));</programlisting>

<para>Vous devez, soit éviter de tels cas, soit revenir à la fonction <function>sprintf()</function> du style C. Une autre solution possible est d'utiliser la <ulink url="http://www.cs.auc.dk/~olau/compose/">bibliothèque compose</ulink> qui prend en charge des syntaxes telles que :</para>

<programlisting>label.set_text(compose(_("Really delete %1 now?"), filename));</programlisting>
</sect2>

<sect2 id="i18n-display-size">
        <title>Hypothèse concernant la taille d'affichage des chaînes</title>

        <para>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 <application>gtkmm</application> se redimensionnent à la taille voulue lors de l'exécution.</para>
</sect2>

<sect2 id="i18n-unusual-words">
        <title>Mots inhabituels</title>

        <para>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 ».</para>
</sect2>

<sect2 id="i18n-non-ascii-characters">
<title>Utilisation de caractères non-ASCII dans les chaînes</title>

<para>Actuellement, <application>gettext</application> 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 (©).</para>

        <para>Pour contourner ce problème, vous pouvez écrire un commentaire dans le code source juste avant la chaîne, indiquant au traducteur qu'il peut utiliser le caractère spécial s'il est disponible dans leur langue. Pour l'anglais, vous pouvez ensuite faire une traduction américain-anglais dans <filename>en_US.po</filename> en utilisant ce caractère spécial.</para>
      </sect2>
    </sect1>

    <sect1 id="sec-i18n-getting-help-with-translations">
      <title>Obtenir de l'aide avec les traductions</title>

      <para>Si votre programme est un logiciel libre, il existe un sous-projet complet <literal>GNOME</literal> dédié à l'aide à la traduction, le <ulink url="http://developer.gnome.org/projects/gtp/">Projet de traduction <literal>GNOME</literal></ulink> (GNOME Translation Project).</para>

      <para>Voici comment il fonctionne : contactez la liste de diffusion gnome-i18n pour indiquer comment les traducteurs pourraient avoir accès à votre sous-répertoire <filename>po/</filename> et pour ajouter votre projet aux grands <ulink url="http://developer.gnome.org/projects/gtp/status/">tableaux d'état</ulink>.</para>

      <para>Assurez-vous que le fichier <filename>POTFILES.in</filename> dans le sous-répertoire <filename>po/</filename> est à jour (la commande <command>intltool‑update -M</command> peut vous aider pour cela) de façon à ce que les traducteurs aient toujours accès à des fichiers <filename>mon_programme.pot</filename> actualisés et gelez tout simplement les chaînes au moins quelques jours avant de téléverser une nouvelle version en l'annonçant sur gnome-i18n. Selon le nombre de chaînes que votre programme comporte et selon sa popularité, les traductions vont alors commencer à apparaître dans les fichiers <filename>nom_de_langue.po</filename>.</para>

      <para>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.</para>
    </sect1>
</chapter>

<chapter id="chapter-customwidgets">
    <title>Éléments graphiques personnalisés</title>

    <para><application>gtkmm</application> 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.</para>

    <sect1 id="sec-custom-containers">
    <title>Conteneurs personnalisés</title>
    <para>Quand vous dérivez de la classe <classname>Gtk::Container</classname>, vous pouvez surdéfinir les fonctions membres virtuelles suivantes : <itemizedlist>
      <listitem><para><methodname>get_request_mode_vfunc()</methodname> : renvoie quel est l'objet <literal>Gtk::SizeRequestMode</literal> préféré par le conteneur.</para></listitem>
      <listitem><para><methodname>get_preferred_width_vfunc()</methodname> : calcule la largeur minimale naturelle du conteneur.</para></listitem>
      <listitem><para><methodname>get_preferred_height_vfunc()</methodname> : calcule la hauteur minimale naturelle du conteneur.</para></listitem>
      <listitem><para><methodname>get_preferred_width_for_height_vfunc()</methodname> : calcule la largeur minimale naturelle du conteneur compte tenu de la hauteur précisée.</para></listitem>
      <listitem><para><methodname>get_preferred_height_for_width_vfunc()</methodname> : calcule la hauteur minimale naturelle du conteneur compte tenu de la largeur précisée.</para></listitem>
      <listitem><para><methodname>on_size_allocate()</methodname> : place les éléments graphiques enfants, compte tenu de la hauteur et de la largeur réellement attribuées au conteneur.</para></listitem>
      <listitem><para><methodname>forall_vfunc()</methodname> : appelle la même fonction de rappel pour chaque enfant.</para></listitem>
      <listitem><para><methodname>on_add()</methodname> : ajoute un élément graphique enfant dans le conteneur.</para></listitem>
      <listitem><para><methodname>on_remove()</methodname> : supprime un élément graphique enfant du conteneur.</para></listitem>
      <listitem><para><methodname>child_type_vfunc()</methodname> : renvoie le type d'enfant pouvant être ajouté.</para></listitem>
    </itemizedlist></para>

    <para>Les fonctions membres virtuelles <methodname>get_request_mode_vfunc()</methodname>, <methodname>get_preferred_width_vfunc()</methodname>, <methodname>get_preferred_height_vfunc()</methodname>, <methodname>get_preferred_width_for_height_vfunc()</methodname>, <methodname>get_preferred_height_for_width_vfunc()</methodname> et <methodname>on_size_allocate()</methodname> contrôlent la disposition des éléments graphiques enfants. Par exemple, si votre conteneur possède deux éléments graphiques enfants, l'un au dessus de l'autre, votre fonction membre <methodname>get_preferred_width_vfunc()</methodname> doit renvoyer la plus grande des largeurs des éléments graphiques enfants et <methodname>get_preferred_height_for_width_vfunc()</methodname> la somme des hauteurs. Si vous voulez de l'espace libre autour les éléments graphiques enfants, vous devez également l'additionner à la largeur et à la hauteur. Votre conteneur d'éléments graphiques se sert de ces résultats pour s'assurer que vos éléments graphiques ont assez de place. En examinant chaque parent de l'élément graphique, et les parents de celui-ci, cette logique détermine éventuellement la taille de la fenêtre de plus haut niveau.</para>

    <para>Vous n'avez pas la garantie d'obtenir le <literal>Gtk::SizeRequestMode</literal> demandé. C'est pourquoi les quatre fonctions membres <methodname>get_preferred_xxx_vfunc()</methodname> doivent renvoyer des valeurs raisonnables.</para>

   <para><methodname>on_size_allocate()</methodname>, toutefois, reçoit les vraies hauteur et largeur que le conteneur parent a décidé de donner à l'élément graphique. Cela peut être plus que le minimum ou même plus que la taille naturelle, par exemple, si la fenêtre de haut niveau a été agrandie. Vous pouvez choisir d'ignorer l'espace supplémentaire et laisser la zone inoccupée, ou bien vous pouvez choisir d'agrandir vos éléments graphiques enfants pour remplir cet espace, ou bien encore vous pouvez choisir d'augmenter l'espace libre entre vos éléments graphiques. C'est votre conteneur, à vous de décider. N'oubliez pas d'appeler <methodname>set_allocation()</methodname> à l'intérieur de votre implémentation de <methodname>on_size_allocate()</methodname> pour utiliser effectivement l'espace alloué offert par le conteneur parent.</para>

  <para>À moins que votre conteneur ne soit une fenêtre de haut niveau dérivée de <classname>Gtk::Window</classname>, vous devez également appeler <methodname>Gtk::Widget::set_has_window(false)</methodname> dans le constructeur. Cela signifie que votre conteneur ne crée pas sa propre <classname>Gdk::Window</classname>, mais utilise la fenêtre du parent. (Notez la différence entre <classname>Gtk::Window</classname> et <classname>Gdk::Window</classname>.) Si votre conteneur n'a pas besoin de sa propre <classname>Gdk::Window</classname> et ne dérive pas d'une <classname>Gtk::Window</classname>, vous devez aussi surdéfinir la fonction membre <methodname>on_realize()</methodname> comme cela est décrit dans la section <link linkend="sec-custom-widgets">Éléments graphiques personnalisés</link>. Et, sauf si votre conteneur dessine directement dans la <classname>Gdk::Window</classname> sous-jacente, vous devrez probablement appeler <methodname>set_redraw_on_allocate(false)</methodname> pour améliorer les performances.</para>

  <para>En surdéfinissant <methodname>forall_vfunc()</methodname> vous permettez aux applications d'opérer sur tous les éléments graphiques enfants du conteneur. Par exemple, <methodname>show_all_children()</methodname> utilise cette possibilité pour trouver tous les éléments graphiques enfants et les afficher.</para>

  <para>Même si votre conteneur possède sa propre fonction membre pour définir ses éléments graphiques enfants, vous devez quand même fournir une implémentation des fonctions membres virtuelles <methodname>on_add()</methodname> et <methodname>on_remove()</methodname> de la classe de base de façon à ce que les fonctions membres add() et remove() fassent quelque chose d'approprié si elles sont appelées.</para>

  <para>Votre implémentation de la fonction membre <methodname>child_type_vfunc()</methodname> 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 à <methodname>Gtk::Widget::get_type()</methodname> d'indiquer quelles sont les classes dérivées de <classname>Gtk::Widget</classname> acceptées. Si le conteneur ne peut plus contenir d'autres éléments graphiques, cette fonction membre doit renvoyer la valeur <literal>G_TYPE_NONE</literal>.</para>


<sect2 id="custom-container-example"><title>Exemple</title>

    <para>Cet exemple implémente un conteneur avec deux éléments graphiques enfants, l'un au dessus de l'autre. Bien entendu, dans ce cas il aurait été de loin beaucoup plus simple d'utiliser <classname>Gtk::VBox</classname>.</para>

<figure id="figure-custom-container">
  <title>Conteneur personnalisé</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/custom_container.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/custom/custom_container/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>mycontainer.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_CUSTOM_CONTAINER_MYCONTAINER_H
#define GTKMM_CUSTOM_CONTAINER_MYCONTAINER_H

#include &lt;gtkmm/container.h&gt;

class MyContainer : public Gtk::Container
{
public:
  MyContainer();
  virtual ~MyContainer();

  void set_child_widgets(Gtk::Widget&amp; child_one, Gtk::Widget&amp; child_two);

protected:

  //Overrides:
  virtual Gtk::SizeRequestMode get_request_mode_vfunc() const;
  virtual void get_preferred_width_vfunc(int&amp; minimum_width, int&amp; natural_width) const;
  virtual void get_preferred_height_for_width_vfunc(int width, int&amp; minimum_height, int&amp; natural_height) const;
  virtual void get_preferred_height_vfunc(int&amp; minimum_height, int&amp; natural_height) const;
  virtual void get_preferred_width_for_height_vfunc(int height, int&amp; minimum_width, int&amp; natural_width) const;
  virtual void on_size_allocate(Gtk::Allocation&amp; allocation);

  virtual void forall_vfunc(gboolean include_internals, GtkCallback callback, gpointer callback_data);

  virtual void on_add(Gtk::Widget* child);
  virtual void on_remove(Gtk::Widget* child);
  virtual GType child_type_vfunc() const;

  Gtk::Widget* m_child_one;
  Gtk::Widget* m_child_two;
};

#endif //GTKMM_CUSTOM_CONTAINER_MYCONTAINER_H
</programlisting>
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;
#include "mycontainer.h"

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

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

  //Child widgets:
  Gtk::VBox m_VBox;
  MyContainer m_MyContainer;
  Gtk::Button m_Button_One;
  Gtk::Label m_Label_Two;
  Gtk::HButtonBox m_ButtonBox;
  Gtk::Button m_Button_Quit;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include "examplewindow.h"

ExampleWindow::ExampleWindow()
: m_Button_One("Child One"),
  m_Label_Two("Child 2"),
  m_Button_Quit("Quit")
{
  set_title("Custom Container example");
  set_border_width(6);
  set_default_size(400, 200);

  add(m_VBox);

  //Add the child widgets to the custom container:
  m_MyContainer.set_child_widgets(m_Button_One, m_Label_Two);

  m_Label_Two.set_alignment(1.0, 0.5);

  m_VBox.pack_start(m_MyContainer, Gtk::PACK_EXPAND_WIDGET);
  m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

  m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
  m_ButtonBox.set_border_width(6);
  m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
  m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
              &amp;ExampleWindow::on_button_quit) );

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<para>File: <filename>mycontainer.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include &lt;iostream&gt;
#include &lt;algorithm&gt; // std::max
#include "mycontainer.h"

MyContainer::MyContainer()
: m_child_one(0), m_child_two(0)
{
  set_has_window(false);
  set_redraw_on_allocate(false);
}

MyContainer::~MyContainer()
{
}

void MyContainer::set_child_widgets(Gtk::Widget&amp; child_one,
        Gtk::Widget&amp; child_two)
{
  m_child_one = &amp;child_one;
  m_child_two = &amp;child_two;

  m_child_one-&gt;set_parent(*this);
  m_child_two-&gt;set_parent(*this);
}

//This example container is a simplified VBox with at most two children.
Gtk::SizeRequestMode MyContainer::get_request_mode_vfunc() const
{
  return Gtk::SIZE_REQUEST_HEIGHT_FOR_WIDTH;
}

//Discover the total amount of minimum space and natural space needed by
//this container and its children.
void MyContainer::get_preferred_width_vfunc(int&amp; minimum_width, int&amp; natural_width) const
{
  int child_minimum_width[2] = {0, 0};
  int child_natural_width[2] = {0, 0};

  if(m_child_one &amp;&amp; m_child_one-&gt;get_visible())
    m_child_one-&gt;get_preferred_width(child_minimum_width[0], child_natural_width[0]);

  if(m_child_two &amp;&amp; m_child_two-&gt;get_visible())
    m_child_two-&gt;get_preferred_width(child_minimum_width[1], child_natural_width[1]);

  //Request a width equal to the width of the widest visible child.
  minimum_width = std::max(child_minimum_width[0], child_minimum_width[1]);
  natural_width = std::max(child_natural_width[0], child_natural_width[1]);
}

void MyContainer::get_preferred_height_for_width_vfunc(int width,
   int&amp; minimum_height, int&amp; natural_height) const
{
  int child_minimum_height[2] = {0, 0};
  int child_natural_height[2] = {0, 0};
  int nvis_children = 0;

  if(m_child_one &amp;&amp; m_child_one-&gt;get_visible())
  {
    ++nvis_children;
    m_child_one-&gt;get_preferred_height_for_width(width, child_minimum_height[0],
                                                child_natural_height[0]);
  }

  if(m_child_two &amp;&amp; m_child_two-&gt;get_visible())
  {
    ++nvis_children;
    m_child_two-&gt;get_preferred_height_for_width(width, child_minimum_height[1],
                                                child_natural_height[1]);
  }

  //The allocated height will be divided equally among the visible children.
  //Request a height equal to the number of visible children times the height
  //of the highest child.
  minimum_height = nvis_children * std::max(child_minimum_height[0],
                                            child_minimum_height[1]);
  natural_height = nvis_children * std::max(child_natural_height[0],
                                            child_natural_height[1]);
}

void MyContainer::get_preferred_height_vfunc(int&amp; minimum_height, int&amp; natural_height) const
{
  int child_minimum_height[2] = {0, 0};
  int child_natural_height[2] = {0, 0};
  int nvis_children = 0;

  if(m_child_one &amp;&amp; m_child_one-&gt;get_visible())
  {
    ++nvis_children;
    m_child_one-&gt;get_preferred_height(child_minimum_height[0], child_natural_height[0]);
  }

  if(m_child_two &amp;&amp; m_child_two-&gt;get_visible())
  {
    ++nvis_children;
    m_child_two-&gt;get_preferred_height(child_minimum_height[1], child_natural_height[1]);
  }

  //The allocated height will be divided equally among the visible children.
  //Request a height equal to the number of visible children times the height
  //of the highest child.
  minimum_height = nvis_children * std::max(child_minimum_height[0],
                                            child_minimum_height[1]);
  natural_height = nvis_children * std::max(child_natural_height[0],
                                            child_natural_height[1]);
}

void MyContainer::get_preferred_width_for_height_vfunc(int height,
   int&amp; minimum_width, int&amp; natural_width) const
{
  int child_minimum_width[2] = {0, 0};
  int child_natural_width[2] = {0, 0};
  int nvis_children = 0;

  //Get number of visible children.
  if(m_child_one &amp;&amp; m_child_one-&gt;get_visible())
    ++nvis_children;
  if(m_child_two &amp;&amp; m_child_two-&gt;get_visible())
    ++nvis_children;

  if(nvis_children &gt; 0)
  {
    //Divide the height equally among the visible children.
    const int height_per_child = height / nvis_children;

    if(m_child_one &amp;&amp; m_child_one-&gt;get_visible())
      m_child_one-&gt;get_preferred_width_for_height(height_per_child,
                   child_minimum_width[0], child_natural_width[0]);

    if(m_child_two &amp;&amp; m_child_two-&gt;get_visible())
      m_child_two-&gt;get_preferred_width_for_height(height_per_child,
                   child_minimum_width[1], child_natural_width[1]);
  }

  //Request a width equal to the width of the widest child.
  minimum_width = std::max(child_minimum_width[0], child_minimum_width[1]);
  natural_width = std::max(child_natural_width[0], child_natural_width[1]);
}

void MyContainer::on_size_allocate(Gtk::Allocation&amp; allocation)
{
  //Do something with the space that we have actually been given:
  //(We will not be given heights or widths less than we have requested, though
  //we might get more.)

  //Use the offered allocation for this container:
  set_allocation(allocation);

  //Get number of visible children.
  int nvis_children = 0;
  if(m_child_one &amp;&amp; m_child_one-&gt;get_visible())
    ++nvis_children;
  if(m_child_two &amp;&amp; m_child_two-&gt;get_visible())
    ++nvis_children;

  if(nvis_children &lt;= 0)
    return;

  //Assign space to the children:
  Gtk::Allocation child_allocation_one;
  Gtk::Allocation child_allocation_two;

  //Place the first child at the top-left:
  child_allocation_one.set_x( allocation.get_x() );
  child_allocation_one.set_y( allocation.get_y() );

  //Make it take up the full width available:
  child_allocation_one.set_width( allocation.get_width() );

  if(m_child_one &amp;&amp; m_child_one-&gt;get_visible())
  {
    //Divide the height equally among the visible children.
    child_allocation_one.set_height( allocation.get_height() / nvis_children);
    m_child_one-&gt;size_allocate(child_allocation_one);
  }
  else
    child_allocation_one.set_height(0);

  //Place the second child below the first child:
  child_allocation_two.set_x( allocation.get_x() );
  child_allocation_two.set_y( allocation.get_y() +
          child_allocation_one.get_height());

  //Make it take up the full width available:
  child_allocation_two.set_width( allocation.get_width() );

  //Make it take up the remaining height:
  child_allocation_two.set_height( allocation.get_height() -
          child_allocation_one.get_height());

  if(m_child_two &amp;&amp; m_child_two-&gt;get_visible())
    m_child_two-&gt;size_allocate(child_allocation_two);
}

void MyContainer::forall_vfunc(gboolean, GtkCallback callback, gpointer callback_data)
{
  if(m_child_one)
    callback(m_child_one-&gt;gobj(), callback_data);

  if(m_child_two)
    callback(m_child_two-&gt;gobj(), callback_data);
}

void MyContainer::on_add(Gtk::Widget* child)
{
  if(!m_child_one)
  {
    m_child_one = child;
    m_child_one-&gt;set_parent(*this);
  }
  else if(!m_child_two)
  {
    m_child_two = child;
    m_child_two-&gt;set_parent(*this);
  }
}

void MyContainer::on_remove(Gtk::Widget* child)
{
  if(child)
  {
    const bool visible = child-&gt;get_visible();
    bool found = false;

    if(child == m_child_one)
    {
      m_child_one = 0;
      found = true;
    }
    else if(child == m_child_two)
    {
      m_child_two = 0;
      found = true;
    }

    if(found)
    {
      child-&gt;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;
  }
}
</programlisting>
<!-- end inserted example code -->
</sect2>

    </sect1>

    <sect1 id="sec-custom-widgets">
    <title>Éléments graphiques personnalisés</title>
    <para>En dérivant directement de la classe <classname>Gtk::Widget</classname>, 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 <classname>Gtk::Label</classname> écrit directement le texte de l'étiquette sans passer par l'intermédiaire d'autres éléments graphiques.</para>

    <para>Quand vous dérivez de la classe <classname>Gtk::Widget</classname>, vous pouvez surdéfinir les fonctions membres virtuelles. Les fonctions membres marquées (optionnelles) ne nécessitent pas d'être surdéfinies pour tous les éléments graphiques personnalisés. Les fonctions membres de la classe de base peuvent se révéler appropriées. <itemizedlist>
      <listitem><para><methodname>get_request_mode_vfunc()</methodname> : (optionelle) renvoie quel est le <literal>Gtk::SizeRequestMode</literal> préféré par l'élément graphique.</para></listitem>
      <listitem><para><methodname>get_preferred_width_vfunc()</methodname> : calcule la largeur minimale naturelle de l'élément graphique.</para></listitem>
      <listitem><para><methodname>get_preferred_height_vfunc()</methodname> : calcule la hauteur minimale naturelle de l'élément graphique.</para></listitem>
      <listitem><para><methodname>get_preferred_width_for_height_vfunc()</methodname> : calcule la largeur minimale naturelle de l'élément graphique compte tenu de la hauteur précisée.</para></listitem>
      <listitem><para><methodname>get_preferred_height_for_width_vfunc()</methodname> : calcule la hauteur minimale naturelle de l'élément graphique compte tenu de la largeur précisée.</para></listitem>
      <listitem><para><methodname>on_size_allocate()</methodname> : place l'élément graphique, compte tenu de la hauteur et de la largeur réellement attribuées.</para></listitem>
      <listitem><para><methodname>on_realize()</methodname> : associe un objet <classname>Gdk::Window</classname> à l'élément graphique.</para></listitem>
      <listitem><para><methodname>on_unrealize()</methodname> : (optionnelle) détruit l'association avec l'objet <classname>Gdk::Window</classname>.</para></listitem>
      <listitem><para><methodname>on_map()</methodname>: (optionnelle)</para></listitem>
      <listitem><para><methodname>on_unmap()</methodname>: (optionnelle)</para></listitem>
      <listitem><para><methodname>on_draw()</methodname> : trace sur l'objet <classname>Cairo::Context</classname> fourni.</para></listitem>
    </itemizedlist></para>

    <para>Les six premières fonctions membres dans le tableau précédent sont également surdéfinies dans les conteneurs personnalisés. Elles sont brièvement décrites dans la section <link linkend="sec-custom-containers">Conteneurs personnalisés</link>.</para>

    <para>La plupart des éléments graphiques personnalisés nécessitent leur propre <classname>Gdk::Window</classname> pour tracer dessus. Alors vous pouvez appeler <methodname>Gtk::Widget::set_has_window(true)</methodname> dans votre constructeur (c'est la valeur par défaut). Si vous n'appelez pas <methodname>set_has_window(false)</methodname>, vous devez surdéfinir <methodname>on_realize()</methodname> et appeler à partir de là <methodname>Gtk::Widget::set_realized()</methodname> et <methodname>Gtk::Widget::set_window()</methodname>.</para>

<sect2 id="custom-widget-example"><title>Exemple</title>

<para>Cet exemple implémente un élément graphique qui trace un triangle de Penrose.</para>

<figure id="figure-custom-widget">
  <title>Élément graphique personnalisé</title>
  <screenshot>
    <graphic format="PNG" fileref="figures/custom_widget.png"/>
  </screenshot>
</figure>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/custom/custom_widget/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>mywidget.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_CUSTOM_WIDGET_MYWIDGET_H
#define GTKMM_CUSTOM_WIDGET_MYWIDGET_H

#include &lt;gtkmm/widget.h&gt;
#include &lt;gtkmm/cssprovider.h&gt;

class MyWidget : public Gtk::Widget
{
public:
  MyWidget();
  virtual ~MyWidget();

protected:

  //Overrides:
  virtual Gtk::SizeRequestMode get_request_mode_vfunc() const;
  virtual void get_preferred_width_vfunc(int&amp; minimum_width, int&amp; natural_width) const;
  virtual void get_preferred_height_for_width_vfunc(int width, int&amp; minimum_height, int&amp; natural_height) const;
  virtual void get_preferred_height_vfunc(int&amp; minimum_height, int&amp; natural_height) const;
  virtual void get_preferred_width_for_height_vfunc(int height, int&amp; minimum_width, int&amp; natural_width) const;
  virtual void on_size_allocate(Gtk::Allocation&amp; allocation);
  virtual void on_map();
  virtual void on_unmap();
  virtual void on_realize();
  virtual void on_unrealize();
  virtual bool on_draw(const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr);

  Glib::RefPtr&lt;Gdk::Window&gt; m_refGdkWindow;
  Glib::RefPtr&lt;Gtk::CssProvider&gt; m_refStyleProvider;

  int m_scale;
};

#endif //GTKMM_CUSTOM_WIDGET_MYWIDGET_H
</programlisting>
<para>File: <filename>examplewindow.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include &lt;gtkmm.h&gt;
#include "mywidget.h"

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

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

  //Child widgets:
  Gtk::VBox m_VBox;
  MyWidget m_MyWidget;
  Gtk::HButtonBox m_ButtonBox;
  Gtk::Button m_Button_Quit;
};

#endif //GTKMM_EXAMPLEWINDOW_H
</programlisting>
<para>File: <filename>mywidget.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "mywidget.h"
#include &lt;gdkmm/general.h&gt;  // for cairo helper functions
#include &lt;iostream&gt;
//#include &lt;gtk/gtkwidget.h&gt; //For GTK_IS_WIDGET()
#include &lt;cstring&gt;


MyWidget::MyWidget() :
  //The GType name will actually be gtkmm__CustomObject_mywidget
  Glib::ObjectBase("mywidget"),
  Gtk::Widget(),
  m_scale(1000)
{
  set_has_window(true);

  //This shows the GType name, which must be used in the CSS file.
  std::cout &lt;&lt; "GType name: " &lt;&lt; G_OBJECT_TYPE_NAME(gobj()) &lt;&lt; std::endl;

  //This shows that the GType still derives from GtkWidget:
  //std::cout &lt;&lt; "Gtype is a GtkWidget?:" &lt;&lt; GTK_IS_WIDGET(gobj()) &lt;&lt; std::endl;

  //Install a style so that an aspect of this widget may be themed via a CSS
  //style sheet file:
  gtk_widget_class_install_style_property(GTK_WIDGET_CLASS(
              G_OBJECT_GET_CLASS(gobj())),
      g_param_spec_int("example_scale",
        "Scale of Example Drawing",
        "The scale to use when drawing. This is just a silly example.",
        G_MININT,
        G_MAXINT,
        500,
        G_PARAM_READABLE) );

  m_refStyleProvider = Gtk::CssProvider::create();
  Glib::RefPtr&lt;Gtk::StyleContext&gt; refStyleContext = get_style_context();
  refStyleContext-&gt;add_provider(m_refStyleProvider, 
    GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
    
  try
  {
    m_refStyleProvider-&gt;load_from_path("custom_gtk.css");
  }
  catch(const Glib::Error&amp; ex)
  {
    std::cerr &lt;&lt; "Gtk::CssProvider::load_from_path() failed: " &lt;&lt; ex.what() &lt;&lt; std::endl;
  }
}

MyWidget::~MyWidget()
{
}

Gtk::SizeRequestMode MyWidget::get_request_mode_vfunc() const
{
  //Accept the default value supplied by the base class.
  return Gtk::Widget::get_request_mode_vfunc();
}

//Discover the total amount of minimum space and natural space needed by
//this widget.
//Let's make this simple example widget always need minimum 60 by 50 and
//natural 100 by 70.
void MyWidget::get_preferred_width_vfunc(int&amp; minimum_width, int&amp; natural_width) const
{
  minimum_width = 60;
  natural_width = 100;
}

void MyWidget::get_preferred_height_for_width_vfunc(int /* width */,
   int&amp; minimum_height, int&amp; natural_height) const
{
  minimum_height = 50;
  natural_height = 70;
}

void MyWidget::get_preferred_height_vfunc(int&amp; minimum_height, int&amp; natural_height) const
{
  minimum_height = 50;
  natural_height = 70;
}

void MyWidget::get_preferred_width_for_height_vfunc(int /* height */,
   int&amp; minimum_width, int&amp; natural_width) const
{
  minimum_width = 60;
  natural_width = 100;
}

void MyWidget::on_size_allocate(Gtk::Allocation&amp; allocation)
{
  //Do something with the space that we have actually been given:
  //(We will not be given heights or widths less than we have requested, though
  //we might get more)

  //Use the offered allocation for this container:
  set_allocation(allocation);

  if(m_refGdkWindow)
  {
    m_refGdkWindow-&gt;move_resize( allocation.get_x(), allocation.get_y(),
            allocation.get_width(), allocation.get_height() );
  }
}

void MyWidget::on_map()
{
  //Call base class:
  Gtk::Widget::on_map();
}

void MyWidget::on_unmap()
{
  //Call base class:
  Gtk::Widget::on_unmap();
}

void MyWidget::on_realize()
{
  //Do not call base class Gtk::Widget::on_realize().
  //It's intended only for widgets that set_has_window(false).

  set_realized();

  //Get the themed style from the CSS file:
  get_style_property("example_scale", m_scale);
  std::cout &lt;&lt; "m_scale (example_scale from the theme/css-file) is: "
      &lt;&lt; m_scale &lt;&lt; std::endl;

  if(!m_refGdkWindow)
  {
    //Create the GdkWindow:

    GdkWindowAttr attributes;
    memset(&amp;attributes, 0, sizeof(attributes));

    Gtk::Allocation allocation = get_allocation();

    //Set initial position and size of the Gdk::Window:
    attributes.x = allocation.get_x();
    attributes.y = allocation.get_y();
    attributes.width = allocation.get_width();
    attributes.height = allocation.get_height();

    attributes.event_mask = get_events () | Gdk::EXPOSURE_MASK;
    attributes.window_type = GDK_WINDOW_CHILD;
    attributes.wclass = GDK_INPUT_OUTPUT;

    m_refGdkWindow = Gdk::Window::create(get_parent_window(), &amp;attributes,
            GDK_WA_X | GDK_WA_Y);
    set_window(m_refGdkWindow);

    //set colors
    override_background_color(Gdk::RGBA("red"));
    override_color(Gdk::RGBA("blue"));

    //make the widget receive expose events
    m_refGdkWindow-&gt;set_user_data(gobj());
  }
}

void MyWidget::on_unrealize()
{
  m_refGdkWindow.reset();

  //Call base class:
  Gtk::Widget::on_unrealize();
}

bool MyWidget::on_draw(const Cairo::RefPtr&lt;Cairo::Context&gt;&amp; cr)
{
  const double scale_x = (double)get_allocation().get_width() / m_scale;
  const double scale_y = (double)get_allocation().get_height() / m_scale;

  // paint the background
  Gdk::Cairo::set_source_rgba(cr, get_style_context()-&gt;get_background_color());
  cr-&gt;paint();

  // draw the foreground
  Gdk::Cairo::set_source_rgba(cr, get_style_context()-&gt;get_color());
  cr-&gt;move_to(155.*scale_x, 165.*scale_y);
  cr-&gt;line_to(155.*scale_x, 838.*scale_y);
  cr-&gt;line_to(265.*scale_x, 900.*scale_y);
  cr-&gt;line_to(849.*scale_x, 564.*scale_y);
  cr-&gt;line_to(849.*scale_x, 438.*scale_y);
  cr-&gt;line_to(265.*scale_x, 100.*scale_y);
  cr-&gt;line_to(155.*scale_x, 165.*scale_y);
  cr-&gt;move_to(265.*scale_x, 100.*scale_y);
  cr-&gt;line_to(265.*scale_x, 652.*scale_y);
  cr-&gt;line_to(526.*scale_x, 502.*scale_y);
  cr-&gt;move_to(369.*scale_x, 411.*scale_y);
  cr-&gt;line_to(633.*scale_x, 564.*scale_y);
  cr-&gt;move_to(369.*scale_x, 286.*scale_y);
  cr-&gt;line_to(369.*scale_x, 592.*scale_y);
  cr-&gt;move_to(369.*scale_x, 286.*scale_y);
  cr-&gt;line_to(849.*scale_x, 564.*scale_y);
  cr-&gt;move_to(633.*scale_x, 564.*scale_y);
  cr-&gt;line_to(155.*scale_x, 838.*scale_y);
  cr-&gt;stroke();

  return true;
}
</programlisting>
<para>File: <filename>examplewindow.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"

ExampleWindow::ExampleWindow()
: m_Button_Quit("Quit")
{
  set_title("Custom Widget example");
  set_border_width(6);
  set_default_size(400, 200);

  add(m_VBox);
  m_VBox.pack_start(m_MyWidget, Gtk::PACK_EXPAND_WIDGET);
  m_MyWidget.show();

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

  m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
  m_ButtonBox.set_border_width(6);
  m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
  m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this, &amp;ExampleWindow::on_button_quit) );

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_button_quit()
{
  hide();
}
</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "examplewindow.h"
#include &lt;gtkmm/main.h&gt;

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

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

  return 0;
}
</programlisting>
<!-- end inserted example code -->
</sect2>

    </sect1>



</chapter>

<chapter id="chapter-recommended-techniques">
<title>Techniques recommandées</title>

<para>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 <application>gtkmm</application>.</para>

<para>Utilisez <application>autoconf</application> et <application>automake</application> de GNU ! Ce sont des amis :) <application>Automake</application> examine les fichiers C, détermine leurs dépendances mutuelles et génère un <filename>Makefile</filename> ; ainsi les fichiers peuvent être compilés dans le bon ordre. <application>Autoconf</application> permet une configuration automatique de l'installation du logiciel en gérant un grand nombre de systèmes exotiques pour augmenter la portabilité.</para>

<para>Sous-classez vos éléments graphiques pour mieux organiser votre code. Vous devrez probablement sous-classer au moins votre fenêtre principale <classname>Window</classname>. Ensuite, vous pouvez faire des éléments graphiques enfants et des fonctions membres gestionnaires des signaux de cette classe.</para>

<para>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 <application>gtkmm</application> utilisent une version spéciale de <classname>sigc::signal</classname>, mais vous pouvez utiliser les signaux normaux tels que décrits dans la documentation de <application>libsigc++</application>.</para>

<sect1 id="sec-application-lifetime">
    <title>Durée de vie d'une application</title>
<para>La plupart des applications ne disposent que d'une fenêtre de la classe <classname>Window</classname>, ou uniquement une fenêtre principale. Ces applications peuvent utiliser la surdéfinition de <methodname>Gtk::Main::run(Gtk::Window&amp;)</methodname>. Elle affiche la fenêtre et rend la main quand la fenêtre a été cachée. Ceci se produit quand l'utilisateur ferme la fenêtre ou quand le code applique la fonction <methodname>hide()</methodname> sur la fenêtre. Vous pouvez empêcher l'utilisateur de fermer la fenêtre (par exemple, s'il y a des modifications non enregistrées) en surdéfinissant <methodname>Gtk::Window::on_delete_event()</methodname>.</para>
<para>La plupart de nos exemples utilisent cette technique.</para>
</sect1>

<sect1 id="sec-using-a-gtkmm-widget">
<title>Utilisation d'un élément graphique <application>gtkmm</application></title>

<para>Nos exemples adoptent tous la même structure. Ils suivent ces étapes pour l'utilisation d'un <classname>Élément graphique</classname> :</para>

<para>

<orderedlist>
<listitem>
<para>Déclarer une variable du type de l'<classname>Élément graphique</classname> 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 <literal>new</literal> 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.</para>
</listitem>

<listitem>
<para>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.</para>
</listitem>

<listitem>
<para>Connectez tout signal que vous souhaitez utiliser aux gestionnaires appropriés.</para>
</listitem>

<listitem>
<para>Empaquetez l'élément graphique dans un conteneur par un appel approprié, par exemple <methodname>Gtk::Container::add()</methodname> ou <methodname>pack_start()</methodname>.</para>
</listitem>

<listitem>
<para>Appelez <methodname>show()</methodname> pour afficher l'élément graphique.</para>
</listitem>

</orderedlist>

</para>

<para><methodname>Gtk::Widget::show()</methodname> fait savoir à <application>gtkmm</application> que vous avez terminé de définir les attributs de l'élément graphique et qu'il est prêt à être affiché. Vous pouvez utiliser <methodname>Gtk::Widget::hide()</methodname> pour le faire disparaître à nouveau. L'ordre dans lequel vous affichez les éléments graphiques n'a pas d'importance, mais nous suggérons de n'afficher qu'en dernier la fenêtre de plus haut niveau ; ainsi, la fenêtre globale apparaît en ayant tout son contenu déjà dessinée. Sinon, l'utilisateur voit d'abord une fenêtre vierge dans laquelle les éléments graphiques sont tracés progressivement.</para>

</sect1>
</chapter>

<chapter id="chapter-contributing">
<title>Comment contribuer</title>

<para>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 <application>gtkmm</application> qui ne serait pas déjà documenté, il serait aimable à vous d'envisager une contribution à ce document.</para>
<para>L'idéal serait que vous <ulink url="http://www.gtkmm.org/bugs.shtml">fournissiez un patch</ulink> pour le fichier <filename>docs/tutorial/C/gtkmm-tutorial-in.xml</filename>. Ce fichier est actuellement dans le module <literal>gtkmm-documentation</literal> du dépôt git de GNOME.</para>

<para>Si vous décidez de contribuer, veuillez poster votre contribution sur la liste de diffusion de <application>gtkmm</application> à l'adresse <ulink url="mailto:gtkmm-list@gnome.org">&lt;gtkmm-list@gnome.org&gt;</ulink>. É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.</para>

</chapter>

<appendix id="chapter-refptr">
<title>Le pointeur intelligent RefPtr</title>
<para><classname>Glib::RefPtr</classname> est un pointeur intelligent. Plus précisément, c'est un pointeur intelligent à décompte de références. Vous connaissez déjà peut-être le <literal>std::auto_ptr&lt;&gt;</literal>, qui est aussi un pointeur intelligent, mais <literal>Glib::RefPtr&lt;&gt;</literal> est plus simple et plus utile. Nous espérons qu'une future version de la Bibliothèque Standard C++ contiendra un pointeur partagé intelligent à décompte de références ; une future version de <application>gtkmm</application> pourrait alors l'utiliser à la place.</para>

<para><ulink url="http://developer.gnome.org/glibmm/unstable/classGlib_1_1RefPtr.html">Référence</ulink></para>

<para>Un pointeur intelligent se comporte plus ou moins comme un pointeur normal. Voici quelques exemples.</para>

<sect1 id="sec-refptr-copying">
    <title>Copie</title>
<para>Vous pouvez copier les <classname>RefPtr</classname>, tout comme des pointeurs normaux. Mais contrairement aux pointeurs normaux, vous n'avez pas à vous soucier de la destruction de l'instance sous-jacente.</para>
<para>
<programlisting>
Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap = Gdk::Bitmap::create(window,
data, width, height);
Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap2 = refBitmap;
</programlisting>
</para>
<para>Cela signifie bien sûr que vous pouvez stocker les <classname>RefPtrs</classname> dans des conteneurs standards tels que <classname>std::vector</classname> ou <classname>std::list</classname>.</para>
<para>
<programlisting>
std::list&lt; Glib::RefPtr&lt;Gdk::Pixmap&gt; &gt; listPixmaps;
Glib::RefPtr&lt;Gdk::Pixmap&gt; refPixmap = Gdk::Pixmap::create(window,
width, height, depth);
listPixmaps.push_back(refPixmap);
</programlisting>
</para>
</sect1>

<sect1 id="sec-refptr-dereferencing"><title>Déréférencement</title>
<para>Vous pouvez déréférencer un pointeur intelligent avec l'opérateur <literal>-&gt;</literal> pour appeler des fonctions membres de l'instance subjacente, comme pour un pointeur normal.</para>
<para>
<programlisting>
Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap = Gdk::Bitmap::create(window,
data, width, height);
int depth = refBitmap-&gt;get_depth();
</programlisting>
</para>
<para>Mais contrairement à la plupart des pointeurs, vous ne pouvez pas utiliser l'opérateur <literal>*</literal> pour avoir accès à l'instance sous-jacente.</para>
<para>
<programlisting>
Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap = Gdk::Bitmap::create(window,
data, width, height);
Gdk::Bitmap* underlying = *refBitmap; // Erreur de syntaxe - ne compilera pas.
</programlisting>
</para>
</sect1>

<sect1 id="sec-refptr-casting"><title>Forçage de type</title>
<para>Vous pouvez forcer les <classname>RefPtrs</classname> à des types de base, comme des pointeurs normaux.</para>
<para>
<programlisting>
Glib::RefPtr&lt;Gtk::TreeStore&gt; refStore = Gtk::TreeStore::create(columns);
Glib::RefPtr&lt;Gtk::TreeModel&gt; refModel = refStore;
</programlisting>
</para>
<para>Cela signifie que toute fonction membre prenant en paramètre un <literal>const Glib::RefPtr&lt;BaseType&gt;</literal> peut également prendre un <literal>const Glib::RefPtr&lt;DerivedType&gt;</literal>. Le forçage est implicite, tout comme pour un pointeur normal.</para>
<para>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.</para>
<para>
<programlisting>
Glib::RefPtr&lt;Gtk::TreeStore&gt; refStore =
Glib::RefPtr&lt;Gtk::TreeStore&gt;::cast_dynamic(refModel);
Glib::RefPtr&lt;Gtk::TreeStore&gt; refStore2 =
Glib::RefPtr&lt;Gtk::TreeStore&gt;::cast_static(refModel);
</programlisting>
</para>
</sect1>


<sect1 id="sec-refptr-checking-for-null"><title>Vérification du pointeur NULL </title>
<para>Comme pour les pointeurs normaux, vous pouvez vérifier si un pointeur <classname>RefPtr</classname> ne pointe sur rien.</para>
<para>
<programlisting>
Glib::RefPtr&lt;Gtk::TreeModel&gt; refModel = m_TreeView.get_model();
if(refModel)
{
  int cols_count = refModel-&gt;get_n_columns();
  ...
}
</programlisting>
</para>
<para>Mais contrairement aux pointeurs normaux, les <classname>RefPtr</classname> sont automatiquement initialisés à NULL ; vous n'avez pas à faire cela vous-même.</para>
</sect1>


<sect1 id="sec-refptr-constness"><title>Constance</title>
<para>L'utilisation du mot clé <literal>const</literal> dans le C++ n'est pas toujours claire.  Vous ne devez pas penser que <literal>const Quelquechose*</literal> déclare un pointeur sur un type <literal>const Quelquechose</literal> ; le pointeur peut être modifié, mais pas le <literal>Quelquechose</literal> sur lequel il pointe.</para>
<para>Ainsi, l'équivalent <classname>RefPtr</classname> de <literal>Quelquechose*</literal> pour un paramètre de fonction membre est <literal>const Glib::RefPtr&lt;Quelquechose&gt;&amp;</literal> et l'équivalent de <literal>const Quelquechose*</literal> est <literal>const Glib::RefPtr&lt;const Quelquechose&gt;&amp;</literal>.</para>
<para>Le <literal>const ... &amp;</literal> qui entoure les deux expressions est juste une question d'efficacité, c'est comme utiliser <classname>const std::string&amp;</classname> à la place de <classname>std::string</classname> pour un paramètre de fonction pour éviter une recopie non nécessaire.</para>
</sect1>

</appendix>


<appendix id="chapter-signals">
<title>Signaux</title>

<sect1 id="sec-connecting-signal-handlers">
<title>Connexion aux gestionnaires de signal</title>
<para>Les classes d'éléments graphiques <application>gtkmm</application> ont des fonctions membres d'accès aux signaux, comme <methodname>Gtk::Button::signal_clicked()</methodname>, qui permettent de se connecter au gestionnaire de signal. Grâce à la souplesse de <application>libsigc++</application>, la bibliothèque utilisée par <application>gtkmm</application>, 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 <application>GTK+</application> nomment souvent ces gestionnaires de signal « fonctions de rappel » (callback).</para>

<para>Voici un exemple de gestionnaire de signal connecté à un signal :</para>

<para>
<programlisting>
#include &lt;gtkmm/button.h&gt;

void on_button_clicked()
{
    std::cout &lt;&lt; "Hello World" &lt;&lt; std::endl;
}

main()
{
    Gtk::Button button("Hello World");
    button.signal_clicked().connect(sigc::ptr_fun(&amp;on_button_clicked));
}
</programlisting>
</para>

<para>Il y a un certain nombre de choses à considérer à propos de ce code (non fonctionnel). D'abord identifions les parties concernées :</para>

<itemizedlist>
<listitem>

<para>Le gestionnaire de signal est <methodname>on_button_clicked()</methodname>.</para>
</listitem>
<listitem>

<para>Nous le raccrochons à l'objet <classname>Gtk::Button</classname> nommé <varname>button</varname>.</para>
</listitem>
<listitem>

<para>Quand le bouton émet le signal <literal>clicked</literal>, <methodname>on_button_clicked()</methodname> est appelé.</para>
</listitem>

</itemizedlist>

<para>Maintenant ré-examinons la connexion :</para>

<para>
<programlisting>
    ...
    button.signal_clicked().connect(sigc::ptr_fun(&amp;on_button_clicked));
    ...
</programlisting>
</para>

<para>Notez que nous ne passons pas directement un pointeur sur <methodname>on_button_clicked()</methodname> à la fonction membre <methodname>connect()</methodname> du signal. À la place, nous faisons appel à <function>sigc::ptr_fun()</function> et passons le résultat à <methodname>connect()</methodname>.</para>

<para><function>sigc::ptr_fun()</function> génère un objet <classname>sigc::slot</classname>. 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 ». <function>sigc::ptr_fun()</function> génère un connecteur pour une fonction autonome ou une fonction membre statique. <function>sigc::mem_fun()</function> génère un connecteur pour une fonction membre d'une instance donnée.</para>

<para>Voici un exemple un peu plus développé de connecteurs en action :</para>

<para>
<programlisting>
void on_button_clicked();

class some_class
{
    void on_button_clicked();
};

some_class some_object;

main()
{
    Gtk::Button button;
    button.signal_clicked().connect( sigc::ptr_fun(&amp;on_button_clicked) );
    button.signal_clicked().connect( sigc::mem_fun(some_object,
                                     &amp;some_class::on_button_clicked) );
}
</programlisting>
</para>

<para>Le premier appel à <methodname>connect()</methodname> est identique à celui que nous avons vu la fois précédente ; rien de plus à dire.</para>
<para>Le suivant est plus intéressant. <function>sigc::mem_fun()</function> est appelé avec deux paramètres. Le premier paramètre est <parameter>some_object</parameter>, 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 <function>sigc::mem_fun()</function> 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 <methodname>some_object.on_button_clicked()</methodname>.</para>

<para>Autre chose à noter dans cet exemple : nous appelons <methodname>connect()</methodname> 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.</para>

<para>Nous venons de vous dire que le signal <literal>clicked</literal> 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 <function>sigc::bind()</function>, bien entendu). C'est pourquoi il est important de savoir quel type de gestionnaire de signal vous devez connecter à un signal donné.</para>
</sect1>

<sect1 id="sec-writing-signal-handlers">
<title>Écriture de gestionnaires de signal</title>

<para>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 <application>gtkmm</application> :</para>

<para>
<programlisting>
Glib::SignalProxy1&lt;bool, Gtk::DirectionType&gt; signal_focus()
</programlisting>
</para>

<para>Outre le nom du signal (<literal>focus</literal>), deux choses sont importantes à noter ici : le nombre suivant le mot <classname>SignalProxy</classname> (1, dans notre cas), et les types de la liste (<literal>bool</literal> et <literal>Gtk::DirectionType</literal>). Le nombre indique le nombre de paramètres que le gestionnaire de signal doit posséder, le premier type, <literal>bool</literal>, est le type de retour du gestionnaire de signal et le suivant, <literal>Gtk::DirectionType</literal>, est le type du premier et unique paramètre de ce signal. En consultant la documentation de référence, vous pouvez également prendre connaissance des noms des arguments.</para>

<para>Les mêmes principes s'appliquent aux signaux avec plus de paramètres, voici un exemple avec trois paramètres (pris dans le fichier <filename>&lt;gtkmm/editable.h&gt;</filename>) :</para>

<para>
<programlisting>
Glib::SignalProxy3&lt;void, const Glib::ustring&amp;, int, int*&gt; signal_insert_text()

</programlisting>
</para>

<para>Il est de la même forme. Le nombre 3 à la fin du nom du type indique que le gestionnaire de signal nécessite trois paramètres. Le premier type dans la liste des types est <literal>void</literal>, c'est le type de retour du gestionnaire de signal. Les trois types suivants sont les types des paramètres, dans l'ordre. Notre prototype de gestionnaire de signal ressemble à quelque chose comme :</para>

<para>
<programlisting>
void on_insert_text(const Glib::ustring&amp; text, int length, int* position);
</programlisting>
</para>
</sect1>

<sect1 id="sec-disconnecting-signal-handlers">
<title>Déconnexion des gestionnaires de signal</title>

<para>Examinons à nouveau la fonction membre <literal>connect</literal> d'un signal :</para>

<para>
<programlisting>
sigc::signal&lt;void,int&gt;::iterator signal&lt;void,int&gt;::connect( const sigc::slot&lt;void,int&gt;&amp; );
</programlisting>
</para>

<para>Notez que la valeur de retour est du type <classname>sigc::signal&lt;void,int&gt;::iterator</classname>. Celle-ci peut être implicitement convertie en <classname>sigc::connection</classname> qui peut, à son tour, être utilisée pour contrôler la connexion. En conservant un objet connexion, vous pouvez déconnecter son signal associé avec la fonction membre <methodname>sigc::connection::disconnect()</methodname>.</para>

</sect1>
<sect1 id="sec-overriding-default-signal-handlers">
<title>Surdéfinition du gestionnaire de signal par défaut</title>

<para>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.</para>

<para>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.</para>

<para>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.</para>

<para>Les classes <application>gtkmm</application> ont été conçues dans l'optique de surdéfinitions ; elles comportent des fonctions membres virtuelles spécialement pensées pour être surdéfinies.</para>

<para>Regardons un exemple de surdéfinition :</para>

<para>
<programlisting>
#include &lt;gtkmm/button.h&gt;

class OverriddenButton : public Gtk::Button
{
protected:
    virtual void on_clicked();
}

void OverriddenButton::on_clicked()
{
    std::cout &lt;&lt; "Hello World" &lt;&lt; std::endl;

// appeler la version de la classe de base de la fonction membre:
    Gtk::Button::on_clicked();
}
</programlisting>
</para>

<para>Ici nous définissons une nouvelle classe nommée <classname>OverriddenButton</classname> qui hérite de <classname>Gtk::Button</classname>. La seule chose que nous modifions est la fonction membre <methodname>on_clicked()</methodname> ; cette fonction membre est appelée chaque fois qu'un objet <classname>Gtk::Button</classname> émet le signal <literal>clicked</literal>. Elle affiche « Hello World » sur <literal>stdout</literal>, puis appelle la fonction membre originelle pour que <classname>Gtk::Button</classname> fasse ce qu'il a à faire quand il n'est pas surdéfini.</para>

<para>Il n'est pas toujours nécessaire d'appeler la fonction membre du parent ; certaines fois vous ne le souhaiterez pas. Notez que nous avons appelé la fonction membre du parent <emphasis>après</emphasis> avoir écrit « Hello World », mais nous aurions pu l'appeler avant. Dans cet exemple simple, cela n'a pas beaucoup d'importance, mais parfois si. Avec les signaux, il n'est pas facile de modifier des détails de ce type, et vous pouvez ici faire des choses que vous ne pourrez absolument pas faire avec des gestionnaires de signal connectés : vous pouvez appeler la fonction membre du parent au <emphasis>milieu</emphasis> de votre code personnalisé.</para>

</sect1>

<sect1 id="sec-binding-extra-arguments">
<title>Liaison avec des paramètres supplémentaires</title>
<para>Si vous utilisez un gestionnaire de signal pour capter le même signal à partir de plusieurs éléments graphiques, vous pouvez souhaiter que le gestionnaire de signal reçoive des informations supplémentaires. Par exemple, savoir quel bouton a été cliqué. Vous pouvez réaliser cela avec <function>sigc::bind()</function>. Voici du code extrait de l'exemple <link linkend="sec-helloworld2">helloworld2</link> déjà rencontré plus haut. <programlisting>
m_button1.signal_clicked().connect( 
            sigc::bind&lt;Glib::ustring&gt;( 
                                 sigc::mem_fun(
                                               *this, 
                                               &amp;HelloWorld::on_button_clicked
                                              ),
                                 "bouton 1")
                                  );
</programlisting> Ce code indique que nous voulons que le signal envoie une valeur supplémentaire de type <classname>Glib::ustring</classname> au gestionnaire et que sa valeur soit égale à « bouton 1 ». Bien évidemment, nous devons ajouter ce paramètre supplémentaire dans la déclaration de fonction de notre gestionnaire de signal : <programlisting>
virtual void on_button_clicked(Glib::ustring data);
</programlisting> Bien évidemment encore, un gestionnaire normal de signal « clicked » ne comporterait pas de paramètre.</para>
<para><function>sigc::bind()</function> n'est pas d'usage courant, mais peut-être le trouverez-vous commode parfois. Si vous êtes un familier de la programmation avec <application>GTK+</application>, vous avez alors probablement noté la similitude avec les paramètres supplémentaires  <literal>gpointer data</literal> que toutes les fonctions de rappel possèdent. Généralement, cette possibilité est utilisée à l'excès dans <application>GTK+</application> 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 <application>gtkmm</application>.</para>
</sect1>

<sect1 id="sec-xeventsignals">
<title>Signaux des événements X</title>
<para>La classe <classname>Widget</classname> possède certains signaux spéciaux correspondant aux événements de la fenêtre X sous-jacente. Il possèdent le suffixe <literal>_event</literal> ; par exemple, <methodname>Widget::signal_button_pressed_event()</methodname>.</para>
<para>Vous pouvez trouver occasionnellement utile de gérer les événements X quand il y a quelque chose  que vous ne pouvez pas réaliser avec les signaux normaux. <classname>Gtk::Button</classname>, par exemple, ne renvoie pas les coordonnées du pointeur de souris avec le signal <literal>clicked</literal>, mais en gérant <literal>button_pressed_event</literal>, vous pouvez obtenir cette information. Les événements X sont également souvent utilisés pour gérer les touches pressées.</para>

<para>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 <literal>false</literal>, alors <application>gtkmm</application> passe l'événement au gestionnaire de signal suivant. Si la valeur est <literal>true</literal>, aucun autre gestionnaire de signal n'est appelé.</para>

<para>La gestion des événements X n'affecte pas les autres signaux de l'élément graphique. Si vous gérez <literal>button_pressed_event</literal> pour <classname>Gtk::Button</classname>, vous serez encore en mesure de gérer le signal <literal>clicked</literal>. Ils sont émis (pratiquement) simultanément.</para>

<para>Notez aussi que tous les éléments graphiques ne reçoivent pas tous les événements X par défaut. Pour recevoir des événements X supplémentaires, vous pouvez utiliser <methodname>Gtk::Widget::set_events()</methodname> avant d'afficher l'élément graphique ou <methodname>Gtk::Widget::add_events()</methodname> après. Toutefois, certains éléments graphiques doivent préalablement avoir été placés dans un élément graphique <classname>EventBox</classname>. Consultez le chapitre <link linkend="chapter-widgets-without-xwindows">Éléments graphiques sans fenêtre-X</link>.</para>

<para>Voici un exemple simple : <programlisting>
bool on_button_press(GdkEventButton* event);
Gtk::Button button("label");
button.signal_button_press_event().connect(
                  sigc::ptr_fun(&amp;on_button_press) 
                                          );
</programlisting></para>
<para>Quand la souris est au dessus du bouton et qu'un bouton de souris est pressé, <methodname>on_button_press()</methodname> est appelé.</para>

<para><literal>GdkEventButton</literal> 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 <literal>GdkEvent</literal> sont différentes selon les événements.</para>

<sect2 id="signal-handler-sequence">
<title>Séquencement des gestionnaires de signaux</title>
<para>Par défaut, les gestionnaires de signaux sont appelés successivement. Toutefois cela peut conduire à des difficultés avec les signaux des événements X. Par exemple, le gestionnaire de signal existant, ou le gestionnaire par défaut, peut renvoyer une valeur empêchant l'appel des autres gestionnaires de signal. Pour indiquer qu'un gestionnaire de signal doit être appelé avant les autres ou bien appelé dans tous les cas, vous pouvez indiquer <literal>false</literal> pour le paramètre optionnel <literal>after</literal>. Par exemple, <programlisting>
button.signal_button_press_event().connect( 
                sigc::ptr_fun(&amp;on_mywindow_button_press), 
                false );
</programlisting></para>

</sect2>

</sect1>

</appendix>



<appendix id="chapter-custom-signals">
<title>Création de vos propres signaux</title>
<para>Maintenant que nous avons vu les signaux et les gestionnaires de signal dans <application>gtkmm</application>, 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 <application>libsigc++</application>.</para>
<para>Ce n'est pas à proprement parler un problème <application>gtkmm</application> ou d'interface utilisateur. <application>gtkmm</application> utilise <application>libsigc++</application> pour implémenter ses habillages mandataires du système de signaux <application>GTK+</application>, mais pour des nouveaux signaux non GTK+, vous pouvez créer des signaux C++ purs en utilisant le modèle <classname>sigc::signal&lt;&gt;</classname>.</para>
<para>Par exemple, pour créer un signal qui envoie 2 paramètres, un de type <literal>bool</literal> et un de type <literal>int</literal>, déclarez juste un <classname>sigc::signal</classname>, ainsi : <programlisting>
sigc::signal&lt;void, bool, int&gt; signal_something;
</programlisting></para>
<para>Vous pouvez simplement déclarer ce signal comme une variable membre publique, mais certaines personnes trouvent cela détestable et préfèrent aménager son accessibilité via une fonction membre de mécanisme d'accès, ainsi : <programlisting>
class Server
{
public:
  // mécanisme d'accès au signal :
  typedef sigc::signal&lt;void, bool, int&gt; type_signal_something;
  type_signal_something signal_something();

protected:
  type_signal_something m_signal_something;
};

Server::type_signal_something Server::signal_something()
{
  return m_signal_something;
}
</programlisting></para>

<para>Vous pouvez ensuite connecter le signal en utilisant la même syntaxe que celle utilisée pour connecter les signaux <application>gtkmm</application>. Par exemple, <programlisting>
server.signal_something().connect(
  sigc::mem_fun(client, &amp;Client::on_server_something) );
</programlisting></para>

<sect1 id="chapter-custom-signals-example"><title>Exemple</title>

<para>Voici un exemple pleinement fonctionnel définissant et utilisant un signal personnalisé.</para>

<para><ulink url="http://git.gnome.org/browse/gtkmm-documentation/tree/examples/book/signals/custom/?h=">Code source</ulink></para>
<!-- start inserted example code -->
<para>File: <filename>client.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_CLIENT_H
#define GTKMM_EXAMPLE_CLIENT_H

#include &lt;sigc++/sigc++.h&gt;

//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
</programlisting>
<para>File: <filename>server.h</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#ifndef GTKMM_EXAMPLE_SERVER_H
#define GTKMM_EXAMPLE_SERVER_H

#include &lt;sigc++/sigc++.h&gt;

class Server
{
public:
  Server();
  virtual ~Server();

  void do_something();

  //signal accessor:
  typedef sigc::signal&lt;void, bool, int&gt; type_signal_something;
  type_signal_something signal_something();

protected:
  type_signal_something m_signal_something;
};

#endif //GTKMM_EXAMPLE_SERVER_H
</programlisting>
<para>File: <filename>server.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "server.h"
#include &lt;iostream&gt;

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

</programlisting>
<para>File: <filename>main.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "server.h"
#include "client.h"
#include &lt;iostream&gt;

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,
              &amp;Client::on_server_something) );

  std::cout &lt;&lt; "Before Server::do_something()" &lt;&lt; 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 &lt;&lt; "After Server::do_something()" &lt;&lt; std::endl;

  return 0;
}
</programlisting>
<para>File: <filename>client.cc</filename> (For use with gtkmm 3, not gtkmm 2)
</para>
<programlisting>
#include "client.h"
#include &lt;iostream&gt;

Client::Client()
{
}

Client::~Client()
{
}

void Client::on_server_something(bool a, int b)
{
  std::cout &lt;&lt; "Client::on_server_something() called with these parameters: "
      &lt;&lt; a &lt;&lt; ", " &lt;&lt; b &lt;&lt; std::endl;
}
</programlisting>
<!-- end inserted example code -->

</sect1>

</appendix>




<appendix id="sec-signals-comparison">
<title>Comparaison avec les autres systèmes de signalisation</title>
<para>(En aparté : <application>GTK+</application> 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 <literal>broadcasters</literal> (émetteurs), puis on y connecte des <literal>listeners</literal> (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 <application>gtkmm</application>, les objets signaux jouent le rôle d'émetteurs et les connecteurs celui de récepteurs — en quelque sorte. Plus à ce sujet plus tard.)</para>
<para>Les gestionnaires de signaux <application>gtkmm</application> sont fortement typés, alors que le code C de <application>GTK+</application> 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 à <application>Qt</application>, <application>gtkmm</application> réalise cela sans modifier le langage C++.</para>
<para>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 ».</para>
<para>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.</para>
</appendix>

<appendix id="sec-windows-installation">
        <title><application>gtkmm</application> et Win32</title>
    <para>Un des avantages majeurs de <application>gtkmm</application> est que <application>gtkmm</application> est multiplate-forme. Les programmes <application>gtkmm</application> é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.</para>
    <para><application>gtkmm</application> fonctionne actuellement avec le <ulink url="http://mingw.org/">compilateur MingW/GCC3.4</ulink> et Microsoft Visual C++ 2005 ou supérieur (y compris l'édition express disponible gratuitement). Un <ulink url="ftp://ftp.gnome.org/pub/GNOME/binaries/win32/gtkmm">installeur</ulink> de gtkmm est disponible pour Microsoft Windows. Consultez <ulink url="http://live.gnome.org/gtkmm/MSWindows/"> http://live.gnome.org/gtkmm/MSWindows</ulink> pour des instructions sur son utilisation.</para>
  <sect1 id="sec-building-on-win32">
        <title>Construction de <application>gtkmm</application> sur Win32</title>
    <para>Veuillez consulter <ulink url="http://live.gnome.org/gtkmm/MSWindows/BuildingGtkmm">http://live.gnome.org/gtkmm/MSWindows/BuildingGtkmm</ulink> pour des instructions à propos de la construction de gtkmm sur Windows.</para>

    </sect1>
</appendix>

<appendix id="chapter-working-with-source">
  <title>Travail avec le code source de gtkmm</title>
  <para>Si vous êtes intéressé par une participation au développement de <application>gtkmm</application> ou par des corrections d'anomalies dans <application>gtkmm</application>, vous aurez certainement besoin de construire la version de développement de <application>gtkmm</application>. Toutefois, vous ne devez pas installer une version de développement sur votre version stable. Vous devez l'installer à côté de l'installation existante de <application>gtkmm</application> dans un dossier séparé.</para>
  <para>
    The easiest way to do this is using <ulink url="http://developer.gnome.org/jhbuild/unstable/">jhbuild</ulink>.
    <application>jhbuild</application> 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 <application>gtkmm</application> from the source repository (git). For up-to-date information
    on <application>jhbuild</application>, please refer to the <ulink url="http://developer.gnome.org/jhbuild/unstable/">jhbuild manual</ulink>.
    If you need assistance using <application>jhbuild</application>, you should
    ask for help on the <ulink url="http://mail.gnome.org/mailman/listinfo/gnome-love">gnome-love
      mailing list</ulink>.
  </para>
  <note>
    <para>Notez que pour construire <application>gtkmm</application> à partir du dépôt git, il vous sera nécessaire de construire toutes ses dépendances à partir de git également. <application>jhbuild</application> facilite également cette opération par comparaison avec ce qu'elle représenterait normalement sans lui, mais la construction et l'installation du tout demande tout de même pas mal de temps. Vous serez probablement confrontés à des problèmes de construction, mais ils sont en règle générale rapidement corrigés si vous les rapportez.</para>
  </note>
  <sect1 id="sec-setting-up-jhbuild">
    <title>Paramétrage de jhbuild</title>
    <para>
      To set up <application>jhbuild</application>, follow the basic
      installation instructions from the <ulink url="http://developer.gnome.org/jhbuild/unstable/">jhbuild manual</ulink>.
      After you've have installd <application>jhbuild</application>, you
      should copy the sample <application>jhbuild</application> configuration
      file into your home directory by executing the following command from the
      <application>jhbuild</application> directory:
      <command>$ cp sample.jhbuildrc ~/.jhbuildrc</command>
    </para>
    <para>Le module de <application>gtkmm</application> est défini dans le jeu de modules GNOME (c'est-à-dire, <filename>gnome-2.xx.modules</filename>) ; modifiez votre fichier <filename>.jhbuildrc</filename> et fixez le paramétrage de votre module prédéfini à la dernière version de GNOME ainsi : <programlisting>moduleset = 'gnome-2.30'</programlisting></para>
    <para>Après avoir défini le module correct, vous devez indiquer à <application>jhbuild</application> quel est ou quels sont les modules à construire. Pour construire <application>gtkmm</application> et toutes ses dépendances, paramétrez la variable <varname>modules</varname> ainsi : <programlisting>modules = [ 'gtkmm', ]</programlisting></para>
    <para>Vous pouvez construire tous les modules GNOME C++ en définissant la valeur de la variable <varname>modules</varname> à celle du méta-paquet nommé <literal>meta-gnome-c++</literal> ou construire tous les modules du noyau de GNOME avec <literal>meta-gnome-desktop</literal>. La variable <varname>modules</varname> indique quels sont les modules à construire quand vous ne précisez pas explicitement quelque chose en ligne de commande. Vous pouvez toujours construire plus tard un module prédéfini différent en le définissant sur la ligne de commande (par exemple, <command>jhbuild build gtkmm</command>).</para>
    <important>
      <title>Définition d'un préfixe</title>
      <para>Par défaut, la configuration de <application>jhbuild</application> est déterminée pour installer tous les logiciels construits avec son aide avec le préfixe de dossier <filename>/opt/gnome2</filename>. Vous pouvez opter pour un préfixe différent, mais il est recommandé de le différencier de celui utilisé pour les autres logiciels installés (n'utilisez pas <filename>/usr</filename> !). Si vous avez suivi les instructions de jhbuild, ce préfixe vous appartient en tant qu'utilisateur ; vous n'aurez donc pas besoin d'être <literal>root</literal> pour lancer <application>jhbuild</application>.</para>
    </important>
  </sect1>
  <sect1 id="sec-installing-jhbuild">
    <title>Installation et utilisation de la version git de <application>gtkmm</application></title>
    <para>Après avoir configuré <application>jhbuild</application> comme décrit plus haut, la construction de <application>gtkmm</application> devrait être relativement simple. Avant de lancer une première fois <application>jhbuild</application>, effectuez la séquence de commandes suivante pour vous assurer que <application>jhbuild</application> dispose bien des outils voulus et pour vérifier que <application>jhbuild</application> est correctement paramétré : <screen>$ jhbuild bootstrap
$ jhbuild sanitycheck</screen></para>
    <sect2 id="jhbuild-installing-gtkmm">
      <title>Installation de <application>gtkmm</application> avec <application>jhbuild</application></title>
      <para>Si tout fonctionne correctement, vous devez être capable de construire <application>gtkmm</application> et toutes ses dépendances à partir du dépôt git en exécutant la commande <command>jhbuild build</command> (ou, si vous n'avez pas précisé <application>gtkmm</application> dans la variable <varname>modules</varname>, avec la commande <command>jhbuild build gtkmm</command>). </para>
      <para>Cette commande construit et installe une série de modules ; cela prend très certainement beaucoup de temps la première fois. Les fois suivantes, toutefois, cela devrait aller un peu plus vite étant donné que vous n'aurez à reconstruire que les fichiers modifiés depuis la dernière opération de construction. Sinon, après avoir construit et installé <application>gtkmm</application> la première fois, vous pouvez construire à nouveau <application>gtkmm</application> lui-même (sans reconstruire toutes ses dépendances) avec la commande <command>jhbuild buildone gtkmm</command>.</para>
    </sect2>
    <sect2 id="jhbuild-using-gtkmm">
      <title>Utilisation de la version git de <application>gtkmm</application></title>
      <para>Après avoir installé la version git de <application>gtkmm</application>, vous êtes prêt à commencer à l'utiliser et le tester. Pour utiliser la nouvelle version de <application>gtkmm</application> que vous venez d'installer, il est nécessaire de paramétrer certaines variables d'environnement pour que le script <filename>configure</filename> sache où trouver les nouvelles librairies. Fort heureusement, <application>jhbuild</application> offre une solution élégante à ce problème. L'exécution de la commande <command>jhbuild shell</command> 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 <application>jhbuild</application>.</para>
      <para>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 <command>jhbuild shell</command> pour ouvrir un nouveau shell dans l'environnement <application>jhbuild</application>. Autrement, vous pouvez lancer une commande à effet unique dans l'environnement <application>jhbuild</application> avec la commande suivante : <command>jhbuild run command-name</command>. 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.</para>

    </sect2>
  </sect1>
</appendix>

<appendix id="chapter-wrapping-c-libraries">
<title>Habillage des bibliothèques C avec gmmproc</title>
<para><application>gtkmm</application> se sert de l'utilitaire <command>gmmproc</command> 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 <classname>GObject</classname>. 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.</para>
<para>Cela implique divers outils, dont certains sont retors, mais qui au moins fonctionnent ; ils ont été utilisés avec succès par plusieurs projets.</para>

<sect1 id="sec-wrapping-build-structure">
<title>La structure de construction</title>
<para>Générer du code source pour un habillage d'API dans le style gtkmm requiert l'utilisation d'outils tels que <command>gmmproc</command> et <filename>generate_wrap_init.pl</filename>. En théorie, vous pouvez écrire vos propres fichiers de construction pour utiliser ces outils de manière appropriée, mais l'utilisation de l'infrastructure de construction fournie par le module mm-common est un meilleur choix. Prendre un module de liaison existant à titre d'exemple et l'examiner est un bon début.</para>
<para>Par exemple, disons que nous habillons une bibliothèque C nommée libexample. Elle fournit une API fondée sur <classname>GObject</classname> dont les types sont nommés, par exemple, <classname>ExampleThing</classname> et <classname>ExampleStuff</classname>.</para>

<sect2 id="copying-skeleton-project">
<title>Copie du squelette du projet</title>

<para>Selon la coutume, la librairie habillée s'appellera libsomethingmm. Nous commençons par copier <ulink url="http://git.gnome.org/cgit/mm-common/tree/skeletonmm">l'arborescence des sources squelettes</ulink> à partir du module mm-common. <programlisting>
  $ git clone git://git.gnome.org/mm-common
  $ cp -a mm-common/skeletonmm libsomethingmm
</programlisting></para>
<para>Cet arbre fournit une structure de répertoires pour les fichiers sources .hg et .ccg et pour les fichiers générés .h and .cc ; à l'aide du fichier <filename>filelist.am</filename>, Automake inclut des fichiers qui peuvent indiquer les divers fichiers utilisés sous forme de variables génériques Automake. L'arborescence ressemble alors à quelque chose comme cela après avoir renommé les répertoires de façon appropriée : <itemizedlist>
    <listitem><para><filename>libsomethingmm</filename> : le répertoire de plus haut niveau.</para>
     <itemizedlist>
         <listitem><para><filename>libsomething</filename> : contient le fichier include principal et le fichier pkg-config .pc.</para>
         <itemizedlist>
             <listitem><para><filename>src</filename> : contient les fichiers source .hg et .ccg.</para></listitem>
             <listitem><para><filename>libsomethingmm</filename> : contient les fichiers .h et .cc générés et écrits à la main.</para>
             <itemizedlist>
                 <listitem><para><filename>private</filename> : contient les fichiers générés <filename>*_p.h</filename>.</para></listitem>
             </itemizedlist>
           </listitem>
         </itemizedlist>
       </listitem>
    </itemizedlist>
  </listitem>
</itemizedlist></para>

<para>De la même manière que nous avons renommé les répertoires, nous devons renommer certains fichiers sources. Par exemple : <programlisting>
$ for f in $(find libsomethingmm -depth -name '*skeleton*'); do \
    d="${f%/*}"; b="${f##*/}"; mv "$f" "$d/${b//skeleton/libsomething}"; \
  done
</programlisting> Un certain nombre de fichiers squelettes doivent être complétés plus tard avec les données spécifiques au contenu du projet.</para>
<para>Notez que les fichiers avec l'extension <filename>.in</filename> 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.</para>
</sect2>

<sect2 id="modifying-build-files">
<title>Modification des fichiers de construction</title>

<para>Maintenant nous modifions les fichiers pour les adapter à nos besoins. Il se peut que préfériez utiliser un utilitaire rechercher-remplacer agissant sur plusieurs fichiers pour cette opération, comme <command>regexxer</command>. Notez que pratiquement tous les fichiers fournis avec l'arborescence des sources squelettes contiennent du texte à substituer. Ainsi, les substitutions doivent être effectuées globalement et non pas être limitées aux fichiers Automake et Autoconf.</para>
<para>Toutes les mentions de <varname>skeleton</varname> 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 <varname>SKELETON</varname> doivent être remplacées par « SOMETHING » ou « LIBSOMETHING » et celles de <varname>Skeleton</varname> par « Something ».</para>
<para>De même, remplacez toutes les occurrences de <varname>Joe Hacker</varname> par le nom du détenteur du copyright — vous, probablement. Faites de même pour l'adresse courriel <varname>joe@example.com</varname>.</para>

<sect3 id="modifying-configure.ac">
<title>configure.ac</title>
<para>Dans <filename>configure.ac</filename>, <itemizedlist>
  <listitem><para>la ligne <function>AC_CONFIG_SRCDIR()</function> doit mentionner un fichier de votre arborescence source. Vous pouvez modifier cela plus tard si vous ne connaissez pas encore les noms de certains fichiers à créer.</para></listitem>
  <listitem><para>il est courant pour les modules de liaison de garder trace du numéro de version de la bibliothèque qu'ils habillent. Ainsi, par exemple, si la bibliothèque C est à la version 1.23.4, alors la version initiale du module de liaison sera 1.23.0. Évitez toutefois de démarrer avec un numéro de version mineur pair, car il indique traditionnellement une version stable.</para></listitem>
  <listitem><para>la ligne <function>AC_CONFIG_HEADERS()</function> est utilisée pour générer deux ou plusieurs fichier d'en-tête de configuration. Le premier fichier d'en-tête de la liste comporte toutes les macros de configuration définies pendant le lancement de configure. Les en-têtes restants de la liste ne contiennent qu'un sous-ensemble des macros de configuration et leur fichier <filename>configh.h.in</filename> correspondant ne sera pas généré automatiquement. La raison de cette séparation est que les en-têtes de configuration avec une espace dans le nom sont installées dans votre bibliothèque et définissent des macros visibles publiquement.</para></listitem>
  <listitem><para>il se peut que la ligne <function>AC_SUBST([SOMETHINGMM_MODULES], ['...'])</function> ait besoin d'être modifiée pour vérifier les dépendances adéquates.</para></listitem>
  <listitem><para>le bloc <function>AC_CONFIG_FILES()</function> doit mentionner les noms de répertoires corrects, tels que décrits ci-dessus.</para></listitem>
</itemizedlist></para>
</sect3>

<sect3 id="modifying-makefile.am">
<title>Fichiers Makefile.am</title>
<para>Ensuite nous devons adapter les divers fichiers <filename>Makefile.am</filename> : <itemizedlist>
    <listitem><para>dans <filename>skeleton/src/Makefile.am</filename>, nous devons mentionner des valeurs correctes pour les variables génériques utilisées autre part dans le système de construction :</para>
        <variablelist>
            <varlistentry>
                <term><varname>binding_name</varname></term>
                <listitem><para>le nom de la bibliothèque, comme libsomethingmm.</para></listitem>
            </varlistentry>
            <varlistentry>
                <term><varname>wrap_init_flags</varname></term>
                <listitem><para>des marqueurs additionnels en ligne de commande passés au script  <filename>generate_wrap_init.pl</filename>, tels que le nom de l'espace de noms C++ et le préfixe du répertoire parent des fichiers include.</para></listitem>
            </varlistentry>
        </variablelist>
    </listitem>
    <listitem><para>dans <filename>skeleton/skeletonmm/Makefile.am</filename>, nous devons mentionner des valeurs correctes pour les variables génériques utilisées autre part dans le système de construction :</para>
      <variablelist>
        <varlistentry>
          <term><varname>lib_LTLIBRARIES</varname></term>
          <listitem><para>cette variable doit indiquer le nom correct de la bibliothèque, tel qu'utilisé par les noms de variables <varname>_SOURCES</varname>, <varname>_LDFLAGS</varname> et <varname>_LIBADD</varname>. Il est autorisé d'utiliser des variables substituées par <filename>configure</filename> comme <varname>@SOMETHINGMM_API_VERSION@</varname> en tant que partie de noms de variables.</para></listitem>
        </varlistentry>
        <varlistentry>
          <term><varname>AM_CPPFLAGS</varname></term>
          <listitem><para>les options en ligne de commande passées au préprocesseur C.</para></listitem>
        </varlistentry>
        <varlistentry>
          <term><varname>AM_CXXFLAGS</varname></term>
          <listitem><para>les options en ligne de commande passées au compilateur C++.</para></listitem>
        </varlistentry>
      </variablelist>
    </listitem>
  </itemizedlist></para>
</sect3>

<sect3 id="creating-hg-ccg">
<title>Création des fichiers .hg et .ccg</title>
<para>Vous devez maintenant créer vos premiers fichiers <filename>.hg</filename> et <filename>.ccg</filename> pour habiller quelques objets dans la librairie C. Il y a une paire de fichiers sources à titre d'exemple : <filename>skeleton.ccg</filename> et <filename>skeleton.hg</filename>. Faites des copies de ces fichiers si nécessaire.</para>
<para>Il faut mentionner tous les fichiers <filename>.hg</filename> et <filename>.ccg</filename> dans le fichier <filename>skeleton/src/filelist.am</filename>, traditionnellement dans la variable <varname>files_hg</varname>.</para>
<para>Tout fichier source <filename>.h</filename> et <filename>.cc</filename> non généré automatiquement doit être placé dans <filename>skeleton/skeletonmm/</filename> et énuméré dans <filename>skeleton/skeletonmm/filelist.am</filename>, traditionnellement dans les variables <varname>files_extra_h</varname> et <varname>files_extra_cc</varname>.</para>
<para>Dans le paragraphe <link linkend="sec-wrapping-hg-files">Fichiers .hg et .ccg</link> vous pouvez voir la syntaxe utilisée dans ces fichiers.</para>
</sect3>
</sect2>
</sect1>

<sect1 id="sec-wrapping-defs-files">
<title>Génération des fichiers .defs</title>
<para>Les fichiers <filename>.defs</filename> sont des fichiers texte, au format lisp, décrivant l'API de la bibliothèque C, y compris ses <itemizedlist>
  <listitem><para>objets (GObjects, éléments graphiques, interfaces, types de boîtes et structures brutes)</para></listitem>
  <listitem><para>fonctions</para></listitem>
  <listitem><para>énumérations</para></listitem>
  <listitem><para>signaux</para></listitem>
  <listitem><para>propriétés</para></listitem>
  <listitem><para>fonctions virtuelles.</para></listitem>
</itemizedlist></para>
<para>À ce moment, nous disposons d'outils séparés pour générer les diverses parties des fichiers <filename>.defs</filename>, nous les éclatons donc en fichiers séparés. Par exemple, dans le répertoire <filename>gtk/src</filename> des sources de <application>gtkmm</application>, vous trouvez ces fichiers : <variablelist>
        <varlistentry>
            <term><filename>gtk.defs</filename></term>
            <listitem><para>inclut les autres fichiers.</para></listitem>
        </varlistentry>
        <varlistentry>
            <term><filename>gtk_methods.defs</filename></term>
            <listitem><para>objets et fonctions</para></listitem>
        </varlistentry>
        <varlistentry>
            <term><filename>gtk_enums.defs</filename></term>
            <listitem><para>énumérations.</para></listitem>
        </varlistentry>
        <varlistentry>
            <term><filename>gtk_signals.defs</filename></term>
            <listitem><para>signaux et propriétés</para></listitem>
        </varlistentry>
        <varlistentry>
            <term><filename>gtk_vfuncs.defs</filename></term>
            <listitem><para>fonctions virtuelles (champs de pointeurs membres de fonction dans des structures), écrites à la main.</para></listitem>
        </varlistentry>
    </variablelist></para>

<sect2 id="generating-defs-methods">
<title>Génération des .defs pour les fonctions membres</title>
<para>Ce fichier <filename>.defs</filename> décrit les objets et leurs fonctions. Il est généré par le script <command>h2def.py</command> que vous trouverez dans le répertoire <filename>codegen</filename> des pygobject. Par exemple, <programlisting>
$ ./h2def.py /usr/include/gtk-2.0/gtk/*.h &gt; gtk_methods.defs
</programlisting></para>
</sect2>

<sect2 id="generating-defs-enums">
<title>Génération des .defs pour les énumérations</title>
<para>Ce fichier <filename>.defs</filename> décrit les types enum et leurs valeurs possibles. Il est généré par le script <filename>enum.pl</filename> que vous trouverez dans le répertoire <filename>tools</filename> de glibmm. Par exemple, <programlisting>
$ ./enum.pl /usr/include/gtk-2.0/gtk/*.h &gt; gtk_enums.defs
</programlisting></para>
</sect2>

<sect2 id="generating-defs-signals-properties">
<title>Génération des .defs pour les signaux et les propriétés</title>
<para>Ce fichier <filename>.defs</filename> décrit les signaux et les propriétés. Il est généré par l'utilitaire spécial <filename>extra_defs</filename> qui se trouve dans tout projet d'habillage, tel que <filename>gtkmm/tools/extra_defs_gen/</filename>. Par exemple  <programlisting>
$ cd tools/extra_defs_gen
$ ./generate_extra_defs &gt; gtk_signals.defs
</programlisting></para>
<para>Vous devez rédiger le code source de votre propre outil <filename>generate_extra_defs</filename> pour générer les fichiers <filename>.defs</filename> des types C GObject que vous souhaitez habiller. Dans l'arborescence des sources squelettes, le fichier source s'appelle <filename>codegen/extradefs/generate_extra_defs_skeleton.cc</filename>. Si ce n'est pas déjà fait, le fichier doit être renommé en remplaçant la variable de substitution <varname>skeleton</varname> par le nom de base de la nouvelle liaison. Le fichier <filename>codegen/Makefile.am</filename> doit également citer le nouveau nom du fichier source.</para>
<para>Ensuite, modifiez le fichier <filename>.cc</filename> pour définir les types corrects. Par exemple, il se peut que votre fonction <function>main()</function> ressemble à quelque chose comme ceci : <programlisting>
#include &lt;libsomething.h&gt;

int main(int, char**)
{
  something_init();

  std::cout &lt;&lt; get_defs(EXAMPLE_TYPE_SOMETHING)
            &lt;&lt; get_defs(EXAMPLE_TYPE_THING);
  return 0;
}
</programlisting></para>
</sect2>

<sect2 id="writing-defs-vfuncs">
<title>Écriture des .defs pour les fonctions virtuelles</title>
<para>
<programlisting>
</programlisting>
</para>
</sect2>

</sect1>

<sect1 id="sec-wrapping-hg-files">
    <title>Les fichiers .hg et .ccg</title>
    <para>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 <function>_CLASS_GOBJECT()</function> et <function>_WRAP_METHOD()</function>, à partir desquelles <command>gmmproc</command> 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.</para>
    <para>Un fichier .hg inclut habituellement certains fichiers d'en-tête, puis déclare une classe en utilisant certaines macros pour ajouter l'API ou certains comportements pour cette classe. Par exemple, <filename>button.hg</filename> de gtkmm ressemble grossièrement à ceci : <programlisting>
#include &lt;gtkmm/bin.h&gt;
#include &lt;gtkmm/stockid.h&gt;
_DEFS(gtkmm,gtk)
_PINCLUDE(gtkmm/private/bin_p.h)

namespace Gtk
{

class Button : public Bin
{
  _CLASS_GTKOBJECT(Button,GtkButton,GTK_BUTTON,Gtk::Bin,GtkBin)
public:

  _CTOR_DEFAULT
  explicit Button(const Glib::ustring&amp; label, bool mnemonic = false);
  explicit Button(const StockID&amp; stock_id);

  _WRAP_METHOD(void set_label(const Glib::ustring&amp; label), gtk_button_set_label)

  ...

  _WRAP_SIGNAL(void clicked(), "clicked")

  ...

  _WRAP_PROPERTY("label", Glib::ustring)
};

} // espace de nom Gtk
</programlisting></para>
<para>Les macros employées dans cet exemple effectuent les tâches suivantes : <variablelist>
    <varlistentry>
        <term><function>_DEFS()</function></term>
        <listitem><para>précise le répertoire de destination pour les sources générées et le nom des principaux fichiers .defs que <command>gmmproc</command> doit analyser.</para></listitem>
    </varlistentry>
    <varlistentry>
        <term><function>_PINCLUDE()</function></term>
        <listitem><para>indique à <command>gmmproc</command> d'inclure un en-tête à partir du fichier private/button_p.h.</para></listitem>
    </varlistentry>
    <varlistentry>
        <term><function>_CLASS_GTKOBJECT()</function></term>
        <listitem><para>demande à <command>gmmproc</command> d'ajouter de manière appropriée quelques définitions de types, constructeurs et fonctions membres standard à cette classe lors de l'habillage d'un type dérivé de GtkObject.</para></listitem>
    </varlistentry>
    <varlistentry>
        <term><function>_WRAP_METHOD()</function>, <function>_WRAP_SIGNAL()</function> et <function>_WRAP_PROPERTY()</function></term>
        <listitem><para>ajoute des fonctions membres pour habiller des parties de l'API C.</para></listitem>
    </varlistentry>
</variablelist></para>
<para>Les fichiers .h et .cc sont générées à partir des fichiers .hg et .ccg en les traitant de la sorte avec <command>gmmproc</command>, bien que ceci se fasse automatiquement en utilisant la structure de construction suivante : <programlisting>
$ cd gtk/src
$ /usr/lib/glibmm-2.4/proc/gmmproc -I ../../tools/m4 --defs . button . ./../gtkmm
</programlisting></para>
<para>Notez que nous appelons <command>gmmproc</command> 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.</para>
<para>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.</para>

<para>Les macros sont expliquées plus en détail dans les paragraphes suivants.</para>

<sect2 id="gmmproc-m4-conversions">
<title>Conversions m4</title>
<para>Les macros utilisées dans les fichiers .hg et .ccg ont souvent besoin de savoir comment convertir un type C++ en type C ou vice-versa. gmmproc prend cette information dans un fichier .m4 du répertoire <literal>tools/m4/</literal>. Celle-ci lui permet d'appeler une fonction C dans l'implémentation de votre fonction membre C++, en passant les paramètres appropriés à cette fonction C. Par exemple, cette macro indique à gmmproc comment convertir un pointeur GtkTreeView en pointeur Gtk::TreeView : <programlisting>
_CONVERSION(`GtkTreeView*',`TreeView*',`Glib::wrap($3)')
</programlisting></para>

<para><literal>$3</literal> sera remplacé par le nom du paramètre lorsque cette conversion est utilisée par gmmproc.</para>

<para>Quelques macros supplémentaires rendent ceci plus facile et plus cohérent. Regardez dans les fichiers .m4 pour des exemples. Ainsi :<programlisting>
_CONVERSION(`PrintSettings&amp;',`GtkPrintSettings*',__FR2P)
_CONVERSION(`const PrintSettings&amp;',`GtkPrintSettings*',__FCR2P)
_CONVERSION(`const Glib::RefPtr&lt;Printer&gt;&amp;',`GtkPrinter*',__CONVERT_REFPTR_TO_P($3))
</programlisting></para>
</sect2>


<sect2 id="gmmproc-class-macros">
<title>Macros de classes</title>
<para>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 <varname>gobject_</varname>, des définitions de types, les mécanismes d'accès aux <function>gobj()</function>, l'enregistrement du type et la fonction membre <function>Glib::wrap()</function>, entre autres choses.</para>
<para>D'autres macros, telles que <function>_WRAP_METHOD()</function> et <function>_SIGNAL()</function> ne peuvent être utilisées qu'après un appel de la macro <function>_CLASS_*</function>.</para>

<sect3 id="gmmproc-class-gobject">
<title>_CLASS_GOBJECT</title>
<para>Cette macro déclare un habillage pour un type dérivé de <classname>GObject</classname>, mais non-dérivé de <classname>GtkObject</classname>.</para>
<para><function>_CLASS_GOBJECT( C++ class, C class, C casting macro, C++ base class, C base class )</function></para>
<para>Par exemple, à partir de <filename>accelgroup.hg</filename> : <programlisting>
_CLASS_GOBJECT(AccelGroup, GtkAccelGroup, GTK_ACCEL_GROUP, Glib::Object, GObject)
</programlisting></para>
</sect3>

<sect3 id="gmmproc-class-gtkobject">
<title>_CLASS_GTKOBJECT</title>
<para>Cette macro déclare un habillage pour un type dérivé de <classname>GtkObject</classname>, tel un élément graphique ou une boîte de dialogue.</para>
<para><function>_CLASS_GTKOBJECT( C++ class, C class, C casting macro, C++ base class, C base class )</function></para>
<para>Par exemple, à partir de <filename>button.hg</filename> : <programlisting>
_CLASS_GTKOBJECT(Button, GtkButton, GTK_BUTTON, Gtk::Bin, GtkBin)
</programlisting></para>
</sect3>

<sect3 id="gmmproc-class-boxedtype">
<title>_CLASS_BOXEDTYPE</title>
<para>Cette macro déclare un habillage pour une structure non-<classname>GObject</classname>, enregistrée avec <function>g_boxed_type_register_static()</function>.</para>
<para><function>_CLASS_BOXEDTYPE( C++ class, C class, new function, copy function, free function )</function></para>
<para>Par exemple, pour <classname>Gdk::Color</classname> : <programlisting>
_CLASS_BOXEDTYPE(Color, GdkColor, NONE, gdk_color_copy, gdk_color_free)
</programlisting></para>
</sect3>

<sect3 id="gmmproc-class-boxedtype-static">
<title>_CLASS_BOXEDTYPE_STATIC</title>
<para>Cette macro déclare un habillage pour une simple structure assignable comme un <classname>GdkRectangle</classname>. Elle est semblable à <function>_CLASS_BOXEDTYPE</function>, mais la structure C n'est pas allouée dynamiquement.</para>
<para><function>_CLASS_BOXEDTYPE_STATIC( C++ class, C class )</function></para>
<para>Par exemple, pour <classname>Gdk::Rectangle</classname> : <programlisting>
_CLASS_BOXEDTYPE_STATIC(Rectangle, GdkRectangle)
</programlisting></para>
</sect3>

<sect3 id="gmmproc-class-opaque-copyable">
<title>_CLASS_OPAQUE_COPYABLE</title>
<para>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.</para>
<para><function>_CLASS_OPAQUE_COPYABLE( C++ class,
                        C class,
                        new function,
                        copy function,
                        free function )</function></para>
<para>Par exemple, pour <classname>Gdk::Region</classname> : <programlisting>
_CLASS_OPAQUE_COPYABLE(Region, 
                       GdkRegion,
                       gdk_region_new,
                       gdk_region_copy,
                       gdk_region_destroy)
</programlisting></para>
</sect3>

<sect3 id="gmmproc-class-opaque-refcounted">
<title>_CLASS_OPAQUE_REFCOUNTED</title>
<para>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 <classname>Glib::RefPtr</classname>.</para>
<para><function>_CLASS_OPAQUE_COPYABLE( C++ class, C class, new function, ref function, unref function )</function></para>
<para>Par exemple, pour <classname>Pango::Coverage</classname> : <programlisting>
_CLASS_OPAQUE_REFCOUNTED(Coverage, 
                         PangoCoverage, 
                         pango_coverage_new, 
                         pango_coverage_ref, 
                         pango_coverage_unref)
</programlisting></para>
</sect3>

<sect3 id="gmmproc-class-generic">
<title>_CLASS_GENERIC</title>
<para>Cette macro peut être utilisée pour habiller les structures n'entrant pas dans une catégorie particulière.</para>
<para><function>_CLASS_GENERIC( C++ class, C class )</function></para>
<para>Par exemple, pour <classname>Pango::AttrIter</classname> : <programlisting>
_CLASS_GENERIC(AttrIter, PangoAttrIterator)
</programlisting></para>
</sect3>

<sect3 id="gmmproc-class-interface">
<title>_CLASS_INTERFACE</title>
<para>Cette macro déclare un habillage pour un type dérivé de <classname>GObject</classname>, mais non-dérivé de <classname>GtkObject</classname>.</para>
<para><function>_CLASS_INTERFACE( C++ class, C class, C casting macro, C interface struct, Base C++ class (optional), Base C class (optional) )</function></para>
<para>Par exemple, pour <filename>celleditable.hg</filename> : <programlisting>
  _CLASS_INTERFACE(CellEditable,
                   GtkCellEditable,
                   GTK_CELL_EDITABLE,
                   GtkCellEditableIface)
</programlisting></para>
<para>Deux paramètres sont optionnels, dans le cas où l'interface dérive d'une autre interface, ce qui doit être le cas quand la GInterface a une autre GInterface prérequise. Par exemple, pour <filename>loadableicon.hg</filename> : <programlisting>
  _CLASS_INTERFACE(LoadableIcon,
                   GLoadableIcon,
                   G_LOADABLE_ICON,
                   GLoadableIconIface,
                   Icon,
                   GIcon)
</programlisting></para>
</sect3>


</sect2>

<sect2 id="gmmproc-constructor-macros">
<title>Macros de constructeurs</title>
<para>Les macros <function>_CTOR_DEFAULT()</function> et <function>_WRAP_CTOR()</function> ajoutent des constructeurs, habillant les fonctions C <function>*_new()</function> spécifiées. Ces macros supposent que l'objet C a des propriétés de même nom que les paramètres de la fonction, ce qui est habituellement le cas ; ainsi il peut fournir les paramètres directement pour l'appel de <function>g_object_new()</function>. Ces constructeurs en réalité n'appellent jamais les fonctions C <function>*_new()</function>, car gtkmm doit en fait instancier des types GTypes dérivés et les fonctions C <function>*_new()</function> ne sont conçues que comme fonctions de commodité pour les programmeurs C.</para>
<para>Quand on utilise <function>_CLASS_GOBJECT()</function>, il faut que les constructeurs soient protégés (plutôt que publics) et chaque constructeur doit posséder une fonction correspondante <function>_WRAP_CREATE()</function> dans la section public. Ceci empêche l'instanciation de la classe sans utiliser de <classname>RefPtr</classname>. Par exemple : <programlisting>
class ActionGroup : public Glib::Object
{
  _CLASS_GOBJECT(ActionGroup, GtkActionGroup,
                 GTK_ACTION_GROUP, Glib::Object, GObject)

protected:
  _WRAP_CTOR(ActionGroup(const Glib::ustring&amp; name = Glib::ustring()),
             gtk_action_group_new)

public:
  _WRAP_CREATE(const Glib::ustring&amp; name = Glib::ustring())
</programlisting></para>

<sect3 id="gmmproc-ctor-default">
<title>_CTOR_DEFAULT</title>
<para>Cette macro crée un constructeur par défaut sans paramètre.</para>
</sect3>

<sect3 id="gmmproc-wrap-ctor">
<title>_WRAP_CTOR</title>
<para>Cette macro crée un constructeur avec paramètres, équivalent à la fonction C <function>*_new()</function>. Elle n'appelle pas réellement la fonction <function>*_new()</function>, 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.</para>
</sect3>

<sect3 id="gmmproc-ctor-manual">
<title>Constructeurs codés à la main</title>
<para>Quand un constructeur doit être partiellement écrit à la main parce que, par exemple, les paramètres de la fonction C <function>*_new()</function> ne correspondent pas directement aux propriétés de l'objet ou parce que la fonction C <function>*_new()</function> fait plus qu'appeler <function>g_object_new()</function>, la macro <function>_CONSTRUCT()</function> peut s'utiliser dans le fichier .ccg pour s'économiser un peu de travail. La macro <function>_CONSTRUCT</function> prend comme paramètres une série de noms de propriétés et de valeurs. Par exemple, pour <filename>button.ccg</filename> : <programlisting>
Button::Button(const Glib::ustring&amp; label, bool mnemonic)
:
  _CONSTRUCT("label", label.c_str(), "use_underline", gboolean(mnemonic))
{}
</programlisting></para>
</sect3>

</sect2>

<sect2 id="gmmproc-method-macros">
<title>Macros pour fonctions membres</title>

<sect3 id="gmmproc-wrap-method">
<title>_WRAP_METHOD</title>
<para>Cette macro génère une fonction membre C++ habillant une fonction C.</para>
<para><function>_WRAP_METHOD( C++ method signature, C function name)</function></para>
<para>Par exemple, pour <filename>entry.hg</filename> : <programlisting>
_WRAP_METHOD(void set_text(const Glib::ustring&amp; text), gtk_entry_set_text)
</programlisting></para>
<para>La fonction C (par exemple, <function>gtk_entry_set_text</function>) est décrite plus précisément dans les fichiers .defs et les fichiers <filename>convert*.m4</filename> 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 <filename>*_docs.xml</filename> et <filename>*_docs_override.xml</filename>.</para>
<para>Il y a quelques paramètres optionnels supplémentaires : <variablelist>
    <varlistentry>
        <term>refreturn</term>
        <listitem>
            <para>effectue un appel supplémentaire à reference() sur la valeur de retour au cas où la fonction C ne fournirait pas de référence.</para>
        </listitem>
    </varlistentry>
    <varlistentry>
        <term>errthrow</term>
        <listitem>
            <para>utilise le dernier paramètre GError* de la fonction C pour déclencher une exception.</para>
        </listitem>
    </varlistentry>
    <varlistentry>
        <term>deprecated</term>
        <listitem>
            <para>place le code généré dans un bloc  #ifdef. Le texte concernant l'abandon peut être précisé en tant que paramètre optionnel.</para>
        </listitem>
    </varlistentry>
    <varlistentry>
        <term>constversion</term>
        <listitem>
            <para>appelle simplement la version non-const de la même fonction au lieu de générer du code dupliqué.</para>
        </listitem>
    </varlistentry>
</variablelist></para>
<para>Même s'il est généralement évident que les types C++ devraient être utilisés dans les fonctions membres C++, voici quelques astuces : <itemizedlist>
    <listitem><para>Objets utilisés par l'intermédiaire d'un <classname>RefPtr</classname> : passez le <classname>RefPtr</classname> en tant que référence const, par exemple, <code>const Glib::RefPtr&lt;Gtk::Action&gt;&amp; action</code>.</para></listitem>
    <listitem><para>Objets const utilisés par l'intermédiaire d'un <classname>RefPtr</classname> : si l'objet ne doit pas être modifié par la fonction, assurez-vous que l'objet est const, même si le <classname>RefPtr</classname> est déjà const, par exemple, <code>const Glib::RefPtr&lt;const Gtk::Action&gt;&amp; action</code>.</para></listitem>
<listitem><para>Wrapping <classname>GList*</classname> and
        <classname>GSList*</classname> 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 <classname>std::vector</classname> type.
        For instance, <code>std::vector&lt;
        Glib::RefPtr&lt;Action&gt; &gt;</code>.
        You may need to define a Traits type to specify how the C
        and C++ types should be converted.</para></listitem>
<listitem><para>Habillage des types de retour des <classname>GList*</classname> et <classname>GSList*</classname> : vous devez découvrir comment l'appelant libère la liste et comment il libère les éléments de la liste, à nouveau en lisant la documentation de la fonction C. Avec ces informations vous pouvez choisir le type de propriété (aucun (none), superficiel (shallow), profond (deep)) pour la règle de conversion m4, règle que vous placerez probablement directement dans le fichier .hg parce que le type de propriété dépend plutôt de la fonction que du type, par exemple : <programlisting>#m4 _CONVERSION(`GSList*',`std::vector&lt;Widget*&gt;',`Glib::SListHandler&lt;Widget*&gt;::slist_to_vector($3, Glib::OWNERSHIP_SHALLOW)')</programlisting></para></listitem>
</itemizedlist></para>
</sect3>

<sect3 id="gmmproc-wrap-method-docs-only">
<title>_WRAP_METHOD_DOCS_ONLY</title>
<para>Cette macro est comparable à la macro <function>_WRAP_METHOD()</function>, 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.</para>
<para><function>_WRAP_METHOD_DOCS_ONLY(C function name)</function></para>
<para>Par exemple, pour <filename>container.hg</filename> : <programlisting>
_WRAP_METHOD_DOCS_ONLY(gtk_container_remove)
</programlisting></para>
</sect3>

<sect3 id="gmmproc-ignore">
<title>_IGNORE()</title>
<para><command>gmmproc</command> émet un avertissement sur stdout à propos des fonctions que vous avez oubliées d'habiller, pour vous aider à être sûr d'avoir bien habillé la totalité de l'API. Mais si vous ne voulez pas habiller certaines fonctions ou si vous avez choisi de coder à la main certaines fonctions membres, vous pouvez alors utiliser la macro  _IGNORE() pour que <command>gmmproc</command> arrête de se plaindre.</para>
<para><function>_IGNORE(C function name 1, C function name2, etc)</function></para>
<para>Par exemple, pour <filename>buttonbox.hg</filename> : <programlisting>
_IGNORE(gtk_button_box_set_spacing, gtk_button_box_get_spacing,
</programlisting></para>
</sect3>

<sect3 id="gmmproc-wrap-signal">
<title>_WRAP_SIGNAL</title>
<para>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 <function>signal_clicked()</function>, qui renvoie un objet mandataire. <command>gmmproc</command> 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.</para>
<para><function>_WRAP_SIGNAL( C++ signal handler signature, C signal name)</function></para>
<para>Par exemple, à partir de <filename>button.hg</filename> : <programlisting>
_WRAP_SIGNAL(void clicked(),"clicked")
</programlisting></para>
<para>Les signaux ont généralement des pointeurs de fonction dans la structure GTK, avec une valeur d'énumération correspondante, et une fonction <function>g_signal_new()</function> dans le fichier .c.</para>
<para>Il y a quelques paramètres optionnels supplémentaires : <variablelist>
    <varlistentry>
        <term>no_default_handler</term>
        <listitem>
            <para>ne pas générer une fonction membre virtuelle <function>on_something()</function> pour faciliter la surdéfinition du gestionnaire de signal par défaut. Ce paramètre est à utiliser quand l'ajout d'un signal avec son gestionnaire par défaut casserait l'ABI (Application Binary Interface) en augmentant la taille de la table des fonctions virtuelles de la classe.</para>
        </listitem>
    </varlistentry>
</variablelist></para>
</sect3>

<sect3 id="gmmproc-wrap-property">
<title>_WRAP_PROPERTY</title>
<para>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é. <command>gmmproc</command> 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.</para>
<para><function>_WRAP_PROPERTY(C property name, C++ type)</function></para>
<para>Par exemple, à partir de <filename>button.hg</filename> : <programlisting>
_WRAP_PROPERTY("label", Glib::ustring)
</programlisting></para>
</sect3>

</sect2>

<sect2 id="gmmproc-other-macros">
<title>Autres macros :</title>
<sect3 id="gmmproc-wrap-enum">
<title>_WRAP_ENUM</title>
<para>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.</para>
<para>Par exemple, pour <filename>widget.hg</filename> : <programlisting>
_WRAP_ENUM(WindowType, GdkWindowType)
</programlisting></para>
<para>Si l'énumération n'est pas du type <classname>GType</classname>, vous devrez passer comme troisième paramètre NO_GTYPE. C'est le cas lorsqu'il n'existe pas de fonction <function>*_get_type()</function> pour l'énumération C ; mais, faites attention au fait qu'il n'est pas suffisant d'inclure un en-tête supplémentaire pour cette fonction. Vous devez également faire un rapport d'anomalie concernant l'API C étant donné que toutes les énumérations doivent être enregistrées en tant que GTypes.</para>
<para>Par exemple : <programlisting>
_WRAP_ENUM(IconLookupFlags, GtkIconLookupFlags)
</programlisting></para>
</sect3>

<sect3 id="gmmproc-wrap-gerror">
<title>_WRAP_GERROR</title>
<para>Cette macro génère une classe d'exception C++, dérivée de Glib::Error, avec un Code enum et une fonction membre code(). Vous devez préciser le nom C++ souhaité, le nom de l'énumération correspondante C et le préfixe pour les valeurs d'énumération C.</para>
<para>Cette exception peut alors être déclenchée par des fonctions membres générées par _WRAP_METHOD() avec l'option errthrow.</para>
<para>Par exemple, pour <filename>pixbuf.hg</filename> : <programlisting>
_WRAP_GERROR(PixbufError, GdkPixbufError, GDK_PIXBUF_ERROR)
</programlisting></para>
</sect3>

<sect3 id="gmmproc-member-set-get">
    <title>_MEMBER_GET / _MEMBER_SET</title>
  <para>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.</para>
  <para><function>_MEMBER_GET(C++ name, C name, C++ type, C type)</function></para>
  <para><function>_MEMBER_SET(C++ name, C name, C++ type, C type)</function></para>
  <para>Par exemple, dans <filename>rectangle.hg</filename> : <programlisting>_MEMBER_GET(x, x, int, int)</programlisting></para>
</sect3>
<sect3 id="gmmproc-member-get-set-ptr">
  <title>_MEMBER_GET_PTR / _MEMBER_SET_PTR</title>
  <para>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 <literal>const</literal> et une non-<literal>const</literal>.</para>
  <para><function>_MEMBER_GET_PTR(C++ name, C name, C++ type, C type)</function></para>
  <para><function>_MEMBER_SET_PTR(C++ name, C name, C++ type, C type)</function></para>
  <para>Par exemple, dans <filename>dialog.hg</filename> : <programlisting>
_MEMBER_GET_PTR(vbox, vbox, VBox*, GtkWidget*)
</programlisting></para>
</sect3>
<sect3 id="gmmproc-member-get-set-gobject">
  <title>_MEMBER_GET_GOBJECT / _MEMBER_SET_GOBJECT</title>
  <para>Utilisez cette macro pour fournir des obtenteurs (get) et des mutateurs (set) pour une donnée membre du type <classname>GObject</classname> nécessitant un référencement avant renvoi.</para>
  <para><function>_MEMBER_GET_GOBJECT(C++ name, C name, C++ type, C type)</function></para>
  <para><function>_MEMBER_SET_GOBJECT(C++ name, C name, C++ type, C type)</function></para>
  <para>Par exemple, dans <filename>progress.hg</filename> : <programlisting>
_MEMBER_GET_GOBJECT(offscreen_pixmap, offscreen_pixmap, Gdk::Pixmap, GdkPixmap*)
</programlisting></para>
</sect3>
</sect2>
<sect2 id="gmmproc-basic-types">
  <title>Types de base</title>
  <para>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 <literal>gboolean</literal> puisque le C++ dispose du type <literal>bool</literal>. 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++.</para>
  <segmentedlist><title>Équivalents des types de base</title>
    <?dbhtml list-presentation="table"?>
    <segtitle>Types C</segtitle>
    <segtitle>Types C++</segtitle>
    <seglistitem><seg><type>gboolean</type></seg><seg><type>bool</type></seg></seglistitem>
    <seglistitem><seg><type>gint</type></seg><seg><type>int</type></seg></seglistitem>
    <seglistitem><seg><type>guint</type></seg><seg><type>guint</type></seg></seglistitem>
    <seglistitem><seg><type>gdouble</type></seg><seg><type>double</type></seg></seglistitem>
    <seglistitem><seg><type>gunichar</type></seg><seg><type>gunichar</type></seg></seglistitem>
    <seglistitem><seg><type>gchar*</type></seg><seg><classname>Glib::ustring</classname> (ou <classname>std::string</classname> pour les noms de fichiers)</seg></seglistitem>
  </segmentedlist>
</sect2>
</sect1>


<sect1 id="sec-wrapping-hand-coded-files">
<title>Fichiers sources codés à la main</title>
<para>Vous voudrez peut-être inclure des fichiers sources additionnels qui n'auraient pas été générés par <command>gmmproc</command> à partir des fichiers <filename>.hg</filename> et <filename>.ccg</filename>. Placez-les simplement dans le répertoire <filename>libsomething/libsomethingmm</filename> et mentionnez-les dans le fichier <filename>Makefile.am</filename> dans les variables <varname>files_extra_h</varname> et <varname>files_extra_cc</varname>.</para>
</sect1>

<sect1 id="sec-wrapping-initialization">
<title>Initialisation</title>
<para>Avant de pouvoir vous servir de votre bibliothèque, il faut l'initialiser pour enregistrer les nouveaux types à disposition. La bibliothèque C que vous habillez doit aussi avoir sa propre fonction d'initialisation ; vous devrez l'appeler. Vous pouvez effectuer cette opération dans une fonction <function>init()</function> placée dans des fichiers <filename>init.h</filename> et <filename>init.cc</filename> codés à la main. Cette fonction doit initialiser vos dépendances (comme la fonction C et <application>gtkmm</application>) et appeler la fonction <function>wrap_init()</function> générée. Par exemple : <programlisting>
void init()
{
  // Définir le système des types g et la table Glib::wrap().
  Gtk::Main::init_gtkmm_internals();
  // Indiquer à la table Glib::wrap() les classes libsomethingmm.
  wrap_init();
}
</programlisting></para>
<para>L'implémentation de la fonction membre <function>wrap_init()</function> dans <filename>wrap_init.cc</filename> sera générée avec <filename>generate_wrap_init.pl</filename>, mais sa déclaration dans <filename>wrap_init.h</filename> doit être codée à la main ; vous avez besoin d'ajuster <filename>wrap_init.h</filename> de sorte que la fonction <function>init()</function> apparaisse dans un espace de noms C++ correct.</para>
</sect1>

<sect1 id="sec-wrapping-problems">
<title>Problèmes dans l'API C</title>
<para>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.</para>
<sect2 id="wrapping-predeclare-structs">
<title>Impossibilité de pré-déclarer des structures</title>
<para>Par convention, les structures sont déclarées comme suit dans les en-têtes de style glib/GTK+ : <programlisting>
typedef struct _ExampleWidget ExampleWidget;

struct _ExampleWidget
{
  ...
};
</programlisting></para>
<para>Le typedef préliminaire permet l'utilisation de cette structure dans un en-tête sans inclure sa définition complète, simplement en la pré-déclarant, par répétition de la définition de type. Cela signifie que vous n'avez pas à inclure les en-têtes de la bibliothèque C dans la bibliothèque C++ ; vous la gardez ainsi hors de votre API publique. <command>gmmproc</command> suppose qu'on utilise cette technique ; vous verrez donc des messages d'erreurs si ce n'est pas le cas.</para>
<para>L'erreur de compilation ressemble à quelque chose comme : <programlisting>
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
</programlisting> ou bien encore : <programlisting>
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'
</programlisting></para>
<para>C'est facile à corriger dans la bibliothèque C ; n'envoyez pas de correctif au mainteneur concerné.</para>
</sect2>

<sect2 id="wrapping-no-properties">
<title>Perte de propriétés</title>
<para>Par convention, les objets de style glib/GTK+ possèdent des fonctions <function>*_new()</function>, comme par exemple <function>example_widget_new()</function>, qui ne font rien de plus qu'appeler <function>g_object_new()</function> et renvoyer le résultat. Les paramètres en entrée sont fournis à la fonction <function>g_object_new()</function> en même temps que les noms des propriétés dont elles sont les valeurs. Par exemple, <programlisting>
GtkWidget* example_widget_new(int something, const char* thing)
{
        return g_object_new (EXAMPLE_TYPE_WIDGET,
                             "something", something, 
                             "thing", thing, NULL);
}
</programlisting></para>
<para>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 <function>*_new()</function>. 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.</para>
<para>Pour le moins, la fonction <function>_new()</function> 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 <function>_new()</function> pour autant que ces lignes de code utilisent une API disponible pour nous.</para>
<para>Une autre manière de contourner ce problème consiste à ajouter une fonction <function>*_construct()</function> que le constructeur C++ peut appeler après avoir instancié son propre type. Par exemple, <programlisting>
GtkWidget* example_widget_new(int something, const char* thing)
{
        ExampleWidget* widget;
        widget = g_object_new (EXAMPLE_TYPE_WIDGET, NULL);
        example_widget_construct(widget, 
                                 "something", something,
                                 "thing", thing);
}

void example_widget_construct(ExampleWidget* widget,
                              int something,
                              const char* thing)
{
        //faire quelque chose qui utilise l'API privée:
        widget-&gt;priv-&gt;thing = thing;
        do_something(something);
}
</programlisting></para>
<para>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é.</para>
</sect2>
</sect1>

<sect1 id="sec-wrapping-documentation">
<title>Documentation</title>
<para>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.</para>

<sect2 id="wrapping-reusing-c-documentation">
<title>Réutilisation de la documentation C</title>
<para>Vous pouvez souhaiter réutiliser la documentation existante de la bibliothèque C que vous êtes en train d'habiller. Les bibliothèques du style C GTK utilisent généralement gtk-doc ; les commentaires de leur code source est donc formaté pour gtk-doc avec de la documentation supplémentaire dans des fichiers .tmpl. Le script docextract_to_xml.py, situé dans le répertoire codegen de pygobject, est capable de lire ces fichiers et de générer un fichier .xml que <command>gmmproc</command> peut utiliser pour générer à son tour des commentaires doxygen. <command>gmmproc</command> essaye même de transformer la documentation pour mieux l'adapter à une API C++.</para>
<para>Par exemple, <programlisting>./docextract_to_xml.py -s /gnome/head/cvs/gtk+/gtk/ \
-s /gnome/head/cvs/gtk+/docs/reference/gtk/tmpl/ &gt; gtk_docs.xml
</programlisting></para>
<para>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 <filename>something_docs.xml</filename> vers le fichier <filename>something_docs_override.xml</filename> et en modifiant son contenu.</para>
</sect2>

<sect2 id="wrapping-documentation-build-structure">
<title>Structure de construction de la documentation</title>
<para>Si vous avez copié l'arborescence des squelettes sources de mm-common et substitué le texte à remplacer, vous disposez déjà de fichiers <filename>Makefile.am</filename> et <filename>Doxyfile.in</filename> convenables. Avec le paramétrage de construction de mm-common, la liste des fichiers d'entrée Doxygen n'est pas définie dans le fichier de configuration Doxygen, mais passée de <command>make</command> à l'entrée standard de <command>doxygen</command>. La liste des fichiers en entrée est définie par la variable <varname>doc_input</varname> du fichier <filename>Makefile.am</filename>.</para>
</sect2>

</sect1>

</appendix>

</book>
<!-- some vim settings
    vim:ts=2 sw=2 et
-->
