gtkmm-documentation master - en to fr translation catalogue (1340 entries)

en: Programming with <application>gtkmm</application>
fr: Programmation avec <application>gtkmm</application>

en: Chapter on "Timeouts".
fr: Chapitre « Fonctions à délai échu ».

en: Chapter on "Drawing with Cairo".
fr: Chapitre « Tracés avec Cairo ».

en: Chapter on "Working with gtkmm's Source Code".
fr: Chapitre « Travail sur le code source de gtkmm »

en: Chapter on "Recent Files".
fr: Chapitre « Documents récents ».

en: Parts of chapter on "Internationalization".
fr: Parties du chapitre « Internationalisation ».

en: Chapter on "Win32 Installation".
fr: Chapitre « Installation sur Win32 ».

en: Chapter on "Printing".
fr: Chapitre « Impression ».

en: Section "Build Structure" of chapter on "Wrapping C Libraries with gmmproc".
fr: Section « Structure de construction » du chapitre « Habillage des bibliothèques C avec gmmproc ».

note: This text is copied from the introduction.
en: This book explains key concepts of the <application>gtkmm</application> C++ API for creating user interfaces. It also introduces the main user interface elements ("widgets").
fr: 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).

en: Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. You may obtain a copy of the GNU Free Documentation License from the Free Software Foundation by visiting their Web site or by writing to: Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
fr: 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.

en: This book
fr: Cet ouvrage

en: This book explains key concepts of the <application>gtkmm</application> C++ API for creating user interfaces. It also introduces the main user interface elements ("widgets"). Although it mentions classes, constructors, and methods, it does not go into great detail. Therefore, for full API information you should follow the links into the reference documentation.
fr: 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.

en: This book assumes a good understanding of C++, and how to create C++ programs.
fr: Cet ouvrage suppose une bonne connaissance du C++, ainsi que des méthodes de création de programmes avec ce langage.

en: We would very much like to hear of any problems you have learning <application>gtkmm</application> with this document, and would appreciate input regarding improvements. Please see the <link linkend="chapter-contributing">Contributing</link> section for further information.
fr: 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.

en: <application>gtkmm</application> is a C++ wrapper for <ulink url="http://www.gtk.org/">GTK+</ulink>, a library used to create graphical user interfaces. It is licensed using the LGPL license, so you can develop open software, free software, or even commercial non-free software using <application>gtkmm</application> without purchasing licenses.
fr: <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.

en: <application>gtkmm</application> was originally named gtk-- because GTK+ already has a + in the name. However, as -- is not easily indexed by search engines the package generally went by the name <application>gtkmm</application>, and that's what we stuck with.
fr: À 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.

en: Why use <application>gtkmm</application> instead of GTK+?
fr: Pourquoi utiliser <application>gtkmm</application> plutôt que GTK+ ?

en: <application>gtkmm</application> allows you to write code using normal C++ techniques such as encapsulation, derivation, and polymorphism. As a C++ programmer you probably already realise that this leads to clearer and better organized code.
fr: <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é.

en: <application>gtkmm</application> is more type-safe, so the compiler can detect errors that would only be detected at run time when using C. This use of specific types also makes the API clearer because you can see what types should be used just by looking at a method's declaration.
fr: <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.

en: Inheritance can be used to derive new widgets. The derivation of new widgets in GTK+ C code is so complicated and error prone that almost no C coders do it. As a C++ developer you know that derivation is an essential Object Orientated technique.
fr: 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.

en: Member instances can be used, simplifying memory management. All GTK+ C widgets are dealt with by use of pointers. As a C++ coder you know that pointers should be avoided where possible.
fr: 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.

en: <application>gtkmm</application> involves less code compared to GTK+, which uses prefixed function names and lots of cast macros.
fr: 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.

en: <application>gtkmm</application> compared to Qt
fr: <application>gtkmm</application> comparée à <application>Qt</application>

en: Trolltech's Qt is the closest competition to <application>gtkmm</application>, so it deserves discussion.
fr: Qt de Trolltech est le plus proche concurrent de <application>gtkmm</application> ; cela mérite une explication.

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

en: <application>gtkmm</application> is a wrapper
fr: <application>gtkmm</application> est un habillage

en: <application>gtkmm</application> is not a native C++ toolkit, but a C++ wrapper of a C toolkit. This separation of interface and implementation has advantages. The <application>gtkmm</application> developers spend most of their time talking about how <application>gtkmm</application> can present the clearest API, without awkward compromises due to obscure technical details. We contribute a little to the underlying GTK+ code base, but so do the C coders, and the Perl coders and the Python coders, etc. Therefore GTK+ benefits from a broader user base than language-specific toolkits - there are more implementers, more developers, more testers, and more users.
fr: <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.

en: Dependencies
fr: Dépendances

en: Before attempting to install <application>gtkmm</application> 2.4, you might first need to install these other packages.
fr: Avant de procéder à l'installation de <application>gtkmm</application> 2.4, il se peut que vous ayez besoin d'installer au préalable d'autres paquets logiciels.

en: These dependencies have their own dependencies, including the following applications and libraries:
fr: Ces dépendances ont elles-mêmes leurs propres dépendances, comprenant les applications et bibliothèques suivantes :

en: Unix and Linux
fr: Unix et Linux

en: Prebuilt Packages
fr: Paquets logiciels pré-compilés

en: Recent versions of <application>gtkmm</application> are packaged by nearly every major Linux distribution these days. So, if you use Linux, you can probably get started with <application>gtkmm</application> by installing the package from the official repository for your distribution. Distributions that include <application>gtkmm</application> in their repositories include Debian, Ubuntu, Red Hat, Fedora, Mandriva, Suse, and many others.
fr: 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.

en: The names of the <application>gtkmm</application> packages vary from distribution to distribution (e.g. <application>libgtkmm3.0-dev</application> on Debian and Ubuntu or <application>gtkmm30-devel</application> on Red Hat Fedora), so check with your distribution's package management program for the correct package name and install it like you would any other package.
fr: 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.

en: 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> 2.8 supplied by Debian's <application>libgtkmm2.4-dev</application> package.
fr: Les noms des paquets ne changent pas quand de nouvelles versions de <application>gtkmm</application> compatibles API/ABI(Application Binary Interface) sont publiées. Si ce n'était pas le cas, elles ne seraient pas compatibles. Donc ne soyez pas surpris, par exemple, de trouver la version 2.8 de <application>gtkmm</application> livrée dans le paquet <application>libgtkmm2.4-dev</application> par Debian.

en: Installing From Source
fr: Installation à partir des sources

en: If your distribution does not provide a pre-built <application>gtkmm</application> package, or if you want to install a different version than the one provided by your distribution, you can also install <application>gtkmm</application> from source. The source code for <application>gtkmm</application> can be downloaded from <ulink url="http://www.gtkmm.org/"/>.
fr: 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/"/>.

en: After you've installed all of the dependencies, download the <application>gtkmm</application> source code, unpack it, and change to the newly created directory. <application>gtkmm</application> can be built and installed with the following sequence of commands:
fr: 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 :

en: Remember that on a Unix or Linux operating system, you will probably need to be <literal>root</literal> to install software. The <command>su</command> command will allow you to enter the <literal>root</literal> password and have <literal>root</literal> status temporarily.
fr: 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>.

en: The <filename>configure</filename> script will check to make sure all of the required dependencies are already installed. If you are missing any dependencies, it will exit and display an error.
fr: 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.

en: By default, <application>gtkmm</application> will be installed under the <filename>/usr/local</filename> directory. On some systems you may need to install to a different location. For instance, on Red Hat Linux systems you might use the <literal>--prefix</literal> option with configure, like so: <screen>
    # ./configure --prefix=/usr
    </screen>
fr: 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>

en: You should be very careful when installing to standard system prefixes such as <filename>/usr</filename>. Linux distributions install software packages to <filename>/usr</filename>, so installing a source package to this prefix could corrupt or conflict with software installed using your distribution's package-management system. Ideally, you should use a separate prefix for all software you install from source.
fr: 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.

en: If you want to help develop <application>gtkmm</application> or experiment with new features, you can also install <application>gtkmm</application> from git. Most users will never need to do this, but if you're interested in helping with <application>gtkmm</application> development, see the <link linkend="chapter-working-with-source">Working with gtkmm's Source Code</link> appendix.
fr: 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>

en: Microsoft Windows
fr: Windows Microsoft

en: GTK+ and <application>gtkmm</application> were designed to work well with Microsoft Windows, and the developers encourage its use on the win32 platform. However, Windows has no standard installation system for development libraries. Please see the <ulink url="http://live.gnome.org/gtkmm/MSWindows">Windows Installation</ulink> page for Windows-specific installation instructions and notes.
fr: 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>.

en: Basics
fr: Fondamentaux

en: This chapter will introduce some of the most important aspects of <application>gtkmm</application> coding. These will be demonstrated with simple working example code. However, this is just a taster, so you need to look at the other chapters for more substantial information.
fr: 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.

en: Your existing knowledge of C++ will help you with <application>gtkmm</application> as it would with any library. Unless we state otherwise, you can expect <application>gtkmm</application> classes to behave like any other C++ class, and you can expect to use your existing C++ techniques with <application>gtkmm</application> classes.
fr: 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.

en: Simple Example
fr: Un exemple simple

en: To begin our introduction to <application>gtkmm</application>, we'll start with the simplest program possible. This program will create an empty 200 x 200 pixel window.
fr: 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.

en: Source Code
fr: Code source

en: We will now explain each line of the example
fr: Détaillons maintenant chaque ligne de l'exemple

en: All <application>gtkmm</application> programs must include certain <application>gtkmm</application> headers; <literal>gtkmm.h</literal> includes the entire <application>gtkmm</application> kit. This is usually not a good idea, because it includes a megabyte or so of headers, but for simple programs, it suffices.
fr: 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.

en: The next line: <placeholder-1/> creates a <classname>Gtk::Main</classname> object. This is needed in all <application>gtkmm</application> applications. The constructor for this object initializes <application>gtkmm</application>, and checks the arguments passed to your application on the command line, looking for standard options such as <literal>-display</literal>. It takes these from the argument list, leaving anything it does not recognize for your application to parse or ignore. This ensures that all <application>gtkmm</application> applications accept the same set of standard arguments.
fr: La ligne suivante : <placeholder-1/> 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.

en: The next two lines of code create and display a window:
fr: Les deux lignes de code suivantes créent et affichent une fenêtre :

en: The last line shows the window and enters the <application>gtkmm</application> main processing loop, which will finish when the window is closed.
fr: 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.

en: After putting the source code in <literal>simple.cc</literal> you can compile the above program with gcc using: <placeholder-1/> Note that you must surround the <literal>pkg-config</literal> invocation with backquotes. Backquotes cause the shell to execute the command inside them, and to use the command's output as part of the command line.
fr: Après avoir incorporé ces lignes de code source dans <literal>simple.cc</literal>, vous pouvez compiler ce programme avec la commande : <placeholder-1/> 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.

en: Headers and Linking
fr: Fichiers d'en-têtes et édition des liens

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

en: To simplify compilation, we use <literal>pkg-config</literal>, which is present in all (properly installed) <application>gtkmm</application> installations. This program 'knows' what compiler switches are needed to compile programs that use <application>gtkmm</application>. The <literal>--cflags</literal> option causes <literal>pkg-config</literal> to output a list of include directories for the compiler to look in; the <literal>--libs</literal> option requests the list of libraries for the compiler to link with and the directories to find them in. Try running it from your shell-prompt to see the results on your system.
fr: 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.

en: However, this is even simpler when using the <function>PKG_CHECK_MODULES()</function> macro in a standard configure.ac file with autoconf and automake. For instance: <placeholder-1/> This checks for the presence of gtkmm and defines MYAPP_LIBS and MYAPP_CFLAGS for use in your Makefile.am files.
fr: 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 : <placeholder-1/> 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>.

en: gtkmm-2.4 is the name of the current stable API. There was an older API called gtkmm-2-0 which installs in parallel when it is available. There are several versions of gtkmm-2.4, such as gtkmm 2.10. 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-3.0 API which would install in parallel with gtkmm-2.4 without affecting existing applications.
fr: gtkmm-2.4 est le nom de l'actuelle API stable. Il existe une API plus ancienne nommée gtkmm-2-0 qui s'installe en parallèle quand elle est disponible. Il existe plusieurs versions de gtkmm-2.4, comme gtkmm 2.10. Notez que le nom de l'API ne change pas pour chaque version car il y aurait rupture de compatibilité de l'API et ABI. En théorie, une future API gtkmm-3.0 API devrait paraître. Elle s'installera en parallèle avec gtkmm-2.4 sans affecter les applications existantes.

en: Note that if you mention extra modules in addition to gtkmm-2.4, they should be separated by spaces, not commas.
fr: Notez que si vous mentionnez des modules complémentaires en plus de ceux pour gtkmm-2.4, ils doivent être séparés par des espaces et non des virgules.

en: Openismus has more <ulink url="http://www.openismus.com/documents/linux/automake/automake.shtml">basic help with automake and autoconf</ulink>.
fr: Openismus fournit une <ulink url="http://www.openismus.com/documents/linux/automake/automake.shtml">Aide sur les fondamentaux avec automake et autoconf</ulink>.

en: Widgets
fr: Éléments graphiques

en: <application>gtkmm</application> applications consist of windows containing widgets, such as buttons and text boxes. In some other systems, widgets are called "controls". For each widget in your application's windows, there is a C++ object in your application's code. So you just need to call a method of the widget's class to affect the visible widget.
fr: 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.

en: Widgets are arranged inside container widgets such as frames and notebooks, in a hierarchy of widgets within widgets. Some of these container widgets, such as <classname>Gtk::Grid</classname>, are not visible - they exist only to arrange other widgets. Here is some example code that adds 2 <classname>Gtk::Button</classname> widgets to a <classname>Gtk::VBox</classname> container widgets: <placeholder-1/> and here is how to add the <classname>Gtk::VBox</classname>, containing those buttons, to a <classname>Gtk::Frame</classname>, which has a visible frame and title: <placeholder-2/>
fr: 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> : <placeholder-1/> 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 : <placeholder-2/>

en: Most of the chapters in this book deal with specific widgets. See the <link linkend="chapter-container-widgets">Container Widgets</link> section for more details about adding widgets to container widgets.
fr: 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.

en: Although you can specify the layout and appearance of windows and widgets with C++ code, you will probably find it more convenient to design your user interfaces with <literal>Glade</literal> and load them at runtime with <literal>Gtk::Builder</literal>. See the <link linkend="chapter-builder">Glade and Gtk::Builder</link> chapter.
fr: 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>.

en: Although <application>gtkmm</application> widget instances have lifetimes and scopes just like those of other C++ classes, <application>gtkmm</application> has an optional time-saving feature that you will see in some of the examples. <function>Gtk::manage()</function> allows you to say that a child widget is owned by the container into which you place it. This allows you to <function>new</function> the widget, add it to the container and forget about deleting it. You can learn more about <application>gtkmm</application> memory management techniques in the <link linkend="chapter-memory">Memory Management chapter</link>.
fr: 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>.

en: Signals
fr: Signaux

en: <application>gtkmm</application>, like most GUI toolkits, is <emphasis>event-driven</emphasis>. When an event occurs, such as the press of a mouse button, the appropriate signal will be <emphasis>emitted</emphasis> by the Widget that was pressed. Each Widget has a different set of signals that it can emit. To make a button click result in an action, we set up a <emphasis>signal handler</emphasis> to catch the button's "clicked" signal.
fr: <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.

en: <application>gtkmm</application> uses the libsigc++ library to implement signals. Here is an example line of code that connects a Gtk::Button's "clicked" signal with a signal handler called "on_button_clicked": <placeholder-1/>
fr: <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 » : <placeholder-1/>

en: For more detailed information about signals, see the <link linkend="chapter-signals">appendix</link>.
fr: Pour plus de détails à propos des signaux, consultez cette <link linkend="chapter-signals">annexe</link>.

en: For information about implementing your own signals rather than just connecting to the existing <application>gtkmm</application> signals, see the <link linkend="chapter-custom-signals">appendix</link>.
fr: 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>.

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

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

en: One of the benefits of UTF-8 is that you don't need to use it unless you want to, so you don't need to retrofit all of your code at once. <classname>std::string</classname> will still work for 7-bit ASCII strings. But when you try to localize your application for languages like Chinese, for instance, you will start to see strange errors, and possible crashes. Then all you need to do is start using <classname>Glib::ustring</classname> instead.
fr: 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.

en: Note that UTF-8 isn't compatible with 8-bit encodings like ISO-8859-1. For instance, German umlauts are not in the ASCII range and need more than 1 byte in the UTF-8 encoding. If your code contains 8-bit string literals, you have to convert them to UTF-8 (e.g. the Bavarian greeting "Grüß Gott" would be "Gr\xC3\xBC\xC3\x9F Gott").
fr: 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 »).

en: You should avoid C-style pointer arithmetic, and functions such as strlen(). In UTF-8, each character might need anywhere from 1 to 6 bytes, so it's not possible to assume that the next byte is another character. <classname>Glib::ustring</classname> worries about the details of this for you so you can use methods such as Glib::ustring::substr() while still thinking in terms of characters instead of bytes.
fr: 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.

en: Unlike the Windows UCS-2 Unicode solution, this does not require any special compiler options to process string literals, and it does not result in Unicode executables and libraries which are incompatible with ASCII ones.
fr: 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.

en: Reference
fr: Référence

en: See the <link linkend="chapter-internationalization">Internationalization</link> section for information about providing the UTF-8 string literals.
fr: Consultez le chapitre sur l'<link linkend="chapter-internationalization">Internationalisation</link> pour des informations concernant les chaînes littérales UTF-8.

en: Intermediate types
fr: Types intermédiaires

en: <classname>Glib::StringArrayHandle</classname> or <classname>Glib::ArrayHandle&lt;Glib::ustring&gt;</classname>: Use <classname>std::vector&lt;Glib::ustring&gt;</classname>, <classname>std::list&lt;Glib::ustring&gt;</classname>, <type>const char*[]</type>, etc.
fr: <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.

en: <classname>Glib::ListHandle&lt;Gtk::Widget*&gt;</classname>: Use <classname>std::vector&lt;Gtk::Widget*&gt;</classname>, <classname>std::list&lt;Gtk::Widget*&gt;</classname>, etc.
fr: <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.

en: <classname>Glib::SListHandle&lt;Gtk::Widget*&gt;</classname>: Use <classname>std::vector&lt;Gtk::Widget*&gt;</classname>, <classname>std::list&lt;Gtk::Widget*&gt;</classname>, etc.
fr: <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.

en: Some parts of the <application>gtkmm</application> API use 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>. You should not declare these types yourself -- you should use whatever Standard C++ container you prefer instead. <application>gtkmm</application> will do the conversion for you. Here are some of these intermediate types: <placeholder-1/>
fr: Certaines parties de l'API <application>gtkmm</application> utilisent des conteneurs de données intermédiaires, tels que <classname>Glib::StringArrayHandle</classname>, à la place des conteneurs normalisés spécifiques C++ comme <classname>std::vector</classname> ou <classname>std::list</classname>. Vous ne devez pas déclarer de variables de ces types vous-même — vous devez utiliser à la place n'importe quel conteneur normalisé C++, celui que vous préférez. <application>gtkmm</application> fera les conversions pour vous. Voici quelques-uns de ces types intermédiaires : <placeholder-1/>

en: Mixing C and C++ APIs
fr: Mélange des API C et C++

en: You can use C APIs which do not yet have convenient C++ interfaces. It is generally not a problem to use C APIs from C++, and <application>gtkmm</application> helps by providing access to the underlying C object, and providing an easy way to create a C++ wrapper object from a C object, provided that the C API is also based on the GObject system.
fr: 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.

en: To use a <application>gtkmm</application> instance with a C function that requires a C GObject instance, use the <function>gobj()</function> function to obtain a pointer to the underlying GObject instance. For instance
fr: 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

en: 
    Gtk::Button* button = new Gtk::Button("example");
    gtk_button_do_something_new(button-&gt;gobj());
fr: 
    Gtk::Button* button = new Gtk::Button("exemple");
    gtk_button_do_something_new(button-&gt;gobj());

en: To obtain a <application>gtkmm</application> instance from a C GObject instance, use the Glib::wrap() function. For instance
fr: Pour obtenir un objet <application>gtkmm</application> à partir d'un élément GObject C, utilisez la fonction  Glib::wrap(). Par exemple

en: Hello World in <application>gtkmm</application>
fr: Hello World en <application>gtkmm</application>

en: We've now learned enough to look at a real example. In accordance with an ancient tradition of computer science, we now introduce Hello World, a la <application>gtkmm</application>:
fr: 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> :

en: Try to compile and run it before going on. You should see something like this:
fr: Essayez de le compiler et de le lancer avant de poursuivre. Vous devriez voir quelque chose comme :

en: Pretty thrilling, eh? Let's examine the code. First, the <classname>HelloWorld</classname> class:
fr: Tout à fait palpitant, n'est-ce-pas ? Examinons le code. D'abord, la classe <classname>HelloWorld</classname> :

en: class HelloWorld : public Gtk::Window
    {
    
    public:
      HelloWorld();
      virtual ~HelloWorld();
    
    protected:
      //Signal handlers:
      virtual void on_button_clicked();
    
      //Member widgets:
      Gtk::Button m_button;
    };
fr: 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;
    };

en: This class implements the "Hello World" window. It's derived from <classname>Gtk::Window</classname>, and has a single <classname>Gtk::Button</classname> as a member. We've chosen to use the constructor to do all of the initialisation work for the window, including setting up the signals. Here it is, with the comments omitted:
fr: 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 :

en: Notice that we've used an initialiser statement to give the <literal>m_button</literal> object the label "Hello World".
fr: Notez que nous avons utilisé une instruction d'initialisation pour étiqueter l'objet <literal>m_button</literal> avec « Hello World ».

en: Next we call the Window's <methodname>set_border_width()</methodname> method. This sets the amount of space between the sides of the window and the widget it contains.
fr: 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.

en: We then hook up a signal handler to <literal>m_button</literal>'s <literal>clicked</literal> signal. This prints our friendly greeting to <literal>stdout</literal>.
fr: 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.

en: Next, we use the Window's <methodname>add()</methodname> method to put <literal>m_button</literal> in the Window. (<methodname>add()</methodname> comes from <classname>Gtk::Container</classname>, which is described in the chapter on container widgets.) The <methodname>add()</methodname> method places the Widget in the Window, but it doesn't display the widget. <application>gtkmm</application> widgets are always invisible when you create them - to display them, you must call their <methodname>show()</methodname> method, which is what we do in the next line.
fr: 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.

en: Now let's look at our program's <function>main()</function> function. Here it is, without comments:
fr: Maintenant examinons la fonction <function>main()</function> du programme. La voici, sans commentaire :

en: First we instantiate an object called <literal>kit</literal>. This is of type <classname>Gtk::Main</classname>. Every <application>gtkmm</application> program must have one of these. We pass our command-line arguments to its constructor. It takes the arguments it wants, and leaves you the rest, as we described earlier.
fr: 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.

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

en: Buttons
fr: Boutons

en: <application>gtkmm</application> provides four basic types of buttons:
fr: <application>gtkmm</application> met à votre disposition quatre types basiques de boutons :

en: Push-Buttons
fr: Bouton poussoir

en: <ulink url="http://library.gnome.org/devel/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.
fr: <ulink url="http://library.gnome.org/devel/gtkmm/unstable/classGtk_1_1Button.html"><classname>Gtk::Button</classname></ulink>. C'est le bouton classique, traditionnellement orné d'une étiquette ou d'une image. Le fait de le presser déclenche une action. Consultez le paragraphe <link linkend="sec-pushbuttons">Bouton</link>.

en: Toggle buttons
fr: Bouton bascule

en: <ulink url="http://library.gnome.org/devel/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.
fr: <ulink url="http://library.gnome.org/devel/gtkmm/unstable/classGtk_1_1ToggleButton.html"><classname>Gtk::ToggleButton</classname></ulink>. Contrairement au précédent, qui se relève après avoir été pressé, un bouton bascule reste en position basse jusqu'à ce que vous le pressiez à nouveau. Il est utile en tant qu'interrupteur marche/arrêt. Consultez le paragraphe <link linkend="sec-toggle-buttons">Bouton bascule</link>.

en: Checkboxes
fr: Case à cocher

en: <ulink url="http://library.gnome.org/devel/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.
fr: <ulink url="http://library.gnome.org/devel/gtkmm/unstable/classGtk_1_1CheckButton.html"><classname>Gtk::CheckButton</classname></ulink>. Elle agit comme un bouton-bascule, mais affiche son état dans un petit carré. L'étiquette est disposée sur son côté. Elle peut s'utiliser dans la plupart des situations où l'on doit définir un état actif/inactif. Consultez le paragraphe <link linkend="sec-checkboxes">Cases à cocher</link>.

en: Radio buttons
fr: Bouton radio

en: <ulink url="http://library.gnome.org/devel/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.
fr: <ulink url="http://library.gnome.org/devel/gtkmm/unstable/classGtk_1_1RadioButton.html"><classname>Gtk::RadioButton</classname></ulink>. Ainsi dénommé d'après le comportement des sélecteurs de stations sur les anciens autoradios, ce bouton s'utilise en groupe pour des choix mutuellement exclusifs. Presser sur l'un d'eux désélectionne tout autre bouton du groupe. Il ressemble à une case à cocher (petit élément graphique avec une étiquette sur le côté), mais il a généralement un aspect différencié. Consultez le paragraphe <link linkend="sec-radio-buttons">Bouton radio</link>.

en: Note that, due to GTK+'s theming system, the appearance of these widgets will vary. In the case of checkboxes and radio buttons, they may vary considerably.
fr: 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.

en: Button
fr: Bouton

en: Constructors
fr: Constructeurs

en: There are two ways to create a Button. You can specify a label string in the <classname>Gtk::Button</classname> constructor, or set it later with <methodname>set_label()</methodname>.
fr: 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>.

en: To define an accelerator key for keyboard navigation, place an underscore before one of the label's characters and specify <literal>true</literal> for the optional <literal>mnemonic</literal> parameter. For instance:
fr: 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 :

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

en: Wherever possible you should use Stock items, to ensure consistency with other applications, and to improve the appearance of your applications by using icons. For instance, <placeholder-1/> This will use standard text, in all languages, with standard keyboard accelerators, with a standard icon.
fr: 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, <placeholder-1/> utilise un texte normalisé, dans toutes les langues, avec un raccourci clavier et une icône standard.

en: <classname>Gtk::Button</classname> is also a container so you could put any other widget, such as a <classname>Gtk::Image</classname> into it.
fr: <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>.

en: Example
fr: Exemple

en: This example creates a button with a picture and a label.
fr: Cet exemple crée un bouton avec image et étiquette.

en: buttons example
fr: Exemple de bouton

en: The <classname>Gtk::Button</classname> widget has the following signals, but most of the time you will just handle the <literal>clicked</literal> signal:
fr: 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é) :

en: pressed
fr: pressed (enfoncé)

en: Emitted when the button is pressed.
fr: Émis quand le bouton est enfoncé.

en: released
fr: released (relâché)

en: Emitted when the button is released.
fr: Émis quand le bouton est relâché.

en: clicked
fr: clicked (cliqué)

en: Emitted when the button is pressed and released.
fr: Émis quand le bouton est enfoncé et relâché.

en: enter
fr: enter (entré)

en: Emitted when the mouse pointer moves over the button's window.
fr: Émis quand le pointeur de souris entre dans la fenêtre du bouton.

en: leave
fr: leave (quitté)

en: Emitted when the mouse pointer leaves the button's window.
fr: Émis lorsque le pointeur de souris sort de la fenêtre du bouton.

en: ToggleButton
fr: Bouton bascule

en: <classname>ToggleButton</classname>s are like normal <classname>Button</classname>s, but when clicked they remain activated, or pressed, until clicked again.
fr: 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.

en: To retrieve the state of the <classname>ToggleButton</classname>, you can use the <methodname>get_active()</methodname> method. This returns <literal>true</literal> if the button is "down". You can also set the toggle button's state, with <methodname>set_active()</methodname>. Note that, if you do this, and the state actually changes, it causes the "clicked" signal to be emitted. This is usually what you want.
fr: 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é.

en: You can use the <methodname>toggled()</methodname> method to toggle the button, rather than forcing it to be up or down: This switches the button's state, and causes the <literal>toggled</literal> signal to be emitted.
fr: 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.

en: <classname>Gtk::ToggleButton</classname> is most useful as a base class for the <classname>Gtk::CheckButton</classname> and <classname>Gtk::RadioButton</classname> classes.
fr: <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>.

en: CheckButton
fr: Case à cocher

en: <classname>Gtk::CheckButton</classname> inherits from <classname>Gtk::ToggleButton</classname>. The only real difference between the two is <classname>Gtk::CheckButton</classname>'s appearance. You can check, set, and toggle a checkbox using the same member methods as for <classname>Gtk::ToggleButton</classname>.
fr: 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>.

en: RadioButton
fr: Bouton radio

en: Like checkboxes, radio buttons also inherit from <classname>Gtk::ToggleButton</classname>, but these work in groups, and only one RadioButton in a group can be selected at any one time.
fr: 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é.

en: Groups
fr: Groupes

en: There are two ways to set up a group of radio buttons. The first way is to create the buttons, and set up their groups afterwards. Only the first two constructors are used. In the following example, we make a new window class called <classname>RadioButtons</classname>, and then put three radio buttons in it:
fr: 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 :

en: class RadioButtons : public Gtk::Window
    {
    public:
        RadioButtons();
    
    protected:
        Gtk::RadioButton m_rb1, m_rb2, m_rb3;
    };
    
    RadioButtons::RadioButtons()
      : m_rb1("button1"),
        m_rb2("button2"),
        m_rb3("button3")
    {
        Gtk::RadioButton::Group group = m_rb1.get_group();
        m_rb2.set_group(group);
        m_rb3.set_group(group);
    }
fr: 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);
    }

en: We told <application>gtkmm</application> to put all three <classname>RadioButton</classname>s in the same group by obtaining the group with <methodname>get_group()</methodname> and using <methodname>set_group()</methodname> to tell the other <classname>RadioButton</classname>s to share that group.
fr: 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.

en: m_rb2.set_group(m_rb1.get_group()); //doesn't work
fr: m_rb2.set_group(m_rb1.get_group()); // ne fonctionne pas !

en: Note that you can't just do <placeholder-1/> because the group is modified by <methodname>set_group()</methodname> and therefore non-const.
fr: Notez qu'il n'est pas possible d'écrire simplement <placeholder-1/> étant donné que <methodname>set_group()</methodname> modifie le groupe et qu'en conséquence, le pointeur n'est pas constant.

en: The second way to set up radio buttons is to make a group first, and then add radio buttons to it. Here's an example:
fr: 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 :

en: class RadioButtons : public Gtk::Window
    {
    public:
        RadioButtons();
    };
    
    RadioButtons::RadioButtons()
    {
        Gtk::RadioButton::Group group;
        Gtk::RadioButton *m_rb1 = Gtk::manage(
          new Gtk::RadioButton(group,"button1"));
        Gtk::RadioButton *m_rb2 = manage(
          new Gtk::RadioButton(group,"button2"));
          Gtk::RadioButton *m_rb3 = manage(
            new Gtk::RadioButton(group,"button3"));
    }
fr: 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"));
    }

en: We made a new group by simply declaring a variable, <literal>group</literal>, of type <classname>Gtk::RadioButton::Group</classname>. Then we made three radio buttons, using a constructor to make each of them part of <literal>group</literal>.
fr: 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>.

en: Methods
fr: Fonctions membres

en: <classname>RadioButtons</classname> are "off" when created; this means that when you first make a group of them, they will all be off. Don't forget to turn one of them on using <methodname>set_active()</methodname>:
fr: À 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> :

en: The following example demonstrates the use of <classname>RadioButton</classname>s:
fr: L'exemple suivant montre l'utilisation de la classe <classname>RadioButton</classname> :

en: Range Widgets
fr: Éléments graphiques à plage de réglage

en: <classname>Gtk::Scale</classname> and <classname>Gtk::Scrollbar</classname> both inherit from <classname>Gtk::Range</classname> and share much functionality. They contain a "trough" and a "slider" (sometimes called a "thumbwheel" in other GUI environments). Dragging the slider with the pointer moves it within the trough, while clicking in the trough advances the slider towards the location of the click, either completely, or by a designated amount, depending on which mouse button is used. This should be familiar scrollbar behaviour.
fr: 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.

en: As will be explained in the <link linkend="chapter-adjustment">Adjustment</link> section, all Range widgets are associated with a <classname>Adjustment</classname> object. To change the lower, upper, and current values used by the widget you need to use the methods of its <classname>Adjustment</classname>, which you can get with the <methodname>get_adjustment()</methodname> method. The <classname>Range</classname> widgets' default constructors create an <classname>Adjustment</classname> automatically, or you can specify an existing <classname>Adjustment</classname>, maybe to share it with another widget. See the <link linkend="chapter-adjustment">Adjustments</link> section for further details.
fr: 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.

en: Scrollbar Widgets
fr: Éléments graphiques barres de défilement

en: These are standard scrollbars. They should be used only to scroll another widget, such as, a <classname>Gtk::Entry</classname>, or a <classname>Gtk::Viewport</classname>, though it's usually easier to use the <classname>Gtk::ScrolledWindow</classname> widget in most cases.
fr: 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.

en: There are horizontal and vertical scrollbar classes - <classname>Gtk::HScrollbar</classname> and <classname>Gtk::VScrollbar</classname>.
fr: 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>.

en: Scale Widgets
fr: Éléments graphiques échelles de valeur

en: <classname>Gtk::Scale</classname> widgets (or "sliders") allow the user to visually select and manipulate a value within a specific range. You might use one, for instance, to adjust the magnification level on a zoomed preview of a picture, or to control the brightness of a colour, or to specify the number of minutes of inactivity before a screensaver takes over the screen.
fr: 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.

en: As with <classname>Scrollbar</classname>s, there are separate widget types for horizontal and vertical widgets - <classname>Gtk::HScale</classname> and <classname>Gtk::VScale</classname>. The default constructors create an <classname>Adjustment</classname> with all of its values set to <literal>0.0</literal>. This isn't useful so you will need to set some <classname>Adjustment</classname> details to get meaningful behaviour.
fr: 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.

en: Useful methods
fr: Fonctions membres utiles

en: <classname>Scale</classname> widgets can display their current value as a number next to the trough. By default they show the value, but you can change this with the <methodname>set_draw_value()</methodname> method.
fr: 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>.

en: The value displayed by a scale widget is rounded to one decimal point by default, as is the <literal>value</literal> field in its <classname>Gtk::Adjustment</classname>. You can change this with the <methodname>set_digits()</methodname> method.
fr: 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>.

en: Also, the value can be drawn in different positions relative to the trough, specified by the <methodname>set_value_pos()</methodname> method.
fr: 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>.

en: Update Policies
fr: Politiques de mise à jour

en: <literal>Gtk::UPDATE_CONTINUOUS</literal> - This is the default. The <literal>value_changed</literal> signal is emitted continuously, i.e. whenever the slider is moved by even the tiniest amount.
fr: <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.

en: <literal>Gtk::UPDATE_DISCONTINUOUS</literal> - The <literal>value_changed</literal> signal is only emitted once the slider has stopped moving and the user has released the mouse button.
fr: <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.

en: <literal>Gtk::UPDATE_DELAYED</literal> - The <literal>value_changed</literal> signal is emitted when the user releases the mouse button, or if the slider stops moving for a short period of time.
fr: <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.

en: The <emphasis>update policy</emphasis> of a <classname>Range</classname> widget defines at what points during user interaction it will change the <literal>value</literal> field of its <classname>Gtk::Adjustment</classname> and emit the <literal>value_changed</literal> signal. The update policies, set with the <methodname>set_update_policy()</methodname> method, are: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: This example displays a window with three range widgets all connected to the same adjustment, along with a couple of controls for adjusting some of the parameters mentioned above and in the section on adjustments, so you can see how they affect the way these widgets work for the user.
fr: 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.

en: Miscellaneous Widgets
fr: Éléments graphiques divers

en: Label
fr: Étiquette

en: Labels are the main method of placing non-editable text in windows, for instance to place a title next to a <classname>Entry</classname> widget. You can specify the text in the constructor, or later with the <methodname>set_text()</methodname> or set_markup() methods.
fr: 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>.

en: The width of the label will be adjusted automatically. You can produce multi-line labels by putting line breaks ("\n") in the label string.
fr: 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.

en: The label text can be justified using the <methodname>set_justify()</methodname> method. The widget is also capable of word-wrapping, which can be activated with <methodname>set_line_wrap()</methodname>.
fr: 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>.

en: 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://library.gnome.org/devel/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> .
fr: Gtk::Label prend en charge les mises en forme simples comme la graisse, la couleur et la taille de la police. Il suffit de fournir une chaîne de caractère à la fonction membre <methodname>set_markup()</methodname> en utilisant la <ulink url="http://library.gnome.org/devel/pango/unstable/PangoMarkupFormat.html">syntaxe de balisage Pango</ulink>. Par exemple, <code> &lt;b&gt;texte gras&lt;/b&gt; et &lt;s&gt;texte barré&lt;/s&gt; </code> .

en: Below is a short example to illustrate these functions. This example makes use of the Frame widget to better demonstrate the label styles. (The Frame widget is explained in the <link linkend="sec-frame">Frame</link> section.)
fr: 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>).

en: Entry
fr: Champ de saisie

en: Simple Use
fr: Utilisation simple

en: Entry widgets allow the user to enter text. You can change the contents with the <methodname>set_text()</methodname> method, and read the current contents with the <methodname>get_text()</methodname> method.
fr: 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>.

en: Occasionally you might want to make an <classname>Entry</classname> widget read-only. This can be done by passing <literal>false</literal> to the <methodname>set_editable()</methodname> method.
fr: 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>.

en: For the input of passwords, passphrases and other information you don't want echoed on the screen, calling <methodname>set_visibility()</methodname> with <literal>false</literal> will cause the text to be hidden.
fr: 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.

en: You might want to be notified whenever the user types in a text entry widget. <classname>Gtk::Entry</classname> provides two signals, <literal>activate</literal> and <literal>changed</literal>, for just this purpose. <literal>activate</literal> is emitted when the user presses the enter key in a text-entry widget; <literal>changed</literal> is emitted when the text in the widget changes. You can use these, for instance, to validate or filter the text the user types.
fr: 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.

en: Simple Entry Example
fr: Exemple simple de saisie

en: This example uses <classname>Gtk::Entry</classname>. It also has two <classname>CheckButton</classname>s, with which you can toggle the editable and visible flags.
fr: 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 ».

en: Entry Completion
fr: Complétion de saisie

en: A <classname>Entry</classname> widget can offer a drop-down list of pre-existing choices based on the first few characters typed by the user. For instance, a search dialog could suggest text from previous searches.
fr: 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.

en: To enable this functionality, you must create a <classname>EntryCompletion</classname> object, and provide it to the <classname>Entry</classname> widget via the <methodname>set_completion()</methodname> method.
fr: 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>.

en: The <classname>EntryCompletion</classname> may use a <classname>TreeModel</classname> containing possible entries, specified with <methodname>set_model()</methodname>. You should then call <methodname>set_text_column()</methodname> to specify which of your model columns should be used to match possible text entries.
fr: 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.

en: Alternatively, if a complete list of possible entries would be too large or too inconvenient to generate, a callback slot may instead be specified with <methodname>set_match_func()</methodname>. That callback function. This is also useful if you wish to match on a part of the string other than the start.
fr: 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.

en: Entry Completion Example
fr: Exemple de complétion de saisie

en: This example creates a <classname>Gtk::EntryCompletion</classname> and associates it with a <classname>Gtk::Entry</classname> widget. The completion uses a <classname>Gtk::TreeModel</classname> of possible entries, and some additional actions.
fr: 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.

en: Entry Icons
fr: Icône dans un champ de saisie

en: An <classname>Entry</classname> widget can show an icon at the start or end of the text area. The icon can be specifed by methods such as <methodname>set_icon_from_pixbuf()</methodname> or <methodname>set_icon_from_stock()</methodname>. An application can respond to the user pressing the icon by handling the <methodname>signal_icon_press</methodname> signal.
fr: 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>.

en: Entry Icon Example
fr: Exemple d'icône dans un champ de saisie

en: This example shows a <classname>Gtk::Entry</classname> widget with a stock search icon, and prints text to the terminal when the icon is pressed.
fr: 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.

en: Entry with Icon
fr: Saisie avec icône

en: Entry Progress
fr: Saisie avec barre de progression

en: An <classname>Entry</classname> widget can show a progress bar inside the text area, under the entered text. The progress bar will be shown if the <methodname>set_progress_fraction()</methodname> or <methodname>set_progress_pulse_step()</methodname> methods are called.
fr: 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>.

en: Entry Progress Example
fr: Exemple de saisie avec barre de progression

en: This example shows a <classname>Gtk::Entry</classname> widget with a progress bar.
fr: Cet exemple montre un élément graphique <classname>Gtk::Entry</classname> avec barre de progression.

en: Entry with Progress Bar
fr: Saisie avec barre de progression

en: SpinButton
fr: Bouton compteur

en: A <classname>SpinButton</classname> allows the user to select a value from a range of numeric values. It has an Entry widget with up and down arrow buttons at the side. Clicking the buttons causes the value to 'spin' up and down across the range of possible values. The <classname>Entry</classname> widget may also be used to enter a value directly.
fr: 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>.

en: The value can have an adjustable number of decimal places, and the step size is configurable. <classname>SpinButton</classname>s have an 'auto-repeat' feature as well: holding down one of the arrows can optionally cause the value to change more quickly the longer the arrow is held down.
fr: 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.

en: <literal>value</literal>: value for the Spin Button
fr: <literal>value</literal> : valeur initiale du compteur

en: <literal>lower</literal>: lower range value
fr: <literal>lower</literal> : limite inférieure de la plage

en: <literal>upper</literal>: upper range value
fr: <literal>upper</literal> : limite supérieure de la plage

en: <literal>step_increment</literal>: value to increment/decrement when pressing mouse button 1 on a button
fr: <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

en: <literal>page_increment</literal>: value to increment/decrement when pressing mouse button 2 on a button
fr: <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

en: <literal>page_size</literal>: unused
fr: <literal>page_size</literal> : inutilisé

en: <classname>SpinButton</classname>s use an <link linkend="chapter-adjustment">Adjustment</link> object to hold information about the range of values. These Adjustment attributes are used by the Spin Button like so: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: Additionally, mouse button 3 can be used to jump directly to the <literal>upper</literal> or <literal>lower</literal> values.
fr: 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>.

en: The <classname>SpinButton</classname> can create a default <classname>Adjustment</classname>, which you can access via the <methodname>get_adjustment()</methodname> method, or you can specify an existing <classname>Adjustment</classname> in the constructor.
fr: 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.

en: The number of decimal places can be altered using the <methodname>set_digits()</methodname> method.
fr: Le nombre de décimales est modifié à l'aide de la fonction membre <methodname>set_digits()</methodname>.

en: You can set the spinbutton's value using the <methodname>set_value()</methodname> method, and retrieve it with <methodname>get_value()</methodname>.
fr: 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>.

en: The <methodname>spin()</methodname> method 'spins' the <classname>SpinButton</classname>, as if one of its arrows had been clicked. You need to specify a <classname>Gtk::SpinType</classname> to specify the direction or new position.
fr: 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.

en: To prevent the user from typing non-numeric characters into the entry box, pass <literal>true</literal> to the <methodname>set_numeric()</methodname> method.
fr: 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>.

en: To make the <classname>SpinButton</classname> 'wrap' between its upper and lower bounds, use the <methodname>set_wrap()</methodname> method.
fr: 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>.

en: To force it to snap to the nearest <literal>step_increment</literal>, use <methodname>set_snap_to_ticks()</methodname>.
fr: 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>.

en: You can modify the update policy using the <methodname>set_update_policy()</methodname> method, specifying either <literal>Gtk::UPDATE_ALWAYS</literal> or <literal>Gtk::UPDATE_IF_VALID</literal>. <literal>Gtk::UPDATE_ALWAYS</literal> causes the <classname>SpinButton</classname> to ignore errors encountered while converting the text in the entry box to a numeric value. This setting also therefore allows the <classname>SpinButton</classname> to accept non-numeric values. You can force an immediate update using the <methodname>update()</methodname> method.
fr: 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>.

en: Here's an example of a <classname>SpinButton</classname> in action:
fr: Voici un exemple de <classname>SpinButton</classname> en action :

en: ProgressBar
fr: Barres de progression

en: Progress bars are used to show the status of an ongoing operation. For instance, a <classname>ProgressBar</classname> can show how much of a task has been completed.
fr: 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.

en: To change the value shown, use the <methodname>set_fraction()</methodname> method, passing a double between 0 and 1 to provide the new percentage.
fr: 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.

en: where <literal>percentage</literal> is a number, from 0 to 1, indicating what fraction of the bar should be filled.
fr: Le paramètre <literal>percentage</literal> est un nombre, entre 0 et 1, indiquant la proportion de remplissage de la barre.

en: A <classname>ProgressBar</classname>is horizontal and left-to-right by default, but you can change it to a vertical progress bar by using the <methodname>set_orientation()</methodname> method.
fr: 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>.

en: Activity Mode
fr: Mode activité

en: Besides indicating the amount of progress that has occured, the progress bar can also be used to indicate that there is some activity; this is done by placing the progress bar in <emphasis>activity mode</emphasis>. In this mode, the progress bar displays a small rectangle which moves back and forth. Activity mode is useful in situations where the progress of an operation cannot be calculated as a value range (e.g., receiving a file of unknown length).
fr: 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).

en: To do this, you need to call the <methodname>pulse()</methodname> method at regular intervals. You can also choose the step size, with the <methodname>set_pulse_step()</methodname> method.
fr: 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>.

en: When in continuous mode, the progress bar can also display a configurable text string within its trough, using the <methodname>set_text()</methodname> method.
fr: 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>.

en: InfoBar
fr: Infobarre

en: An <classname>InfoBar</classname> may show small items of information or to ask brief questions. Unlike a <classname>Dialog</classname>, it appears at the top of the current window instead of opening a new window. Its API is very similar to the <link linkend="chapter-dialogs">Gtk::Dialog</link> API.
fr: 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>.

en: Tooltips
fr: Infobulles

en: Tooltips are the little information windows that pop up when you leave your pointer over a widget for a few seconds. Use <methodname>set_tooltip_text()</methodname> to set a text string as a tooltip on any <classname>Widget</classname>. <classname>Gtk::ToolItem</classname>s are not <classname>Widget</classname>s, but have the same method for convenience. <classname>Gtk::Tooltip</classname> is used for more advanced tooltip usage, such as showing an image as well as text.
fr: 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.

en: Widget Reference
fr: Référence pour les éléments graphiques

en: Tooltip Reference
fr: Référence Infobulles

en: Tooltip
fr: Infobulle

en: Container Widgets
fr: Éléments graphiques conteneurs

en: All container widgets derive from <classname>Gtk::Container</classname>, not always directly. Some container widgets, such as <classname>Gtk::Table</classname> can hold many child widgets, so these typically have more complex interfaces. Others, such as <classname>Gtk::Frame</classname> contain only one child widget.
fr: 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.

en: Single-item Containers
fr: Conteneurs mono-éléments

en: The single-item container widgets derive from <classname>Gtk::Bin</classname>, which provides the <methodname>add()</methodname> and <methodname>remove()</methodname> methods for the child widget. Note that <classname>Gtk::Button</classname> and <classname>Gtk::Window</classname> are technically single-item containers, but we have discussed them already elsewhere.
fr: 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.

en: We also discuss the <classname>Gtk::Paned</classname> widget, which allows you to divide a window into two separate "panes". This widget actually contains two child widgets, but the number is fixed so it seems appropriate.
fr: 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é.

en: Frame
fr: Cadre

en: Frames can enclose one or a group of widgets within a box, optionally with a title. For instance, you might place a group of <classname>RadioButton</classname>s or <classname>CheckButton</classname>s in a <classname>Frame</classname>.
fr: 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>.

en: Paned
fr: Volets

en: Panes divide a widget into two halves, separated by a moveable divider. There are two such widgets: <classname>Gtk::HPaned</classname> adds a horizontal divider, and <classname>Gtk::VPaned</classname> adds a vertical one. Other than the names and the orientations, there's no difference between the two.
fr: 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.

en: Unlike the other widgets in this chapter, pane widgets contain not one but two child widgets, one in each pane. Therefore, you should use <methodname>add1()</methodname> and <methodname>add2()</methodname> instead of the <methodname>add()</methodname> method.
fr: 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>.

en: You can adjust the position of the divider using the <methodname>set_position()</methodname> method, and you will probably need to do so.
fr: 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.

en: ScrolledWindow
fr: Fenêtre à défilement

en: <classname>ScrolledWindow</classname> widgets create a scrollable area. You can insert any type of widget into a <classname>ScrolledWindow</classname> window, and it will be accessible regardless of its size by using the scrollbars. Note that <classname>ScrolledWindow</classname> is not a <classname>Gtk::Window</classname> despite the slightly misleading name.
fr: 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.

en: Scrolled windows have <emphasis>scrollbar policies</emphasis> which determine whether the <classname>Scrollbar</classname>s will be displayed. The policies can be set with the <methodname>set_policy()</methodname> method. The policy may be one of <literal>Gtk::POLICY_AUTOMATIC</literal> or <literal>Gtk::POLICY_ALWAYS</literal>. <literal>Gtk::POLICY_AUTOMATIC</literal> will cause the scrolled window to display the scrollbar only if the contained widget is larger than the visible area. <literal>Gtk::POLICY_ALWAYS</literal> will cause the scrollbar to be displayed always.
fr: 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.

en: Here is a simple example that packs 100 toggle buttons into a ScrolledWindow. Try resizing the window to see the scrollbars react.
fr: 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.

en: AspectFrame
fr: Cadre proportionné

en: The <classname>AspectFrame</classname> widget looks like a <classname>Frame</classname> widget, but it also enforces the <emphasis>aspect ratio</emphasis> (the ratio of the width to the height) of the child widget, adding extra space if necessary. For instance, this would allow you to display a photograph without allowing the user to distort it horizontally or vertically while resizing.
fr: 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.

en: The following program uses a <classname>Gtk::AspectFrame</classname> to present a drawing area whose aspect ratio will always be 2:1, no matter how the user resizes the top-level window.
fr: 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.

en: Alignment
fr: Alignement

en: The <classname>Alignment</classname> widget allows you to place a widget at a position and size relative to the size of the <classname>Alignment</classname> widget itself. For instance, it might be used to center a widget.
fr: 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.

en: You need to specify the <classname>Alignment</classname>'s characteristics to the constructor, or to the <methodname>set()</methodname> method. In particular, you won't notice much effect unless you specify a number other than 1.0 for the <literal>xscale</literal> and <literal>yscale</literal> parameters, because 1.0 simply means that the child widget will expand to fill all available space.
fr: 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.

en: This example right-aligns a button in a window by using an <classname>Alignment</classname> widget.
fr: Cet exemple aligne à droite un bouton dans une fenêtre à l'aide de l'élément conteneur <classname>Alignment</classname>.

en: See the <link linkend="sec-progressbar">ProgressBar</link> section for another example that uses an <classname>Alignment</classname>.
fr: 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>.

en: Multiple-item widgets
fr: Conteneurs multi-éléments

en: Multiple-item widgets inherit from <classname>Gtk::Container</classname>; just as with <classname>Gtk::Bin</classname>, you use the <methodname>add()</methodname> and <methodname>remove()</methodname> methods to add and remove contained widgets. Unlike <methodname>Gtk::Bin::remove()</methodname>, however, the <methodname>remove()</methodname> method for <classname>Gtk::Container</classname> takes an argument, specifiying which widget to remove.
fr: 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.

en: Packing
fr: Empaquetage

en: You've probably noticed that <application>gtkmm</application> windows seem "elastic" - they can usually be stretched in many different ways. This is due to the <emphasis>widget packing</emphasis> system.
fr: 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 ».

en: Many GUI toolkits require you to precisely place widgets in a window, using absolute positioning, often using a visual editor. This leads to several problems:
fr: 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 :

en: The widgets don't rearrange themselves when the window is resized. Some widgets are hidden when the window is made smaller, and lots of useless space appears when the window is made larger.
fr: 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.

en: It's impossible to predict the amount of space necessary for text after it has been translated to other languages, or displayed in a different font. On Unix it is also impossible to anticipate the effects of every theme and window manager.
fr: 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.

en: Changing the layout of a window "on the fly", to make some extra widgets appear, for instance, is complex. It requires tedious recalculation of every widget's position.
fr: 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.

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

en: <application>gtkmm</application> arranges widgets hierarchically, using <emphasis>containers</emphasis>. A Container widget contains other widgets. Most <application>gtkmm</application> widgets are containers. Windows, Notebook tabs, and Buttons are all container widgets. There are two flavours of containers: single-child containers, which are all descendants of <classname>Gtk::Bin</classname>, and multiple-child containers, which are descendants of <classname>Gtk::Container</classname>. Most widgets in <application>gtkmm</application> are descendants of <classname>Gtk::Bin</classname>, including <classname>Gtk::Window</classname>.
fr: <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>.

en: Yes, that's correct: a Window can contain at most one widget. How, then, can we use a window for anything useful? By placing a multiple-child container in the window. The most useful container widgets are <classname>Gtk:Grid</classname>, <classname>Gtk:VBox</classname>, <classname>Gtk::HBox</classname>, and <classname>Gtk::Table</classname>.
fr: 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>.

en: <classname>Gtk::Grid</classname> arranges its child widgets in rows and columns. Use <methodname>attach()</methodname>, <methodname>attach_next_to()</methodname> and <methodname>add()</methodname> to insert child widgets.
fr: <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.

en: <classname>Gtk::VBox</classname> and <classname>Gtk::HBox</classname> arrange their child widgets vertically and horizontally, respectively. Use <methodname>pack_start()</methodname> and <methodname>pack_end()</methodname> to insert child widgets.
fr: <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.

en: <classname>Gtk::Table</classname> arranges its widgets in a grid. Use <methodname>attach()</methodname> to insert widgets.
fr: <classname>Gtk::Table</classname> place ses éléments graphiques sur une grille. Utilisez <methodname>attach()</methodname> pour insérer les éléments graphiques.

en: There are several other containers, which we will also discuss.
fr: Il existe plusieurs autres conteneurs. Nous en parlerons également.

en: If you've never used a packing toolkit before, it can take some getting used to. You'll probably find, however, that you don't need to rely on visual form editors quite as much as you might with other toolkits.
fr: 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.

en: An improved Hello World
fr: Un Hello World amélioré

en: Let's take a look at a slightly improved <literal>helloworld</literal>, showing what we've learnt.
fr: Regardons un <literal>helloworld</literal> légèrement perfectionné en se servant de nos nouvelles connaissances.

en: After building and running this program, try resizing the window to see the behaviour. Also, try playing with the options to <methodname>pack_start()</methodname> while reading the <link linkend="sec-boxes">Boxes</link> section.
fr: 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>.

en: Boxes
fr: Boîtes

en: Most packing uses boxes as in the above example. These are invisible containers into which we can pack our widgets. When packing widgets into a horizontal box, the objects are inserted horizontally from left to right or right to left depending on whether <methodname>pack_start()</methodname> or <methodname>pack_end()</methodname> is used. In a vertical box, widgets are packed from top to bottom or vice versa. You may use any combination of boxes inside or beside other boxes to create the desired effect.
fr: 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.

en: Adding widgets
fr: Ajout d'éléments graphiques

en: Per-child packing options
fr: Options d'empaquetage par enfant

en: The <methodname>pack_start()</methodname> and <methodname>pack_end()</methodname> methods place widgets inside these containers. The <methodname>pack_start()</methodname> method will start at the top and work its way down in a <classname>VBox</classname>, or pack left to right in an <classname>HBox</classname>. <methodname>pack_end()</methodname> will do the opposite, packing from bottom to top in a <classname>VBox</classname>, or right to left in an <classname>HBox</classname>. Using these methods allows us to right justify or left justify our widgets. We will use <methodname>pack_start()</methodname> in most of our examples.
fr: 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.

en: There are several options governing how widgets are to be packed, and this can be confusing at first. If you have difficulties then it is sometimes a good idea to play with the <application>glade</application> GUI designer to see what is possible. You might even decide to use the <application>Gtk::Builder</application> API to load your GUI at runtime.
fr: 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.

en: There are basically five different styles, as shown in this picture:
fr: À la base, il y cinq styles différents comme illustré dans cette figure :

en: Box Packing 1
fr: Empaquetage dans boîte n°1

en: Each line contains one horizontal box (<classname>HBox</classname>) with several buttons. Each of the buttons on a line is packed into the <classname>HBox</classname> with the same arguments to the <methodname>pack_start()</methodname> method).
fr: 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>.

en: This is the declaration of the <methodname>pack_start()</methodname> method:
fr: Voici la déclaration de la fonction membre <methodname>pack_start()</methodname> :

en: The first argument is the widget you're packing. In our example these are all <classname>Button</classname>s.
fr: Le premier paramètre désigne l'élément graphique à empaquer. Dans notre exemple, ce sont tous des objets <classname>Button</classname>.

en: <literal>PACK_SHRINK</literal>: Space is contracted to the child widget size. The widget will take up just-enough space and never expand.
fr: <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é.

en: <literal>PACK_EXPAND_PADDING</literal>: Extra space is filled with padding. The widgets will be spaced out evenly, but their sizes won't change - there will be empty space between the widgets instead.
fr: <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.

en: <literal>PACK_EXPAND_WIDGET</literal>: Extra space is taken up by increasing the child widget size, without changing the amount of space between widgets.
fr: <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.

en: The <parameter>options</parameter> argument can take one of these three options: <placeholder-1/>
fr: Le paramètre <parameter>options</parameter> peut prendre une des trois valeurs suivantes : <placeholder-1/>

en: The <parameter>padding</parameter> argument specifies the width of an extra border area to leave around the packed widget.
fr: Le paramètre <parameter>padding</parameter> définit la largeur de la bordure libre autour de l'élément graphique empaqueté.

en: Per-container packing options
fr: Options d'empaquetage par conteneur

en: Here's the constructor for the box widgets: <placeholder-1/> Passing <literal>true</literal> for <parameter>homogeneous</parameter> will cause all of the contained widgets to be the same size. <parameter>spacing</parameter> is a (minimum) number of pixels to leave between each widget.
fr: Voici le constructeur des éléments graphiques de la boîte : <placeholder-1/> 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.

en: What's the difference between spacing (set when the box is created) and padding (set when elements are packed)? Spacing is added between objects, and padding is added on either side of a widget. The following figure should make it clearer:
fr: 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 :

en: Box Packing 2
fr: Empaquetage dans boîte n°2

en: Here is the source code for the example that produced the screenshots above. When you run this example, provide a number between 1 and 3 as a command-line option, to see different packing options in use.
fr: 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.

en: ButtonBoxes
fr: Boîtes à boutons

en: Button boxes are a convenient way to quickly arrange a group of buttons. They come in both horizontal (<classname>Gtk::HButtonBox</classname>) and vertical (<classname>Gtk::VButtonBox</classname>) flavours. They are exactly alike, except in name and orientation.
fr: 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.

en: <classname>ButtonBox</classname>es help to make applications appear consistent because they use standard settings, such as inter-button spacing and packing.
fr: 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.

en: Buttons are added to a <classname>ButtonBox</classname> with the <methodname>add()</methodname> method.
fr: Les boutons sont insérés dans l'objet <classname>ButtonBox</classname> à l'aide de la fonction membre <methodname>add()</methodname>.

en: Button boxes support several layout styles. The style can be retrieved and changed using <methodname>get_layout()</methodname> and <methodname>set_layout()</methodname>.
fr: 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>.

en: ButtonBox
fr: Boîte à bouton

en: Grid
fr: Grille

en: <classname>Grid</classname> allows us to place widgets in a grid. The grid dynamically lays out child widgets, so the dimensions of the grid do not need to be specified in the constructor.
fr: Les <classname>Grid</classname> (grille) vous permettent de disposer des éléments graphiques dans une grille. La grille agence de manière dynamique les éléments graphiques enfants donc les dimensions de la grille n'ont pas besoin d'être indiquée dans le constructeur.

en: Children 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>. Set the <emphasis>margin</emphasis> and <emphasis>expand</emphasis> properties of the <classname>Widget</classname>s that are added to the grid, in order to control the geometry management.
fr: Les enfants peuvent occuper plusieurs lignes ou colonnes en utilisant la méthode <methodname>attach()</methodname> ou être ajoutés à côté d'un élément graphique existant dans la grille avec la méthode <methodname>attach_next_to()</methodname>. Les lignes et colonnes de la grille peuvent être paramétrées de manière individuelle pour avoir une hauteur ou largeur uniforme avec <methodname>set_row_homogeneous()</methodname> et <methodname>set_column_homogeneous()</methodname>. Paramétrez les propriétés <emphasis>margin</emphasis> et <emphasis>expand</emphasis> des <classname>éléments graphiques</classname> qui sont ajoutés à la grille afin de contrôler la gestion de la géométrie.

en: In the following example, we make a window with three buttons in a grid. The first two buttons will be placed in the upper row, from left to right. A third button is attached underneath the first buttion, in a new lower row, spanning two columns.
fr: Dans l'exemple ci-après, nous créons une fenêtre avec trois boutons dans une grille. Les deux premiers boutons sont placés dans la ligne supérieure de gauche à droite. Le troisième bouton est attaché sous le premier bouton, dans une nouvelle ligne inférieur et occupe deux colonnes.

en: Table
fr: Tableau

en: Tables allows us to place widgets in a grid, similar to <classname>Gtk::Grid</classname>.
fr: Les tableaux permettent de placer les éléments graphiques sur une grille, de manière identique à <classname>Gtk::Grid</classname>.

en: Constructor
fr: Constructeur

en: The grid's dimensions need to be specified in the constructor:
fr: Il est nécessaire de définir les dimensions de la grille dans le constructeur :

en: The first argument is the number of rows to make in the table, while the second, obviously, is the number of columns. If <parameter>homogeneous</parameter> is <literal>true</literal>, the table cells will all be the same size (the size of the largest widget in the table).
fr: 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).

en: The rows and columns are indexed starting at 0. If you specify <parameter>rows</parameter> = 2 and <parameter>columns</parameter> = 2, the layout would look something like this:
fr: 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 :

en: Note that the coordinate system starts in the upper left hand corner.
fr: Notez que l'origine du système de coordonnées est l'angle supérieur gauche.

en: To place a widget into a box, use the following method:
fr: Pour placer un élément graphique dans une cellule, utilisez la fonction membre suivante :

en: The first argument is the widget you wish to place in the table.
fr: Le premier paramètre est l'élément graphique que vous souhaitez placer dans la table.

en: The <parameter>left_attach</parameter> and <parameter>right_attach</parameter> arguments specify where to place the widget, and how many boxes to use. For example, if you want a button in the lower-right cell of a 2 x 2 table, and want it to occupy that cell <emphasis>only</emphasis>, then <parameter>left_attach</parameter> would be 1, <parameter>right_attach</parameter> 2, <parameter>top_attach</parameter> 1, and <parameter>bottom_attach</parameter> 2. If, on the other hand, you wanted a widget to take up the entire top row of our 2 x 2 table, you'd set <parameter>left_attach</parameter> = 0, <parameter>right_attach</parameter> = 2, <parameter>top_attach</parameter> = 0, and <parameter>bottom_attach</parameter> = 1.
fr: 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.

en: <parameter>xoptions</parameter> and <parameter>yoptions</parameter> are used to specify packing options and may be bitwise ORed together to allow multiple options. These options are:
fr: 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 :

en: If the table box is larger than the widget, and <literal>Gtk::FILL</literal> is specified, the widget will expand to use all the room available.
fr: 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.

en: If the table widget is allocated less space than it requested (because the user resized the window), then the widgets will normally just disappear off the bottom of the window. If <literal>Gtk::SHRINK</literal> is specified, the widgets will shrink with the table.
fr: 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.

en: This will cause the table to expand to use up anyremaining space in the window.
fr: Cette option va provoquer l'étalement du tableau jusqu'à occuper tout l'espace libre de la fenêtre.

en: The padding arguments work just as they do for <methodname>pack_start()</methodname>.
fr: Les paramètres de remplissage fonctionnent exactement comme pour la fonction membre <methodname>pack_start()</methodname>.

en: Other methods
fr: Autres fonctions membres

en: <methodname>set_row_spacing()</methodname> and <methodname>set_col_spacing()</methodname> set the spacing between the rows at the specified row or column. Note that for columns, the space goes to the right of the column, and for rows, the space goes below the row.
fr: <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.

en: You can also set a consistent spacing for all rows and/or columns with <methodname>set_row_spacings()</methodname> and <methodname>set_col_spacings()</methodname>. Note that with these calls, the last row and last column do not get any spacing.
fr: 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é.

en: In the following example, we make a window with three buttons in a 2 x 2 table. The first two buttons will be placed in the upper row. A third button is placed in the lower row, spanning both columns.
fr: 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.

en: Notebook
fr: Bloc-note

en: A <classname>Notebook</classname> has a set of stacked <literal>pages</literal>, each of which contains widgets. Labelled <literal>tabs</literal> allow the user to select the pages. <classname>Notebook</classname>s allow several sets of widgets to be placed in a small space, by only showing one page at a time. For instance, they are often used in preferences dialogs.
fr: 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.

en: Use the <methodname>append_page()</methodname>, <methodname>prepend_page()</methodname> and <methodname>insert_page()</methodname> methods to add tabbed pages to the <literal>Notebook</literal>, supplying the child widget and the name for the tab.
fr: 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.

en: To discover the currently visible page, use the <methodname>get_current_page()</methodname> method. This returns the page number, and then calling <methodname>get_nth_page()</methodname> with that number will give you a pointer to the actual child widget.
fr: 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.

en: To programmatically change the selected page, use the <methodname>set_current_page()</methodname> method.
fr: Pour changer de page sélectionnée au cours du programme, utilisez la fonction membre <methodname>set_current_page()</methodname>.

en: An <classname>Assistant</classname> splits a complex operation into steps. Each step is a page, containing a header, a child widget and an action area. The Assistant's action area has navigation buttons which update automatically depending on the type of the page, set with <methodname>set_page_type()</methodname>.
fr: 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>.

en: Use the <methodname>append_page()</methodname>, <methodname>prepend_page</methodname> and <methodname>insert_page()</methodname> methods to add pages to the <classname>Assistant</classname>, supplying the child widget for each page.
fr: 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.

en: To determine the currently-visible page, use the <methodname>get_current_page()</methodname> method, and pass the result to <methodname>get_nth_page()</methodname>, which returns a pointer to the actual widget. To programmatically change the current page, use the <methodname>set_current_page()</methodname> method.
fr: 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>.

en: To set the title of a page, use the <methodname>set_page_title()</methodname> method. The header and side images of a page can be set with the <methodname>set_page_header_image()</methodname> and <methodname>set_page_side_image()</methodname> methods.
fr: 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>.

en: To add widgets to the action area, use the <methodname>add_action_widget()</methodname> method. They will be packed alongside the default buttons. Use the <methodname>remove_action_widget()</methodname> method to remove widgets.
fr: 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.

en: The TreeView widget
fr: L'élément graphique arborescence

en: The <classname>Gtk::TreeView</classname> widget can contain lists or trees of data, in columns.
fr: L'élément graphique <classname>Gtk::TreeView</classname> peut incorporer des listes ou des arborescences de données, disposées en colonnes.

en: The Model
fr: Le modèle

en: Each <classname>Gtk::TreeView</classname> has an associated <classname>Gtk::TreeModel</classname>, which contains the data displayed by the <classname>TreeView</classname>. Each <classname>Gtk::TreeModel</classname> can be used by more than one <classname>Gtk::TreeView</classname>. For instance, this allows the same underlying data to be displayed and edited in 2 different ways at the same time. Or the 2 Views might display different columns from the same Model data, in the same way that 2 SQL queries (or "views") might show different fields from the same database table.
fr: 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.

en: Although you can theoretically implement your own Model, you will normally use either the <classname>ListStore</classname> or <classname>TreeStore</classname> model classes.
fr: 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>.

en: ListStore, for rows
fr: Modèle listStore, pour des colonnes

en: The <classname>ListStore</classname> contains simple rows of data, and each row has no children.
fr: Un objet <classname>ListStore</classname> contient de simples colonnes de données et chaque colonne n'a pas d'enfant.

en: TreeStore, for a hierarchy
fr: Modèle treeStore, pour une hiérarchie

en: The <classname>TreeStore</classname> contains rows of data, and each row may have child rows.
fr: L'objet <classname>TreeStore</classname> contient des colonnes de données et chaque colonne peut avoir des colonnes enfants.

en: Model Columns
fr: Modèle colonnes

en: The <classname>TreeModelColumnRecord</classname> class is used to keep track of the columns and their data types. You add <classname>TreeModelColumn</classname> instances to the <classname>ColumnRecord</classname> and then use those <classname>TreeModelColumns</classname> when getting and setting the data in model rows. You will probably find it convenient to derive a new <classname>TreeModelColumnRecord</classname> which has your <classname>TreeModelColumn</classname> instances as member data.
fr: 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.

en: You specify the <classname>ColumnRecord</classname> when creating the Model, like so:
fr: Vous précisez le <classname>ColumnRecord</classname> à la création du modèle, ainsi :

en: Note that the instance (such as m_Columns here) should usually not be static, because it often needs to be instantiated after glibmm has been instantiated.
fr: 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.

en: Adding Rows
fr: Ajout de lignes

en: Add rows to the model with the <methodname>append()</methodname>, <methodname>prepend()</methodname>, or <methodname>insert()</methodname> methods.
fr: Ajoutez des lignes au modèle avec les fonctions membres <methodname>append()</methodname>, <methodname>prepend()</methodname> ou <methodname>insert()</methodname>.

en: You can dereference the iterator to get the Row:
fr: Vous pouvez déréférencer l'itérateur pour obtenir la ligne :

en: Adding child rows
fr: Ajout de colonnes enfants

en: <classname>Gtk::TreeStore</classname> models can have child items. Add them with the <methodname>append()</methodname>, <methodname>prepend()</methodname>, or <methodname>insert()</methodname> methods, like so:
fr: 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 :

en: Setting values
fr: Définition des valeurs

en: You can use the <methodname>operator[]</methodname> override to set the data for a particular column in the row, specifying the <classname>TreeModelColumn</classname> used to create the model.
fr: 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.

en: row[m_Columns.m_col_text] = "sometext";
fr: row[m_Columns.m_col_text] = "textedonné";

en: Getting values
fr: Obtention des valeurs

en: You can use the <methodname>operator[]</methodname> override to get the data in a particular column in a row, specifiying the <classname>TreeModelColumn</classname> used to create the model.
fr: 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.

en: The compiler will complain if you use an inappropriate type. For instance, this would generate a compiler error:
fr: Le compilateur se plaint si vous utilisez un type inapproprié et génère, par exemple, l'erreur de compilation suivante :

en: "Hidden" Columns
fr: Colonnes « cachées »

en: You might want to associate extra data with each row. If so, just add it as a Model column, but don't add it to the View.
fr: 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.

en: The View
fr: La vue

en: The View is the actual widget (<classname>Gtk::TreeView</classname>) that displays the model (<classname>Gtk::TreeModel</classname>) data and allows the user to interact with it. The View can show all of the model's columns, or just some, and it can show them in various ways.
fr: 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.

en: Using a Model
fr: Utilisation d'un modèle

en: You can specify a <classname>Gtk::TreeModel</classname> when constructing the <classname>Gtk::TreeView</classname>, or you can use the <methodname>set_model()</methodname> method, like so:
fr: 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 :

en: Adding View Columns
fr: Ajout de colonnes à la vue

en: You can use the <methodname>append_column()</methodname> method to tell the View that it should display certain Model columns, in a certain order, with a certain column title.
fr: 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é.

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

en: More than one Model Column per View Column
fr: Plus d'une colonne de modèle par colonne de vue

en: To render more than one model column in a view column, you need to create the <classname>TreeView::Column</classname> widget manually, and use <methodname>pack_start()</methodname> to add the model columns to it.
fr: 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.

en: Then use <methodname>append_column()</methodname> to add the view Column to the View. Notice that <methodname>Gtk::View::append_column()</methodname> is overridden to accept either a prebuilt <classname>Gtk::View::Column</classname> widget, or just the <classname>TreeModelColumn</classname> from which it generates an appropriate <classname>Gtk::View::Column</classname> widget.
fr: 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é.

en: Here is some example code from <filename>demos/gtk-demo/example_stockbrowser.cc</filename>, which has a pixbuf icon and a text name in the same column:
fr: 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 :

en: Gtk::TreeView::Column* pColumn =
        Gtk::manage( new Gtk::TreeView::Column("Symbol") );
    
    // m_columns.icon and m_columns.symbol are columns in the model.
    // pColumn is the column in the TreeView:
    pColumn-&gt;pack_start(m_columns.icon, false); //false = don't expand.
    pColumn-&gt;pack_start(m_columns.symbol);
    
    m_TreeView.append_column(*pColumn);
fr: 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);

en: Specifying CellRenderer details
fr: Détails pour la définition du CellRenderer

en: The default <classname>CellRenderers</classname> and their default behaviour will normally suffice, but you might occasionally need finer control. For instance, this example code from <filename>demos/gtk-demo/example_treestore.cc</filename>, manually constructs a <classname>Gtk::CellRenderer</classname> widget and instructs it to render the data from various model columns through various aspects of its appearance.
fr: 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.

en: You can also connect to <classname>CellRenderer</classname> signals to detect user actions. For instance:
fr: Vous pouvez aussi connecter les signaux du <classname>CellRenderer</classname> pour détecter des actions utilisateur. Par exemple :

en: Editable Cells
fr: Cellules modifiables

en: Automatically-stored editable cells.
fr: Cellules modifiables à enregistrement automatique.

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

en: Implementing custom logic for editable cells.
fr: Implémentation d'une logique personnalisée pour les cellules modifiables.

en: However, you might not want the new values to be stored immediately. For instance, maybe you want to restrict the input to certain characters or ranges of values.
fr: 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.

en: To achieve this, you should use the normal <classname>Gtk::TreeView</classname><methodname>insert_column()</methodname> and <methodname>append_column()</methodname> methods, then use <methodname>get_column_cell_renderer()</methodname> to get the <classname>Gtk::CellRenderer</classname> used by that column.
fr: 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.

en: You should then cast that <classname>Gtk::CellRenderer*</classname> to the specific <classname>CellRenderer</classname> that you expect, so you can use specific API.
fr: 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.

en: For instance, for a CellRendererText, you would set the cell's <emphasis>editable</emphasis> property to true, like so:
fr: Par exemple, pour un CellRendererText, vous définissez la propriété <emphasis>editable</emphasis> égale à <literal>true</literal>, comme ceci :

en: For a CellRendererToggle, you would set the <emphasis>activatable</emphasis> property instead.
fr: Pour un « CellRendererToggle », vous paramétrez la propriété <emphasis>activatable</emphasis> à la place.

en: You can then connect to the appropriate "edited" signal. For instance, connect to <methodname>Gtk::CellRendererText::signal_edited()</methodname>, or <methodname>Gtk::CellRendererToggle::signal_toggled()</methodname>. If the column contains more than one <classname>CellRenderer</classname> then you will need to use <methodname>Gtk::TreeView::get_column()</methodname> and then call <methodname>get_cell_renderers()</methodname> on that view Column.
fr: 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.

en: In your signal handler, you should examine the new value and then store it in the Model if that is appropriate for your application.
fr: 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.

en: Iterating over Model Rows
fr: Itération parmi les colonnes du modèle

en: <classname>Gtk::TreeModel</classname> provides a C++ Standard Library-style container of its children, via the <methodname>children()</methodname> method. You can use the familiar <methodname>begin()</methodname> and <methodname>end()</methodname> methods iterator incrementing, like so:
fr: <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 :

en: typedef Gtk::TreeModel::Children type_children; //minimise code length.
    type_children children = refModel-&gt;children();
    for(type_children::iterator iter = children.begin();
        iter != children.end(); ++iter)
    {
      Gtk::TreeModel::Row row = *iter;
      //Do something with the row - see above for set/get.
    }
fr: 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.
    }

en: Row children
fr: Ligne enfant

en: When using a <classname>Gtk::TreeStore</classname>, the rows can have child rows, which can have their own children in turn. Use <methodname>Gtk::TreeModel::Row::children()</methodname> to get the container of child <classname>Row</classname>s: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: The Selection
fr: La sélection

en: To find out what rows the user has selected, get the <classname>Gtk::TreeView::Selection</classname> object from the <classname>TreeView</classname>, like so:
fr: 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 :

en: Single or multiple selection
fr: Sélection simple ou multiple

en: By default, only single rows can be selected, but you can allow multiple selection by setting the mode, like so: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: The selected rows
fr: Les lignes sélectionnées

en: For single-selection, you can just call <methodname>get_selected()</methodname>, like so:
fr: Pour une simple sélection, appelez simplement la fonction membre <methodname>get_selected()</methodname>, comme suit :

en: TreeModel::iterator iter = refTreeSelection-&gt;get_selected();
    if(iter) //If anything is selected
    {
      TreeModel::Row row = *iter;
      //Do something with the row.
    }
fr: 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.
    }

en: For multiple-selection, you need to define a callback, and give it to <methodname>selected_foreach()</methodname>, <methodname>selected_foreach_path()</methodname>, or <methodname>selected_foreach_iter()</methodname>, like so:
fr: 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 :

en: 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;
      //Do something with the row.
    }
fr: 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.
    }

en: The "changed" signal
fr: Le signal « changed »

en: To respond to the user clicking on a row or range of rows, connect to the signal like so:
fr: Pour répondre à l'utilisateur qui clique sur une ligne ou une plage de lignes, connectez le signal ainsi :

en: Preventing row selection
fr: Empêcher la sélection de lignes

en: Maybe the user should not be able to select every item in your list or tree. For instance, in the gtk-demo, you can select a demo to see the source code, but it doesn't make any sense to select a demo category.
fr: 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.

en: To control which rows can be selected, use the <methodname>set_select_function()</methodname> method, providing a <classname>sigc::slot</classname> callback. For instance:
fr: 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 :

en: and then
fr: puis

en: 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);
      return iter-&gt;children().empty(); // only allow leaf nodes to be selected
    }
fr: 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(); 
    }

en: Changing the selection
fr: Modification de la sélection

en: To change the selection, specify a <classname>Gtk::TreeModel::iterator</classname> or <classname>Gtk::TreeModel::Row</classname>, like so:
fr: Pour modifier la sélection, précisez un <classname>Gtk::TreeModel::iterator</classname> ou <classname>Gtk::TreeModel::Row</classname>, ainsi :

en: Gtk::TreeModel::Row row = m_refModel-&gt;children()[5]; //The fifth row.
    if(row)
      refTreeSelection-&gt;select(row);
fr: Gtk::TreeModel::Row row = m_refModel-&gt;children()[5]; // 5ième ligne.
    if(row)
      refTreeSelection-&gt;select(row);

en: or
fr: ou

en: Sorting
fr: Tris

en: The standard tree models (<classname>TreeStore</classname> and <classname>ListStore</classname> derive from <classname>TreeSortable</classname>, so they offer sorting functionality. For instance, call <methodname>set_sort_column()</methodname>, to sort the model by the specified column. Or supply a callback function to <methodname>set_sort_func()</methodname> to implement a more complicated sorting algorithm.
fr: 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.

en: TreeSortable Reference
fr: Référence de TreeSortable

en: Sorting by clicking on columns
fr: Tri en cliquant sur l'en-tête de colonne

en: So that a user can click on a <classname>TreeView</classname>'s column header to sort the <classname>TreeView</classname>'s contents, call <methodname>Gtk::TreeViewModel::set_sort_column()</methodname>, supplying the model column on which model should be sorted when the header is clicked. For instance:
fr: 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 :

en: Independently sorted views of the same model
fr: Vues d'un même modèle triées de manière indépendante

en: The <classname>TreeView</classname> already allows you to show the same <classname>TreeModel</classname> in two <classname>TreeView</classname> widgets. If you need one of these TreeViews to sort the model differently than the other then you should use a <classname>TreeModelSort</classname> instead of just, for instance, <methodname>Gtk::TreeViewModel::set_sort_column()</methodname>. <classname>TreeModelSort</classname> is a model that contains another model, presenting a sorted version of that model. For instance, you might add a sorted version of a model to a <classname>TreeView</classname> like so:
fr: 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 :

en: Note, however, that the TreeView will provide iterators to the sorted model. You must convert them to iterators to the underlying child model in order to perform actions on that model. For instance:
fr: 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 :

en: TreeModelSort Reference
fr: Référence de TreeModelSort

en: Drag and Drop
fr: Glisser-déposer

en: <classname>Gtk::TreeView</classname> already implments simple drag-and-drop when used with the <classname>Gtk::ListStore</classname> or <classname>Gtk::TreeStore</classname> models. If necessary, it also allows you to implement more complex behaviour when items are dragged and dropped, using the normal <link linkend="chapter-draganddrop">Drag and Drop</link> API.
fr: <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>.

en: Reorderable rows
fr: Réarrangement de lignes

en: If you call <methodname>Gtk::TreeView::set_reorderable()</methodname> then your TreeView's items can be moved within the treeview itself. This is demonstrated in the <classname>TreeStore</classname> example.
fr: 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>.

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

en: This is demonstrated in the drag_and_drop example.
fr: Cette construction est montrée dans l'exemple du glisser-déposer.

en: Popup Context Menu
fr: Menu contextuel

en: Lots of people need to implement right-click context menus for <classname>TreeView</classname>'s so we will explain how to do that here to save you some time. Apart from one or two points, it's much the same as a normal context menu, as described in the <link linkend="sec-menus-popup">menus chapter</link>.
fr: 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>.

en: Handling <literal>button_press_event</literal>
fr: Gestion du signal <literal>button_press_event</literal>

en: To detect a click of the right mouse button, you need to handle the <literal>button_press_event</literal> signal, and check exactly which button was pressed. Because the <classname>TreeView</classname> normally handles this signal completely, you need to either override the default signal handler in a derived <classname>TreeView</classname> class, or use <methodname>connect_nofify()</methodname> instead of <methodname>connect()</methodname>. You probably also want to call the default handler before doing anything else, so that the right-click will cause the row to be selected first.
fr: 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.

en: This is demonstrated in the Popup Custom Menu example.
fr: Ceci est montré dans l'exemple Menu contextuel personnalisé.

en: Examples
fr: Exemples

en: This example has a <classname>Gtk::TreeView</classname> widget, with a <classname>Gtk::ListStore</classname> model.
fr: Voici un exemple d'élément graphique <classname>Gtk::TreeView</classname> avec un modèle <classname>Gtk::ListStore</classname>.

en: This example is very similar to the <classname>ListStore</classname> example, but uses a <classname>Gtk::TreeStore</classname> model instead, and adds children to the rows.
fr: 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.

en: This example is identical to the <classname>ListStore</classname> example, but it uses <methodname>TreeView::append_column_editable()</methodname> instead of <methodname>TreeView::append_column()</methodname>.
fr: 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>.

en: TreeView - Editable Cells
fr: TreeView - Cellules modifiables

en: This example is much like the <classname>TreeStore</classname> example, but has 2 extra columns to indicate whether the row can be dragged, and whether it can receive drag-and-dropped rows. It uses a derived <classname>Gtk::TreeStore</classname> which overrides the virtual functions as described in the <link linkend="sec-treeview-draganddrop">TreeView Drag and Drop</link> section..
fr: 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>.

en: TreeView - Drag And Drop
fr: TreeView - Glisser-déposer

en: This example is much like the <classname>ListStore</classname> example, but derives a custom <classname>TreeView</classname> in order to override the <literal>button_press_event</literal>, and also to encapsulate the tree model code in our derived class. See the <link linkend="sec-treeview-contextmenu">TreeView Popup Context Menu</link> section.
fr: 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>.

en: TreeView - Popup Context Menu
fr: TreeView - Menu contextuel

en: Combo Boxes
fr: Boîtes combinées

en: The <classname>ComboBox</classname> widgets offers a list (or tree) of choices in a dropdown menu. If appropriate, it can show extra information about each item, such as text, a picture, a checkbox, or a progress bar. The <classname>ComboBox</classname> widget usually restricts the user to the available choices, but it can optionally have an <classname>Entry</classname>, allowing the user to enter arbitrary text if the none of the available choices are suitable.
fr: 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.

en: The list is provided via a <classname>TreeModel</classname>, and columns from this model are added to the ComboBox's view with the <methodname>ComboBox::pack_start()</methodname> method. This provides flexibility and compile-time type-safety, but the <classname>ComboBoxText</classname> class provides a simpler text-based specialization in case that flexibility is not required.
fr: 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.

en: The model
fr: Le modèle

en: The model for a ComboBox can be defined and filled exactly as for a <classname>TreeView</classname>. For instance, you might derive a ComboBox class with one integer and one text columns, like so:
fr: 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 :

en: After appending rows to this model, you should provide the model to the <classname>ComboBox</classname> with the <methodname>set_model()</methodname> method. Then use the <methodname>pack_start()</methodname> or <methodname>pack_end()</methodname> methods to specify what methods will be displayed in the ComboBox. As with the TreeView you may either use the default cell renderer by passing the <classname>TreeModelColumn</classname> to the pack methods, or you may instantiate a specific <classname>CellRenderer</classname> and specify a particular mapping with either <methodname>add_attribute()</methodname> or <methodname>set_cell_data_func()</methodname>. Note that these methods are in the <classname>CellLayout</classname> base class.
fr: 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>.

en: The chosen item
fr: L'élément choisi

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

en: Gtk::TreeModel::iterator iter = m_Combo.get_active();
    if(iter)
    {
      Gtk::TreeModel::Row row = *iter;
    
      //Get the data for the selected row, using our knowledge
      //of the tree model:
      int id = row[m_Columns.m_col_id];
      set_something_id_chosen(id); //Your own function.
    }
    else
      set_nothing_chosen(); //Your own function.
fr: 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.

en: Responding to changes
fr: Réponse à une modification

en: You might need to react to every change of selection in the ComboBox, for instance to update other widgets. To do so, you should handle the "changed" signal. For instance:
fr: 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 :

en: Full Example
fr: Exemple complet

en: Simple Text Example
fr: Exemple texte simple

en: ComboBox with an Entry
fr: Boîte combinée avec saisie

en: A <classname>ComboBox</classname> may contain an <classname>Entry</classname> widget for entering of arbitrary text, by specifying true for the constructor's <literal>has_entry</literal> parameter.
fr: 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.

en: The text column
fr: La colonne texte

en: So that the Entry can interact with the drop-down list of choices, you must specify which of your model columns are the text column, with <methodname>set_entry_text_column()</methodname>. For instance: <placeholder-1/>
fr: Comme l'objet <classname>Entry</classname> peut interagir avec la liste déroulante des choix, vous devez indiquer parmi les colonnes de votre modèle quelle est la colonne texte concernée avec <methodname>set_entry_text_column()</methodname>. Par exemple : <placeholder-1/>

en: When you select a choice from the drop-down menu, the value from this column will be placed in the <classname>Entry</classname>.
fr: 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>.

en: The entry
fr: La saisie

en: Because the user may enter arbitrary text, an active model row isn't enough to tell us what text the user has inputted. Therefore, you should retrieve the <classname>Entry</classname> widget with the <methodname>ComboBoxEntry::get_entry()</methodname> method and call <methodname>get_text()</methodname> on that.
fr: É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.

en: ComboBoxEntry
fr: Boîte combinée avec saisie

en: ComboBoxEntryText
fr: Boîte combinée avec saisie de texte

en: TextView
fr: Élément graphique TextView

en: The <classname>TextView</classname> widget can be used to display and edit large amounts of formatted text. Like the <classname>TreeView</classname>, it has a model/view design. In this case the <classname>TextBuffer</classname> is the model.
fr: 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>.

en: The Buffer
fr: Le tampon

en: <classname>Gtk::TextBuffer</classname> is a model containing the data for the <classname>Gtk::TextView</classname>, like the <classname>Gtk::TreeModel</classname> used by <classname>Gtk::TreeView</classname>. This allows two or more <classname>Gtk::TextView</classname>s to share the same <classname>TextBuffer</classname>, and allows those TextBuffers to be displayed slightly differently. Or you could maintain several <classname>Gtk::TextBuffer</classname>s and choose to display each one at different times in the same <classname>Gtk::TextView</classname> widget.
fr: <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.

en: The <classname>TextView</classname> creates its own default <classname>TextBuffer</classname>, which you can access via the <methodname>get_buffer()</methodname> method.
fr: 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>.

en: Iterators
fr: Itérateurs

en: Tags and Formatting
fr: Balisages et formats

en: Tags
fr: Balisages

en: To specify that some text in the buffer should have specific formatting, you must define a tag to hold that formatting information, and then apply that tag to the region of text. For instance, to define the tag and its properties:
fr: 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 :

en: You can specify a name for the <classname>Tag</classname> when using the <methodname>create()</methodname> method, but it is not necessary.
fr: 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.

en: The <classname>Tag</classname> class has many other properties.
fr: La classe <classname>Tag</classname> dispose de nombreuses autres propriétés.

en: TagTable
fr: Tableau des balises

en: Each <classname>Gtk::TextBuffer</classname> uses a <classname>Gtk::TextBuffer::TagTable</classname>, which contains the <classname>Tag</classname>s for that buffer. 2 or more <classname>TextBuffer</classname>s may share the same <classname>TagTable</classname>. When you create <classname>Tag</classname>s you should add them to the <classname>TagTable</classname>. For instance:
fr: 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 :

en: Glib::RefPtr&lt;Gtk::TextBuffer::TagTable&gt; refTagTable =
        Gtk::TextBuffer::TagTable::create();
    refTagTable-&gt;add(refTagMatch);
    //Hopefully a future version of <application>gtkmm</application> will have a set_tag_table() method,
    //for use after creation of the buffer.
    Glib::RefPtr&lt;Gtk::TextBuffer&gt; refBuffer =
        Gtk::TextBuffer::create(refTagTable);
fr: 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);

en: You can also use <methodname>get_tag_table()</methodname> to get, and maybe modify, the <classname>TextBuffer</classname>'s default <classname>TagTable</classname> instead of creating one explicitly.
fr: 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.

en: Applying Tags
fr: Application des balises

en: If you have created a <classname>Tag</classname> and added it to the <classname>TagTable</classname>, you may apply that tag to part of the <classname>TextBuffer</classname> so that some of the text is displayed with that formatting. You define the start and end of the range of text by specifying <classname>Gtk::TextBuffer::iterator</classname>s. For instance:
fr: 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 :

en: Or you could specify the tag when first inserting the text: refBuffer-&gt;insert_with_tag(iter, "Some text", refTagMatch);
fr: Vous pouvez également définir le balisage dès l'insertion du texte : refBuffer-&gt;insert_with_tag(iter, "Un peu de texte", refTagMatch);

en: You can apply more than one <classname>Tag</classname> to the same text, by using <methodname>apply_tag()</methodname> more than once, or by using <methodname>insert_with_tags()</methodname>. The <classname>Tag</classname>s might specify different values for the same properties, but you can resolve these conflicts by using <methodname>Tag::set_priority()</methodname>.
fr: 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>.

en: Marks
fr: Marquages

en: <classname>TextBuffer</classname> iterators are generally invalidated when the text changes, but you can use a <classname>Gtk::TextBuffer::Mark</classname> to remember a position in these situations. For instance,
fr: 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 :

en: You can then use the <methodname>get_iter()</methodname> method later to create an iterator for the <classname>Mark</classname>'s new position.
fr: 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>.

en: There are two built-in <classname>Mark</classname>s - <literal>insert</literal> and <literal>select_bound</literal>, which you can access with <classname>TextBuffer</classname>'s <methodname>get_insert()</methodname> and <methodname>get_selection_bound()</methodname> methods.
fr: 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>.

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

en: Like the <classname>TreeView</classname>, you should probably put your <classname>TextView</classname> inside a <classname>ScrolledWindow</classname> to allow the user to see and move around the whole text area with scrollbars.
fr: 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.

en: Default formatting
fr: Format par défaut

en: <classname>TextView</classname> has various methods which allow you to change the presentation of the buffer for this particular view. Some of these may be overridden by the <classname>Gtk::TextTag</classname>s in the buffer, if they specify the same things. For instance, <methodname>set_left_margin()</methodname>, <methodname>set_right_margin()</methodname>, <methodname>set_indent()</methodname>, etc.
fr: <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.

en: Scrolling
fr: Défilement

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

en: Widgets and ChildAnchors
fr: Éléments graphiques et ancres pour enfant

en: You can embed widgets, such as <classname>Gtk::Button</classname>s, in the text. Each such child widget needs a <classname>ChildAnchor</classname>. ChildAnchors are associated with <classname>iterators</classname>. For instance, to create a child anchor at a particular position, use <methodname>Gtk::TextBuffer::create_child_anchor()</methodname>:
fr: 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> :

en: Then, to add a widget at that position, use <methodname>Gtk::TextView::add_child_at_anchor()</methodname>:
fr: Puis, pour ajouter l'élément graphique à la position indiquée, servez-vous de <methodname>Gtk::TextView::add_child_at_anchor()</methodname> :

en: Menus and Toolbars
fr: Menus et barres d'outils

en: There are specific APIs for Menus and toolbars, but you should usually deal with them together, using the <classname>UIManager</classname> to define <classname>Action</classname>s which you can then arrange in menu and toolbars. In this way you can handle activation of the action instead of responding to the menu and toolbar items separately. And you can enable or disable both the menu and toolbar item via the action.
fr: 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>.

en: This involves the use of the <classname>Gtk::ActionGroup</classname>, <classname>Gtk::Action</classname>, and <classname>UIManager</classname> classes, all of which should be instantiated via their <methodname>create()</methodname> methods, which return <classname>RefPtr</classname>s.
fr: 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>.

en: First create the <classname>Action</classname>s and add them to an <classname>ActionGroup</classname>, with <methodname>ActionGroup::add()</methodname>.
fr: Créez tout d'abord un objet <classname>Action</classname> et ajoutez-le à un <classname>ActionGroup</classname> avec <methodname>ActionGroup::add()</methodname>.

en: The arguments to <methodname>Action::create()</methodname> specify the action's name and how it will appear in menus and toolbars. Use stock items where possible so that you don't need to specify the label, accelerator, icon, and tooltips, and so you can use pre-existing translations.
fr: 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.

en: You can also specify a signal handler when calling <methodname>ActionGroup::add()</methodname>. This signal handler will be called when the action is activated via either a menu item or a toolbar button.
fr: 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.

en: Note that you must specify actions for sub menus as well as menu items.
fr: 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.

en: For instance:
fr: Par exemple :

en: Note that this is where we specify the names of the actions as they will be seen by users in menus and toolbars. Therefore, this is where you should make strings translatable, by putting them inside the _() macro. When we use the Gtk::Stock items, of course, translations are automatically available.
fr: 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.

en: Next you should create a <classname>UIManager</classname> and add the <classname>ActionGroup</classname> to the <classname>UIManager</classname> with <methodname>insert_action_group()</methodname> At this point is also a good idea to tell the parent window to respond to the specified keyboard shortcuts, by using <methodname>add_accel_group()</methodname>.
fr: 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>.

en: For instance,
fr: Par exemple,

en: Then, you can define the actual visible layout of the menus and toolbars, and add the UI layout to the <classname>UIManager</classname>. This "ui string" uses an XML format, in which you should mention the names of the actions that you have already created. For instance:
fr: 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 :

en: Remember that these names are just the identifiers that we used when creating the actions. They are not the text that the user will see in the menus and toolbars. We provided those human-readable names when we created the actions.
fr: 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.

en: To instantiate a <classname>Gtk::MenuBar</classname> or <classname>Gtk::Toolbar</classname> which you can actually show, you should use the <methodname>UIManager::get_widget()</methodname> method, and then add the widget to a container. For instance:
fr: 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 :

en: Popup Menus
fr: Menus contextuels

en: <classname>Menus</classname> are normally just added to a window, but they can also be displayed temporarily as the result of a mouse button click. For instance, a context menu might be displayed when the user clicks their right mouse button.
fr: 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.

en: The UI layout for a popup menu should use the <literal>popup</literal> node. For instance:
fr: La présentation UI d'un menu contextuel utilise la balise <literal>popup</literal>. Par exemple :

en: To show the popup menu, use <classname>Gtk::Menu</classname>'s <methodname>popup()</methodname> method, providing the button identifier and the time of activation, as provided by the <literal>button_press_event</literal> signal, which you will need to handle anyway. For instance:
fr: 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 :

en: 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; //It has been handled.
      }
      else
        return false;
    }
fr: 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;
    }

en: Main Menu example
fr: Exemple de menu principal

en: Main Menu
fr: Menu principal

en: Popup Menu example
fr: Exemple de menu contextuel

en: Popup Menu
fr: Menu contextuel

en: ToolPalette
fr: Palette d'outils

en: A <classname>ToolPalette</classname> is similar to a <classname>Toolbar</classname> but can contain a grid of items, categorized into groups. The user may hide or expand each group. As in a toolbar, the items may be displayed as only icons, as only text, or as icons with text.
fr: 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.

en: The <classname>ToolPalette</classname>'s items might be dragged or simply activated. For instance, the user might drag objects to a canvas to create new items there. Or the user might click an item to activate a certain brush size in a drawing application.
fr: 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é.

en: <classname>ToolItemGroup</classname>s should be added to the tool pallete via the base class's <function>Gtk::Container::add()</function> method, for instance like so:
fr: 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 :

en: 
    Gtk::ToolItemGroup* group_brushes =
      Gtk::manage(new Gtk::ToolItemGroup("Brushes"));
    m_ToolPalette.add(*group_brushes);
fr: 
    Gtk::ToolItemGroup* group_brushes =
      Gtk::manage(new Gtk::ToolItemGroup("Brosses"));
    m_ToolPalette.add(*group_brushes);

en: <classname>Gtk::ToolItem</classname>s can then be added to the group. For instance, like so:
fr: Les éléments <classname>Gtk::ToolItem</classname> sont ensuite ajoutés au groupement. Ainsi :

en: 
    Gtk::ToolButton* button = Gtk::manage(new Gtk::ToolButton(icon, "Big"));
    button-&gt;set_tooltip_text("Big Brush);
    group_brushes-&gt;insert(*button);
fr: 
    Gtk::ToolButton* button = Gtk::manage(new Gtk::ToolButton(icon, "Grande"));
    button-&gt;set_tooltip_text("Grande brosse);
    group_brushes-&gt;insert(*button);

en: You might then handle the <classname>ToolButton</classname>'s <literal>clicked</literal> signal. Alternatively, you could allow the item to be dragged to another widget, by calling <methodname>Gtk::ToolPalette::add_drag_dest()</methodname> and then using <methodname>Gtk::ToolPalette::get_drag_item()</methodname> in the other widget's <literal>drag_data_received</literal> signal handler.
fr: 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.

en: ToolPalette Reference
fr: Référence de ToolPalette

en: ToolItemGroup Reference
fr: Référence de ToolItemGroup

en: ToolItem Reference
fr: Référence de ToolItem

en: Call <methodname>add_drag_dest()</methodname> to allow items or groups to be dragged from the tool palette to a particular destination widget. You can then use <methodname>get_drag_item()</methodname> to discover which ToolItem or ToolItemGroup is being dragged. You can use <literal>dynamic_cast</literal> to discover whether is it an item or a group. For instance, you might use this in your <literal>drag_data_received</literal> signal handler, to add a dropped item, or to show a suitable icon while dragging.
fr: 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é.

en: See the <link linkend="chapter-draganddrop">Drag and Drop</link> chapter for general advice about Drag and Drop with gtkmm.
fr: Consultez le chapitre <link linkend="chapter-draganddrop">Glisser-déposer</link> pour des considérations générales sur cette fonctionnalité avec gtkmm.

en: ToolPalette Example
fr: Exemple de palette d'outils

en: This example adds a <classname>ToolPalette</classname> and a <classname>DrawingArea</classname> to a window and allows the user to drag icons from the tool palette to the drawing area. The tool palette contains several groups of items. The combo boxes allow the user to change the style and orientation of the tool palette.
fr: 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.

en: Adjustments
fr: Ajustements

en: <application>gtkmm</application> has various widgets that can be visually adjusted using the mouse or the keyboard, such as the <classname>Range</classname> widgets (described in the <link linkend="chapter-range-widgets">Range Widgets</link> section). There are also a few widgets that display some adjustable part of a larger area, such as the <classname>Viewport</classname> widget. These widgets have <classname>Gtk::Adjustment</classname> objects that express this common part of their API.
fr: <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.

en: So that applications can react to changes, for instance when a user moves a scrollbar, <classname>Gtk::Adjustment</classname> has a <literal>changed</literal> signal. You can then use the <methodname>get_changed()</methodname> method to discover the new value.
fr: 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.

en: Creating an Adjustment
fr: Création d'un objet Adjustment

en: The <classname>Gtk::Adjustment</classname> constructor is as follows:
fr: Le constructeur de <classname>Gtk::Adjustment</classname> crée la structure suivante :

en: The <parameter>value</parameter> argument is the initial value of the adjustment, usually corresponding to the topmost or leftmost position of an adjustable widget. The <parameter>lower</parameter> and <parameter>upper</parameter> arguments specifies the possible range of values which the adjustment can hold. The <parameter>step_increment</parameter> argument specifies the smaller of the two increments by which the user can change the value, while the <parameter>page_increment</parameter> is the larger one. The <parameter>page_size</parameter> argument usually corresponds somehow to the visible area of a panning widget. The <parameter>upper</parameter> argument is used to represent the bottom most or right most coordinate in a panning widget's child.
fr: 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.

en: Using Adjustments the Easy Way
fr: Facilité d'utilisation des objets Adjustment

en: The adjustable widgets can be roughly divided into those which use and require specific units for these values, and those which treat them as arbitrary numbers.
fr: 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.

en: The group which treats the values as arbitrary numbers includes the <classname>Range</classname> widgets (<classname>Scrollbars</classname> and <classname>Scales</classname>, the <classname>Progressbar</classname> widget, and the <classname>SpinButton</classname> widget). These widgets are typically "adjusted" directly by the user with the mouse or keyboard. They will treat the <parameter>lower</parameter> and <parameter>upper</parameter> values of an adjustment as a range within which the user can manipulate the adjustment's <parameter>value</parameter>. By default, they will only modify the <parameter>value</parameter> of an adjustment.
fr: 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.

en: The other group includes the <classname>Viewport</classname> widget and the <classname>ScrolledWindow</classname> widget. All of these widgets use pixel values for their adjustments. These are also typically adjusted indirectly using scrollbars. While all widgets which use adjustments can either create their own adjustments or use ones you supply, you'll generally want to let this particular category of widgets create its own adjustments.
fr: 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.

en: If you share an adjustment object between a Scrollbar and a TextView widget, manipulating the scrollbar will automagically adjust the TextView widget. You can set it up like this:
fr: 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 :

en: // creates its own adjustments
    Gtk::TextView textview;
    // uses the newly-created adjustment for the scrollbar as well
    Gtk::VScrollbar vscrollbar (*(textview.get_vadjustment()));
fr: // 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()));

en: Adjustment Internals
fr: À l'intérieur des ajustements

en: OK, you say, that's nice, but what if I want to create my own handlers to respond when the user adjusts a <classname>Range</classname> widget or a <classname>SpinButton</classname>. To access the value of a <classname>Gtk::Adjustment</classname>, you can use the <methodname>get_value()</methodname> and <methodname>set_value()</methodname> methods:
fr: 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>.

en: As mentioned earlier, <classname>Gtk::Adjustment</classname> can emit signals. This is, of course, how updates happen automatically when you share an <classname>Adjustment</classname> object between a <classname>Scrollbar</classname> and another adjustable widget; all adjustable widgets connect signal handlers to their adjustment's <literal>value_changed</literal> signal, as can your program.
fr: 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.

en: So, for example, if you have a <classname>Scale</classname> widget, and you want to change the rotation of a picture whenever its value changes, you would create a signal handler like this:
fr: 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 :

en: and connect it to the scale widget's adjustment like this:
fr: et la connectez à l'ajustement de l'élément graphique <literal>Scale</literal> ainsi :

en: What if a widget reconfigures the <parameter>upper</parameter> or <parameter>lower</parameter> fields of its <classname>Adjustment</classname>, such as when a user adds more text to a text widget? In this case, it emits the <literal>changed</literal> signal.
fr: 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>.

en: <classname>Range</classname> widgets typically connect a handler to this signal, which changes their appearance to reflect the change - for example, the size of the slider in a scrollbar will grow or shrink in inverse proportion to the difference between the <parameter>lower</parameter> and <parameter>upper</parameter> values of its <classname>Adjustment</classname>.
fr: 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>.

en: You probably won't ever need to attach a handler to this signal, unless you're writing a new type of range widget.
fr: 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.

en: Widgets Without X-Windows
fr: Éléments graphiques sans fenêtre-X

en: Some Widgets do not have an associated X-Window, so they therefore do not receive X events. This means that the signals described in the <link linkend="sec-xeventsignals">X event signals</link> section will not be emitted. If you want to capture events for these widgets you can use a special container called <classname>Gtk::EventBox</classname>, which is described in the <link linkend="sec-eventbox">EventBox</link> section.
fr: 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>.

en: Here is a list of some of these Widgets:
fr: Voici une liste de quelques uns de ces éléments graphiques :

en: These widgets are mainly used for decoration or layout, so you won't often need to capture events on them. They are intended to have no X-Window in order to improve performance.
fr: 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.

en: Some <application>gtkmm</application> widgets don't have associated X windows; they draw on their parents' windows. Because of this, they cannot receive events. Also, if they are incorrectly sized, they don't clip, so you can get messy overwriting etc. To receive events on one of these widgets, you can it inside an <classname>EventBox</classname> widget and then call <methodname>Gtk::Widget::set_events()</methodname> on the EventBox before showing it.
fr: 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.

en: Although the name <classname>EventBox</classname> emphasises the event-handling method, the widget can also be used for clipping (and more; see the example below).
fr: 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).

note: <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>
en: The constructor for <classname>Gtk::EventBox</classname> is:
fr: Le constructeur d'un objet <classname>Gtk::EventBox</classname> est :

en: A child widget can be added to the <classname>EventBox</classname> using:
fr: L'ajout d'un élément graphique enfant à un <classname>EventBox</classname> s'effectue avec :

en: The following example demonstrates both uses of an <classname>EventBox</classname> - a label is created that is clipped to a small box, and set up so that a mouse-click on the label causes the program to exit. Resizing the window reveals varying amounts of the label.
fr: 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.

en: Dialogs
fr: Boîtes de dialogue

en: Dialogs are used as secondary windows, to provide specific information or to ask questions. <classname>Gtk::Dialog</classname> windows contain a few pre-packed widgets to ensure consistency, and a <methodname>run()</methodname> method which blocks until the user dismisses the dialog.
fr: 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.

en: There are several derived <classname>Dialog</classname> classes which you might find useful. <classname>Gtk::MessageDialog</classname> is used for most simple notifications. But at other times you might need to derive your own dialog class to provide more complex functionality.
fr: 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.

en: To pack widgets into a custom dialog, you should pack them into the <classname>Gtk::VBox</classname>, available via <methodname>get_vbox()</methodname>. To just add a <classname>Button</classname> to the bottom of the <classname>Dialog</classname>, you could use the <methodname>add_button()</methodname> method.
fr: 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>.

en: The <methodname>run()</methodname> method returns an <literal>int</literal>. This may be a value from the <literal>Gtk::ResponseType</literal> if the user closed the button by clicking a standard button, or it could be the custom response value that you specified when using <methodname>add_button()</methodname>.
fr: 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>.

en: MessageDialog
fr: Boîte de dialogue Message

en: <classname>MessageDialog</classname> is a convenience class, used to create simple, standard message dialogs, with a message, an icon, and buttons for user response. You can specify the type of message and the text in the constructor, as well as specifying standard buttons via the <literal>Gtk::ButtonsType</literal> enum.
fr: <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>.

en: FileChooserDialog
fr: Boîte de dialogue Sélection de fichier

en: The <classname>FileChooserDialog</classname> is suitable for use with "Open" or "Save" menu items.
fr: La boîte de dialogue de la classe <classname>FileChooserDialog</classname> convient pour une utilisation avec les éléments de menu « Ouvrir » ou « Enregistrer ».

en: Most of the useful member methods for this class are actually in the <classname>Gtk::FileChooser</classname> base class.
fr: La plupart des fonctions membres utiles de cette classe sont en fait dans la classe de base <classname>Gtk::FileChooser</classname>.

en: FileChooser
fr: Boîte de dialogue Sélection de fichier

en: ColorSelectionDialog
fr: Boîte de dialogue Sélection de couleur

en: The <classname>ColorSelectionDialog</classname> allows the user to choose a color.
fr: La boîte de dialogue <classname>ColorSelectionDialog</classname> permet à l'utilisateur de choisir une couleur.

en: FontSelectionDialog
fr: Boîte de dialogue Sélection de police

en: The <classname>FontSelectionDialog</classname> allows the user to choose a font.
fr: La boîte de dialogue <classname>FontSelectionDialog</classname> permet à l'utilisateur de choisir une police de caractères.

en: The Drawing Area Widget
fr: L'élément graphique zone de dessin

en: The <classname>DrawingArea</classname> widget is a blank window that gives you the freedom to create any graphic you desire. Along with that freedom comes the responsibility to handle expose events on the widget. When a widget is first shown, or when it is covered and then uncovered again it needs to redraw itself. Most widgets have code to do this, but the DrawingArea does not, allowing you to write your own expose event signal handler to determine how the contents of the widget will be drawn. This is most often done by overriding the virtual <methodname>on_expose_event()</methodname> member function.
fr: 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>.

en: GTK+ uses the <ulink url="http://cairographics.org">Cairo</ulink> drawing API. With gtkmm, you may use the <ulink url="http://www.cairographics.org/cairomm/">cairomm</ulink> C++ API for cairo.
fr: 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>.

en: You can draw very sophisticated shapes using Cairo, but the methods to do so are quite basic. Cairo provides methods for drawing straight lines, curved lines, and arcs (including circles). These basic shapes can be combined to create more complex shapes and paths which can be filled with solid colors, gradients, patterns, and other things. In addition, Cairo can perform complex transformations, do compositing of images, and render antialiased text.
fr: 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.

en: Cairo and Pango
fr: Cairo et Pango

en: Although Cairo can render text, it's not meant to be a replacement for Pango. Pango is a better choice if you need to perform more advanced text rendering such as wrapping or ellipsizing text. Drawing text with Cairo should only be done if the text is part of a graphic.
fr: 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.

en: In this section of the tutorial, we'll cover the basic Cairo drawing model, describe each of the basic drawing elements in some detail (with examples), and then present a simple application that uses Cairo to draw a custom clock widget.
fr: 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.

en: The Cairo Drawing Model
fr: Le modèle de tracé Cairo

en: The basic concept of drawing in Cairo involves defining 'invisible' paths and then stroking or filling them to make them visible.
fr: Le concept de base du tracé dans Cairo consiste à définir des chemins « invisibles », puis à les tracer ou les remplir pour les rendre visibles.

en: To do any drawing in <application>gtkmm</application> with Cairo, you must first create a <classname>Cairo::Context</classname> object. This class holds all of the graphics state parameters that describe how drawing is to be done. This includes information such as line width, color, the surface to draw to, and many other things. This allows the actual drawing functions to take fewer arguments to simplify the interface. In <application>gtkmm</application>, a <classname>Cairo::Context</classname> is created by calling the <methodname>Gdk::Window::create_cairo_context()</methodname> function. Since Cairo context are reference-counted objects, this function returns a <classname>Cairo::RefPtr&lt;Cairo::Context&gt;</classname> object.
fr: 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>.

en: The following example shows how to set up a Cairo context with a foreground color of red and a width of 2. Any drawing functions that use this context will use these settings.
fr: 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.

en: Each <classname>Cairo::Context</classname> is associated with a particular <classname>Gdk::Window</classname>, so the first line of the above example creates a <classname>Gtk::DrawingArea</classname> widget and the second line uses its associated <classname>Gdk::Window</classname> to create a <classname>Cairo::Context</classname> object. The final two lines change the graphics state of the context.
fr: 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.

en: There are a number of graphics state variables that can be set for a Cairo context. The most common context attributes are color (using <methodname>set_source_rgb()</methodname> or <methodname>set_source_rgba()</methodname> for translucent colors), line width (using <methodname>set_line_width()</methodname>), line dash pattern (using <methodname>set_dash()</methodname>), line cap style (using <methodname>set_line_cap()</methodname>), and line join style (using <methodname>set_line_join()</methodname>), and font styles (using <methodname>set_font_size()</methodname>, <methodname>set_font_face()</methodname> and others). There are many other settings as well, such as transformation matrices, fill rules, whether to perform antialiasing, and others. For further information, see the <ulink url="http://www.cairographics.org/cairomm/">cairomm</ulink> API documentation.
fr: 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>.

en: It is good practice to put all modifications to the graphics state between <methodname>save()</methodname>/<methodname>restore()</methodname> function calls. For example, if you have a function that takes a <classname>Cairo::Context</classname> reference as an argument, you might implement it as follows:
fr: 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 :

en: void doSomething(Cairo::RefPtr&lt;Cairo::Context&gt; context, int x)
    {
        context-&gt;save();
        // change graphics state
        // peform drawing operations
        context-&gt;restore();
    }
fr: 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();
    }

en: The current state of a <classname>Cairo::Context</classname> can be saved to an internal stack of saved states and later be restored to the state it was in when you saved it. To do this, use the <methodname>save()</methodname> method and the <methodname>restore()</methodname> method. This can be useful if you need to temporarily change the line width and color (or any other graphics setting) in order to draw something and then return to the previous settings. In this situation, you could call <methodname>Cairo::Context::save()</methodname>, change the graphics settings, draw the lines, and then call <methodname>Cairo::Context::restore()</methodname> to restore the original graphics state. Multiple calls to <methodname>save()</methodname> and <methodname>restore()</methodname> can be nested; each call to <methodname>restore()</methodname> restores the state from the matching paired <methodname>save()</methodname>. <placeholder-1/>
fr: 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>. <placeholder-1/>

en: Drawing Straight Lines
fr: Tracé de droites

en: Since the Cairo graphics library was written with support for multiple output targets (the X window system, PNG images, OpenGL, etc), there is a distinction between user-space and device-space coordinates. The mapping between these two coordinate systems defaults to one-to-one so that integer values map roughly to pixels on the screen, but this setting can be adjusted if desired. Sometimes it may be useful to scale the coordinates so that the full width and height of a window both range from 0 to 1 (the 'unit square') or some other mapping that works for your application. this can be done with the <methodname>Cairo::Context::scale()</methodname> function.
fr: É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>.

en: Now that we understand the basics of the Cairo graphics library, we're almost ready to start drawing. We'll start with the simplest of drawing elements: the straight line. But first you need to know a little bit about Cairo's coordinate system. The origin of the Cairo coordinate system is located in the upper-left corner of the window with positive x values to the right and positive y values going down. <placeholder-1/>
fr: 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. <placeholder-1/>

en: In this example, we'll construct a small but fully functional <application>gtkmm</application> program and draw some lines into the window. The lines are drawn by creating a path and then stroking it. A path is created using the functions <methodname>Cairo::Context::move_to()</methodname> and <methodname>Cairo::Context::line_to()</methodname>. The function <methodname>move_to()</methodname> is similar to the act of lifting your pen off of the paper and placing it somewhere else -- no line is drawn between the point you were at and the point you moved to. To draw a line between two points, use the <methodname>line_to()</methodname> function.
fr: 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>.

en: After you've finished creating your path, you still haven't drawn anything visible yet. To make the path visible, you must use the function <methodname>stroke()</methodname> which will stroke the current path with the line width and style specified in your <classname>Cairo::Context</classname> object. After stroking, the current path will be cleared so that you can start on your next path.
fr: 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.

en: Many Cairo drawing functions have a <methodname>_preserve()</methodname> variant. Normally drawing functions such as <methodname>clip()</methodname>, <methodname>fill()</methodname>, or <methodname>stroke()</methodname> will clear the current path. If you use the <methodname>_preserve()</methodname> variant, the current path will be retained so that you can use the same path with the next drawing function.
fr: 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.

en: Drawing Area - Lines
fr: Zone de dessin ‑ Lignes

en: This program contains a single class, <classname>MyArea</classname>, which is a subclass of <classname>Gtk::DrawingArea</classname> and contains an <methodname>on_expose_event()</methodname> member function. This method is called whenever the image in the drawing area needs to be redrawn. This function is passed a pointer to a <classname>GdkEventExpose</classname> structure which defines the area that needs to be redrawn. We use these values to create a rectangle path in Cairo (using the <methodname>rectangle()</methodname> function) and then <methodname>clip()</methodname> to this path. The <methodname>clip()</methodname> function sets a clip region. The current clip region affects all drawing operations by effectively masking out any changes to the surface that are outside the current clip region. This allows us to limit our redrawing to only the area that needs to be redrawn. The actual drawing code sets the color we want to use for drawing by using <methodname>set_source_rgb()</methodname> which takes arguments defining the Red, Green, and Blue components of the desired color (valid values are between 0 and 1). After setting the color, we created a new path using the functions <methodname>move_to()</methodname> and <methodname>line_to()</methodname>, and then stroked this path with <methodname>stroke()</methodname>.
fr: 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>.

en: Drawing with relative coordinates
fr: Tracé en coordonnées relatives

en: In the example above we drew everything using absolute coordinates. You can also draw using relative coordinates. For a straight line, this is done with the function <methodname>Cairo::Context::rel_line_to()</methodname>.
fr: 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>.

en: Line styles
fr: Styles de trait

en: In addition to drawing basic straight lines, there are a number of things that you can customize about a line. You've already seen examples of setting a line's color and width, but there are others as well.
fr: 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.

en: If you've drawn a series of lines that form a path, you may want them to join together in a certain way. Cairo offers three different ways to join lines together: Miter, Bevel, and Round. These are show below:
fr: 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 :

en: Different join types in Cairo
fr: Différents types de raccord dans Cairo

en: The line join style is set using the function <methodname>Cairo::Context::set_line_join()</methodname>.
fr: Le type de raccord est défini avec la fonction <methodname>Cairo::Context::set_line_join()</methodname>.

en: Line ends can have different styles as well. The default style is for the line to start and stop exactly at the destination points of the line. This is called a Butt cap. The other options are Round (uses a round ending, with the center of the circle at the end point) or Square (uses a squared ending, with the center of the square at the end point). This setting is set using the function <methodname>Cairo::Context::set_line_cap()</methodname>.
fr: 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>.

en: There are other things you can customize as well, including creating dashed lines and other things. For more information , see the Cairo API documentation.
fr: 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.

en: Drawing Curved Lines
fr: Tracé de courbes

en: In addition to drawing straight lines Cairo allows you to easily draw curved lines (technically a cubic Bézier spline) using the <methodname>Cairo::Context::curve_to()</methodname> and <methodname>Cairo::Context::rel_curve_to()</methodname> functions. These functions take coordinates for a destination point as well as coordinates for two 'control' points. This is best explained using an example, so let's dive in.
fr: 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.

en: This simple application draws a curve with Cairo and displays the control points for each end of the curve.
fr: Cette simple application trace une courbe avec Cairo et affiche les points de contrôle pour chaque extrémité de la courbe.

en: The only difference between this example and the straight line example is in the <methodname>on_expose_event()</methodname> function, but there are a few new concepts and functions introduced here, so let's examine them briefly.
fr: 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.

en: Note that we clip to the area that needs re-exposing just as we did in the last example. After clipping, however, we make a call to <methodname>Cairo::Context::scale()</methodname>, passing in the width and height of the drawing area. This scales the user-space coordinate system such that the the width and height of the widget are both equal to 1.0 'units'. There's no particular reason to scale the coordinate system in this case, but sometimes it can make drawing operations easier.
fr: 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é.

en: The call to <methodname>Cairo::Context::curve_to()</methodname> should be fairly self-explanatory. The first pair of coordinates define the control point for the beginning of the curve. The second set of coordinates define the control point for the end of the curve, and the last set of coordinates define the destination point. To make the concept of control points a bit easier to visualize, a line has been draw from each control point to the end-point on the curve that it is associated with. Note that these control point lines are both translucent. This is achieved with a variant of <methodname>set_source_rgb()</methodname> called <methodname>set_source_rgba()</methodname>. This function takes a fourth argument specifying the alpha value of the color (valid values are between 0 and 1).
fr: 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).

en: Drawing Arcs and Circles
fr: Tracé des arcs et des cercles

en: With Cairo, the same function is used to draw arcs, circles, or ellipses: <methodname>Cairo::Context::arc()</methodname>. This function takes five arguments. The first two are the coordinates of the center point of the arc, the third argument is the radius of the arc, and the final two arguments define the start and end angle of the arc. All angles are defined in radians, so drawing a circle is the same as drawing an arc from 0 to 2 * M_PI radians. An angle of 0 is in the direction of the positive X axis (in user-space). An angle of M_PI/2 radians (90 degrees) is in the direction of the positive Y axis (in user-space). Angles increase in the direction from the positive X axis toward the positive Y axis. So with the default transformation matrix, angles increase in a clockwise direction.
fr: 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.

en: To draw an ellipse, you can scale the current transformation matrix by different amounts in the X and Y directions. For example, to draw an ellipse in the box given by <varname>x</varname>, <varname>y</varname>, <varname>width</varname>, <varname>height</varname>: <placeholder-1/> Note that this contradicts the <ulink url="http://www.cairographics.org/manual/cairo-Paths.html#cairo-arc">advice given in the official Cairo documentation</ulink>, but it seems to work.
fr: 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> : <placeholder-1/> 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.

en: Here's an example of a simple program that draws an arc, a circle and an ellipse into a drawing area.
fr: Voici un exemple de programme simple traçant un arc, un cercle et une ellipse sur une zone de dessin.

en: Drawing Area - Arcs
fr: Zone de dessin ‑ Arcs

en: There are a couple of things to note about this example code. Again, the only real difference between this example and the previous ones is the <methodname>on_expose_event()</methodname> function, so we'll limit our focus to that function. In addition, the first part of the function is nearly identical to the previous examples, so we'll skip that portion.
fr: 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.

en: Note that in this case, we've expressed nearly everything in terms of the height and width of the window, including the width of the lines. Because of this, when you resize the window, everything scales with the window. Also note that there are three drawing sections in the function and each is wrapped with a <methodname>save()</methodname>/<methodname>restore()</methodname> pair so that we're back at a known state after each drawing.
fr: 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é.

en: The section for drawing an arc introduces one new function, <methodname>close_path()</methodname>. This function will in effect draw a straight line from the current point back to the first point in the path. There is a significant difference between calling <methodname>close_path()</methodname> and manually drawing a line back to the starting point, however. If you use <methodname>close_path()</methodname>, the lines will be nicely joined together. If you use <methodname>line_to()</methodname> instead, the lines will end at the same point, but Cairo won't do any special joining.
fr: 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.

en: Drawing counter-clockwise
fr: Tracé en sens inverse des aiguilles d'une montre

en: The function <methodname>Cairo::Context::arc_negative()</methodname> is exactly the same as <methodname>Cairo::Context::arc()</methodname> but the angles go the opposite direction.
fr: La fonction <methodname>Cairo::Context::arc_negative()</methodname> est identique à <methodname>Cairo::Context::arc()</methodname> mais les angles tournent dans le sens opposé.

en: Drawing Text
fr: Tracé de textes

en: Drawing Text with Pango
fr: Tracé de texte avec Pango

en: Text is drawn via Pango Layouts. The easiest way to create a <classname>Pango::Layout</classname> is to use <methodname>create_pango_layout</methodname>. Once created, the layout can be manipulated in various ways, including changing the text, font, etc. Finally, the layout can be rendered using the <methodname>draw_layout</methodname> method of <classname>Gdk::Drawable</classname>, which takes a <classname>Gdk::GC</classname> object, an x-position, a y-position and the layout itself.
fr: 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.

en: Drawing Images
fr: Affichage d'images

en: Drawing Images with Gdk
fr: Affichage d'images avec Gdk

en: There are a couple of drawing methods for putting image data into a drawing area. <methodname>draw_pixmap()</methodname> can copy the contents of a <classname>Gdk::Drawable</classname> (the window of a drawing area is one) into the drawing area. There is also <methodname>draw_bitmap()</methodname> for drawing a two-color image into the drawing area, and <methodname>draw_image()</methodname> for drawing an image with more than two colors.
fr: 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.

en: For all of these methods, the first argument is the <classname>Gdk::GC</classname>. The second argument is the object of the appropriate type to copy in: <classname>Gdk::Drawable</classname>, <classname>Gdk::Bitmap</classname>, <classname>Gdk::Image</classname>. The next two arguments are the x and y points in the image to begin copying from. Then come the x and y points in the drawing area to copy to. The final two arguments are the width and height of the area to copy.
fr: 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.

en: There is also a method for drawing from a <classname>Gdk::Pixbuf</classname>. A <classname>Gdk::Pixbuf</classname> buffer is a useful wrapper around a collection of pixels, which can be read from files, and manipulated in various ways.
fr: 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.

en: Probably the most common way of creating <classname>Gdk::Pixbuf</classname>s is to use <methodname>Gdk::Pixbuf::create_from_file()</methodname>, which can read an image file, such as a png file into a pixbuf ready for rendering.
fr: 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.

en: The <classname>Gdk::Pixbuf</classname> can be rendered with <methodname>render_to_drawable</methodname>, which takes quite a few parameters. The <methodname>render_to_drawable</methodname> is a member of <classname>Gdk::Pixbuf</classname> rather than <classname>Gdk::Drawable</classname>, which is unlike the <methodname>draw_*</methodname> functions described earlier. As such, its first parameter is the drawable to render to. The second parameter is still the <classname>Gdk::GC</classname>. The next two parameters are the point in the pixbuf to start drawing from. This is followed by the point in the drawable to draw it at, and by the width and height to actually draw (which may not be the whole image, especially if you're only responding to an expose event for part of the window). Finally, there are the dithering parameters. If you use Gdk::RGB_DITHER_NONE as the dither type, then the dither offset parameters can both be 0.
fr: 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.

en: Here is a small bit of code to tie it all together: (Note that usually you wouldn't load the image every time in the expose event handler! It's just shown here to keep it all together)
fr: 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)

en: 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(), // draw the whole image (from 0,0 to the full width,height) at 100,80 in the window
    Gdk::RGB_DITHER_NONE, 0, 0);
    return true;
    }
fr: 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;
    }

en: Example Application: Creating a Clock with Cairo
fr: Exemple d'application : création d'un cadran d'horloge avec Cairo

en: Now that we've covered the basics of drawing with Cairo, let's try to put it all together and create a simple application that actually does something. The following example uses Cairo to create a custom <classname>Clock</classname> widget. The clock has a second hand, a minute hand, and an hour hand, and updates itself every second.
fr: 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.

en: As before, almost all of the interesting stuff is done in the expose event handler <methodname>on_expose_event()</methodname>. Before we dig into the expose event handler, notice that the constructor for the <classname>Clock</classname> widget connects a handler function <methodname>onSecondElapsed()</methodname> to a timer with a timeout period of 1000 milliseconds (1 second). This means that <methodname>onSecondElapsed()</methodname> will get called once per second. The sole responsibility of this function is to invalidate the window so that <application>gtkmm</application> will be forced to redraw it.
fr: 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.

en: Now let's take a look at the code that performs the actual drawing. The first section of <methodname>on_expose_event()</methodname> should be pretty familiar by now as it's mostly 'boilerplate' code for getting the <classname>Gdk::Window</classname>, creating a <classname>Cairo::Context</classname>, and clipping to the area that we want to re-draw. This example again scales the coordinate system to be a unit square so that it's easier to draw the clock as a percentage of window size so that it will automatically scale when the window size is adjusted. Furthermore, the coordinate system is scaled over and down so that the (0, 0) coordinate is in the very center of the window.
fr: 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.

en: The function <methodname>Cairo::Context::paint()</methodname> is used here to set the background color of the window. This function takes no arguments and fills the current surface (or the clipped portion of the surface) with the source color currently active. After setting the background color of the window, we draw a circle for the clock outline, fill it with white, and then stroke the outline in black. Notice that both of these actions use the <methodname>_preserve</methodname> variant to preserve the current path, and then this same path is clipped to make sure than our next lines don't go outside the outline of the clock.
fr: 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.

en: After drawing the outline, we go around the clock and draw ticks for every hour, with a larger tick at 12, 3, 6, and 9. Now we're finally ready to implement the time-keeping functionality of the clock, which simply involves getting the current values for hours, minutes and seconds, and drawing the hands at the correct angles.
fr: 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.

en: <classname>Gtk::Widget</classname> has several methods and signals which are prefixed with "drag_". These are used for Drag and Drop.
fr: <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.

en: Sources and Destinations
fr: Sources et destinations

en: Things are dragged from <literal>sources</literal> to be dropped on <literal>destinations</literal>. Each source and destination has infomation about the data formats that it can send or receive, provided by <classname>Gtk::TargetEntry</classname> items. A drop destination will only accept a dragged item if they both share a compatible <classname>Gtk::TargetEntry</classname> item. Appropriate signals will then be emitted, telling the signal handlers which <classname>Gtk::TargetEntry</classname> was used.
fr: 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é.

en: target: A name, such as "STRING"
fr: cible : un nom, tel que « STRING »

en: info: An identifier which will be sent to your signals to tell you which TargetEntry was used.
fr: info : un identifiant envoyé aux signaux pour indiquer quel TargetEntry a été utilisé.

en: flags: Used only for drag and drop, this specifies whether the data may be dragged to other widgets and applications, or only to the same ones.
fr: 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.

en: <classname>Gtk::TargetEntry</classname> objects contain this information: <placeholder-1/>
fr: Les objets <classname>Gtk::TargetEntry</classname> contiennent ces informations : <placeholder-1/>

en: <classname>Widgets</classname> can be identified as sources or destinations using these <classname>Gtk::Widget</classname> methods:
fr: 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 :

en: <literal>targets</literal> is a container of <classname>Gtk::TargetEntry</classname> (<classname>std::list&lt;Gtk::TargetEntry&gt;</classname> or <classname>std::vector&lt;Gtk::TargetEntry&gt;</classname>, for instance) elements.
fr: <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).

en: <literal>start_button_mask</literal> is an ORed combination of values, which specify which modifier key or mouse button must be pressed to start the drag.
fr: <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.

en: <literal>actions</literal> is an ORed combination of values, which specified which Drag and Drop operations will be possible from this source - for instance, copy, move, or link. The user can choose between the actions by using modifier keys, such as <keycap>Shift</keycap> to change from <literal>copy</literal> to <literal>move</literal>, and this will be shown by a different cursor.
fr: <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.

en: <literal>flags</literal> is an ORed combination of values which indicates how the widget will respond visually to Drag and Drop items.
fr: <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.

en: <literal>actions</literal> indicates the Drag and Drop actions which this destination can receive - see the description above.
fr: <literal>actions</literal> indique les actions de glisser-déposer que cette destination peut accepter — voir la description plus haut.

en: When a drop destination has accepted a dragged item, certain signals will be emitted, depending on what action has been selected. For instance, the user might have held down the <keycap>Shift</keycap> key to specify a <literal>move</literal> rather than a <literal>copy</literal>. Remember that the user can only select the actions which you have specified in your calls to <methodname>drag_dest_set()</methodname> and <methodname>drag_source_set()</methodname>.
fr: 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>.

en: Copy
fr: Copie

en: <literal>drag_begin</literal>: Provides DragContext.
fr: <literal>drag_begin</literal> : fournit un objet DragContext.

en: <literal>drag_motion</literal>: Provides DragContext and coordinates. You can call the drag_status() method of the DragContext to indicate which target will be accepted.
fr: <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.

en: <literal>drag_get</literal>: Provides <literal>info</literal> about the dragged data format, and a <literal>GtkSelectionData</literal> structure, in which you should put the requested data.
fr: <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.

en: <literal>drag_drop</literal>: Provides DragContext and coordinates.
fr: <literal>drag_drop</literal> : fournit un objet DragContext et les coordonnées.

en: <literal>drag_end</literal>: Provides DragContext.
fr: <literal>drag_end</literal> : fournit un objet DragContext.

en: The source widget will emit these signals, in this order: <placeholder-1/>
fr: L'élément graphique source va émettre ces signaux, dans cet ordre : <placeholder-1/>

en: <literal>drag_data_received</literal>: Provides <literal>info</literal> about the dragged data format, and a <literal>GtkSelectionData</literal> structure which contains the dropped data. You should call the <methodname>drag_finish()</methodname> method of the <literal>DragContext</literal> to indicate whether the operation was successful.
fr: <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.

en: The destination widget will emit this signal, after the source destination has emitted the <literal>drag_get</literal> signal: <placeholder-1/>
fr: L'élément graphique destination émet ce signal après que l'élément source a émis le signal <literal>drag_get</literal> : <placeholder-1/>

en: Move
fr: Déplacement

en: <literal>drag_delete</literal>: Gives the source the opportunity to delete the original data if that's appropriate.
fr: <literal>drag_delete</literal> : offre à la source la possibilité de détruire les données initiales si c'est approprié.

en: During a <literal>move</literal>, the source widget will also emit this signal: <placeholder-1/>
fr: Pendant un <literal>déplacement</literal>, l'élément graphique source émet également le signal : <placeholder-1/>

en: The drag and drop signals provide a DragContext, which contains some information about the drag and drop operation and can be used to influence the process. For instance, you can discover the source widget, or change the drag and drop icon, by using the <methodname>set_icon()</methodname> methods. More importantly, you should call the <methodname>drag_finish()</methodname> method from your <literal>drag_data_received</literal> signal handler to indicate whether the drop was successful.
fr: 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.

en: Here is a very simple example, demonstrating a drag and drop <literal>Copy</literal> operation:
fr: Voici un exemple très simple montrant une opération de glisser-déposer avec <literal>copie</literal> :

en: There is a more complex example in examples/dnd.
fr: Dans le dossier examples/dnd, vous pouvez trouver un exemple un peu plus élaboré.

en: The Clipboard
fr: Le presse-papier

en: Simple text copy-paste functionality is provided for free by widgets such as Gtk::Entry and Gtk::TextView, but you might need special code to deal with your own data formats. For instance, a drawing program would need special code to allow copy and paste within a view, or between documents.
fr: 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.

en: <classname>Gtk::Clipboard</classname> is a singleton. You can get the one and only instance with <methodname>Gtk::Clipboard::get()</methodname>.
fr: 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>.

en: So your application doesn't need to wait for clipboard operations, particularly between the time when the user chooses Copy and then later chooses Paste, most <classname>Gtk::Clipboard</classname> methods take <classname>sigc::slot</classname>s which specify callback methods. When <classname>Gtk::Clipboard</classname> is ready, it will call these methods, either providing the requested data, or asking for data.
fr: 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.

en: Targets
fr: Cibles

en: Different applications contain different types of data, and they might make that data available in a variety of formats. <application>gtkmm</application> calls these data types <literal>target</literal>s.
fr: 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).

en: For instance, gedit can supply and receive the <literal>"UTF8_STRING"</literal> target, so you can paste data into gedit from any application that supplies that target. Or two different image editing applications might supply and receive a variety of image formats as targets. As long as one application can receive one of the targets that the other supplies then you will be able to copy data from one to the other.
fr: 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.

en: A target can be in a variety of binary formats. This chapter, and the examples, assume that the data is 8-bit text. This would allow us to use an XML format for the clipboard data. However this would probably not be appropriate for binary data such as images. <classname>Gtk::Clipboard</classname> provides overloads that allow you to specify the format in more detail if necessary.
fr: 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.

en: The <link linkend="chapter-draganddrop">Drag and Drop</link> API uses the same mechanism. You should probably use the same data targets and formats for both Clipboard and Drag and Drap operations.
fr: 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.

en: When the user asks to copy some data, you should tell the <classname>Clipboard</classname> what targets are available, and provide the callback methods that it can use to get the data. At this point you should store a copy of the data, to be provided when the clipboard calls your callback method in repsonse to a paste.
fr: 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.

en: Glib::RefPtr&lt;Gtk::Clipboard&gt; refClipboard = Gtk::Clipboard::get();
    
    //Targets:
    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) );
fr: 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) );

en: Your callback will then provide the store data when the user chooses to paste the data. For instance:
fr: Votre fonction de rappel fournit alors les données enregistrées quand l'utilisateur décide de coller les données. Par exemple :

en: The <literal>ideal</literal> example below can supply more than one clipboard target.
fr: L'exemple « <literal>idéal</literal> » ci-après peut fournir plus d'une cible de presse-papier.

en: The clear callback allows you to free the memory used by your stored data when the clipboard replaces its data with something else.
fr: 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.

en: Paste
fr: Coller

en: When the user asks to paste data from the <classname>Clipboard</classname>, you should request a specific format and provide a callback method which will be called with the actual data. For instance:
fr: 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 :

en: Here is an example callback method:
fr: Voici un exemple de fonction de rappel :

en: void ExampleWindow::on_clipboard_received(
        const Gtk::SelectionData&amp; selection_data)
    {
      Glib::ustring clipboard_data = selection_data.get_data_as_string();
      //Do something with the pasted data.
    }
fr: 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.
    }

en: Discovering the available targets
fr: Détermination des cibles admissibles

en: To find out what targets are currently available on the <classname>Clipboard</classname> for pasting, call the <methodname>request_targets()</methodname> method, specifying a method to be called with the information. For instance:
fr: 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 :

en: In your callback, compare the list of available targets with those that your application supports for pasting. You could enable or disable a Paste menu item, depending on whether pasting is currently possible. For instance:
fr: 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 :

en: void ExampleWindow::on_clipboard_received_targets(
      const Glib::StringArrayHandle&amp; targets_array)
    {
      // Get the list of available clipboard targets:
      std::list&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);
    }
fr: 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);
    }

en: This example allows copy and pasting of application-specific data, using the standard text target. Although this is simple, it's not ideal because it does not identify the <classname>Clipboard</classname> data as being of a particular type.
fr: 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é.

en: Clipboard - Simple
fr: Presse-papier - Simple

en: Ideal
fr: Idéal

en: Defines a custom clipboard target, though the format of that target is still text.
fr: définit une cible de presse-papier personnalisée, même si le format de cette cible est toujours du texte,

en: It supports pasting of 2 targets - both the custom one and a text one that creates an arbitrary text representation of the custom data.
fr: 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,

en: It uses <methodname>request_targets()</methodname> and the <literal>owner_change</literal> signal and disables the Paste button if it can't use anything on the clipboard.
fr: 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.

en: This is like the simple example, but it <placeholder-1/>
fr: Il est identique à l'exemple simple, mais il <placeholder-1/>

en: Clipboard - Ideal
fr: Presse-papier - Idéal

en: Printing
fr: Impression

en: Printing support is available in <application>gtkmm</application> version 2.10 and later.
fr: La prise en charge de l'impression est disponible dans les versions <application>gtkmm</application> 2.10 et ultérieures.

en: At the application development level, <application>gtkmm</application>'s printing API provides dialogs that are consistent across applications and allows us of Cairo's common drawing API, with Pango-driven text rendering. In the implementation of this common API, platform-specific backends and printer-specific drivers are used.
fr: 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.

en: PrintOperation
fr: Objet PrintOperation

en: The primary object is <classname>Gtk::PrintOperation</classname>, allocated for each print operation. To handle page drawing connect to its signals, or inherit from it and override the default virtual signal handlers. <classname>PrintOperation</classname> automatically handles all the settings affecting the print loop.
fr: 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.

en: <literal>begin_print</literal>: You must handle this signal, because this is where you create and set up a <classname>Pango::Layout</classname> using the provided <classname>Gtk::PrintContext</classname>, and break up your printing output into pages.
fr: <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.

en: <literal>paginate</literal>: Pagination is potentially slow so if you need to monitor it you can call the <methodname>PrintOperation::set_show_progress()</methodname> method and handle this signal.
fr: <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.

en: <literal>request_page_setup</literal>: Provides a <classname>PrintContext</classname>, page number and <classname>Gtk::PageSetup</classname>. Handle this signal if you need to modify page setup on a per-page basis.
fr: <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.

en: <literal>draw_page</literal>: You must handle this signal, which provides a <classname>PrintContext</classname> and a page number. The <classname>PrintContext</classname> should be used to create a <classname>Cairo::Context</classname> into which the provided page should be drawn. To render text, iterate over the <classname>Pango::Layout</classname> you created in the <literal>begin_print</literal> handler.
fr: <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>.

en: For each page that needs to be rendered, the following signals are emitted: <placeholder-1/>
fr: Pour chaque page devant être imprimée, les signaux suivants sont émis : <placeholder-1/>

en: <literal>end_print</literal>: A handler for it is a safe place to free any resources related to a <classname>PrintOperation</classname>. If you have your custom class that inherits from <classname>PrintOperation</classname>, it is naturally simpler to do it in the destructor.
fr: <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.

en: <literal>done</literal>: This signal is emitted when printing is finished, meaning when the print data is spooled. Note that the provided <literal>Gtk::PrintOperationResult</literal> may indicate that an error occurred. In any case you probably want to notify the user about the final status.
fr: <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.

en: <literal>status_changed</literal>: Emitted whenever a print job's status changes, until it is finished. Call the <methodname>PrintOperation::set_track_print_status()</methodname> method to monitor the job status after spooling. To see the status, use <methodname>get_status()</methodname> or <methodname>get_status_string()</methodname>.
fr: <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>.

en: The <methodname>PrintOperation::run()</methodname> method starts the print loop, during which various signals are emitted: <placeholder-1/>
fr: La fonction membre <methodname>PrintOperation::run()</methodname> démarre la boucle d'impression au cours de laquelle divers signaux sont émis : <placeholder-1/>

en: Page setup
fr: Mise en page

en: The <classname>PrintOperation</classname> class has a method called <methodname>set_default_page_setup()</methodname> which selects the default paper size, orientation and margins. To show a page setup dialog from your application, use the <methodname>Gtk::run_page_setup_dialog()</methodname> method, which returns a <classname>Gtk::PageSetup</classname> object with the chosen settings. Use this object to update a <classname>PrintOperation</classname> and to access the selected <classname>Gtk::PaperSize</classname>, <literal>Gtk::PageOrientation</literal> and printer-specific margins.
fr: 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.

en: You should save the chosen <classname>Gtk::PageSetup</classname> so you can use it again if the page setup dialog is shown again.
fr: 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.

en: 
    //Within a class that inherits from Gtk::Window and keeps m_refPageSetup and m_refSettings as members...
    Glib::RefPtr&lt;Gtk::PageSetup&gt; new_page_setup = Gtk::run_page_setup_dialog(*this, m_refPageSetup, m_refSettings);
    m_refPageSetup = new_page_setup;
fr: 
    // 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;

en: For instance, <placeholder-1/>
fr: Par exemple, <placeholder-1/>

en: The Cairo coordinate system, in the <literal>draw_page</literal> handler, is automatically rotated to the current page orientation. It is normally within the printer margins, but you can change that via the <methodname>PrintOperation::set_use_full_page()</methodname> method. The default measurement unit is device pixels. To select other units, use the <methodname>PrintOperation::set_unit()</methodname> method.
fr: 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>.

en: Rendering text
fr: Rendu de texte

en: Text rendering is done using Pango. The <classname>Pango::Layout</classname> object for printing should be created by calling the <methodname>PrintContext::create_pango_layout()</methodname> method. The <classname>PrintContext</classname> object also provides the page metrics, via <methodname>get_width()</methodname> and <methodname>get_height()</methodname>. The number of pages can be set with <methodname>PrintOperation::set_n_pages()</methodname>. To actually render the Pango text in <literal>on_draw_page</literal>, get a <classname>Cairo::Context</classname> with <methodname>PrintContext::get_cairo_context()</methodname> and show the <classname>Pango::LayoutLine</classname>s that appear within the requested page number.
fr: 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.

en: See <link linkend="sec-printing-example-simple">an example</link> of exactly how this can be done.
fr: Pour voir exactement comment réaliser ceci, consultez <link linkend="sec-printing-example-simple">cet exemple</link>.

en: Asynchronous operations
fr: Opérations asynchrones

en: By default, <methodname>PrintOperation::run()</methodname> returns when a print operation is completed. If you need to run a non-blocking print operation, call <methodname>PrintOperation::set_allow_async()</methodname>. Note that <methodname>set_allow_async()</methodname> is not supported on all platforms, however the <literal>done</literal> signal will still be emitted.
fr: 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.

en: <methodname>run()</methodname> may return <literal>PRINT_OPERATION_RESULT_IN_PROGRESS</literal>. To track status and handle the result or error you need to implement signal handlers for the <literal>done</literal> and <literal>status_changed</literal> signals:
fr: 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> :

en: 
    // in class ExampleWindow's method...
    Glib::RefPtr&lt;PrintOperation&gt; op = PrintOperation::create();
    // ...set up op...
    op-&gt;signal_done().connect(sigc::bind(sigc::mem_fun(*this, &amp;ExampleWindow::on_printoperation_done), op));
    // run the op
fr: 
    // 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

en: 
    void ExampleWindow::on_printoperation_done(Gtk::PrintOperationResult result, const Glib::RefPtr&lt;PrintOperation&gt;&amp; op)
    {
      if (result == Gtk::PRINT_OPERATION_RESULT_ERROR)
        //notify user
      else if (result == Gtk::PRINT_OPERATION_RESULT_APPLY)
        //Update PrintSettings with the ones used in this PrintOperation
    
      if (! op-&gt;is_finished())
        op-&gt;signal_status_changed().connect(sigc::bind(sigc::mem_fun(*this, &amp;ExampleWindow::on_printoperation_status_changed), op));
    }
fr: 
    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));
    }

en: Second, check for an error and connect to the <literal>status_changed</literal> signal. For instance: <placeholder-1/>
fr: Ensuite, vérifiez si une erreur est survenue et connectez le signal <literal>status_changed</literal>. Par exemple : <placeholder-1/>

en: 
    void ExampleWindow::on_printoperation_status_changed(const Glib::RefPtr&lt;PrintFormOperation&gt;&amp; op)
    {
      if (op-&gt;is_finished())
        //the print job is finished
      else
        //get the status with get_status() or get_status_string()
    
      //update UI
    }
fr: 
    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
    }

en: Finally, check the status. For instance, <placeholder-1/>
fr: Pour terminer, vérifiez l'état. Par exemple : <placeholder-1/>

en: Export to PDF
fr: Exportation au format PDF

en: 
    Glib::RefPtr&lt;Gtk::PrintOperation&gt; op = Gtk::PrintOperation::create();
    // ...set up op...
    op-&gt;set_export_filename("test.pdf");
    Gtk::PrintOperationResult res = op-&gt;run(Gtk::PRINT_OPERATION_ACTION_EXPORT);
fr: 
    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);

en: The 'Print to file' option is available in the print dialog, without the need for extra implementation. However, it is sometimes useful to generate a pdf file directly from code. For instance, <placeholder-1/>
fr: 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, <placeholder-1/>

en: Extending the print dialog
fr: Extension de la boîte de dialogue d'impression

en: Set the title of the tab via <methodname>PrintOperation::set_custom_tab_label()</methodname>, create a new widget and return it from the <literal>create_custom_widget</literal> signal handler. You'll probably want this to be a container widget, packed with some others.
fr: 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.

en: Get the data from the widgets in the <literal>custom_widget_apply</literal> signal handler.
fr: recueillez les données des éléments graphiques dans le gestionnaire de signal <literal>custom_widget_apply</literal>.

en: You may add a custom tab to the print dialog: <placeholder-1/>
fr: Vous pouvez ajouter un onglet personnalisé à la boîte de dialogue d'impression : <placeholder-1/>

en: 
    Gtk::Widget* CustomPrintOperation::on_create_custom_widget()
    {
      set_custom_tab_label("My custom tab");
    
      Gtk::HBox* hbox = new Gtk::HBox(false, 8);
      hbox-&gt;set_border_width(6);
    
      Gtk::Label* label = Gtk::manage(new Gtk::Label("Enter some text: "));
      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();
      //...
    }
fr: 
    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();
      //...
    }

en: Although the <literal>custom_widget_apply</literal> signal provides the widget you previously created, to simplify things you can keep the widgets you expect to contain some user input as class members. For example, let's say you have a <classname>Gtk::Entry</classname> called <literal>m_Entry</literal> as a member of your <classname>CustomPrintOperation</classname> class: <placeholder-1/>
fr: 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> : <placeholder-1/>

en: The example in examples/book/printing/advanced demonstrates this.
fr: L'exemple dans le dossier <filename>examples/book/printing/advanced</filename> démontre cette façon d'opérer.

en: Preview
fr: Aperçu

en: 
    // in a class that inherits from Gtk::Window...
    Glib::RefPtr&lt;PrintOperation&gt; op = PrintOperation::create();
    // ...set up op...
    op-&gt;run(Gtk::PRINT_OPERATION_ACTION_PREVIEW, *this);
fr: 
    // 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);

en: The native GTK+ print dialog has a preview button, but you may also start a preview directly from an application: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: On Unix, the default preview handler uses an external viewer program. On Windows, the native preview dialog will be shown. If necessary you may override this behaviour and provide a custom preview dialog. See the example located in /examples/book/printing/advanced.
fr: 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>.

en: The following example demonstrates how to print some input from a user interface. It shows how to implement <literal>on_begin_print</literal> and <literal>on_draw_page</literal>, as well as how to track print status and update the print settings.
fr: 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.

en: Printing - Simple
fr: Impression - Simple

en: Recently Used Documents
fr: Documents récents

en: Recent Files support is available in <application>gtkmm</application> version 2.10 and later
fr: La prise en charge des « Fichiers récents... » est disponible dans <application>gtkmm</application> version 2.10 et ultérieures

en: <application>gtkmm</application> provides an easy way to manage recently used documents. The classes involved in implementing this functionality are <classname>RecentManager</classname>, <classname>RecentChooserDialog</classname>, <classname>RecentChooserMenu</classname>, <classname>RecentChooserWidget</classname>, and <classname>RecentFilter</classname>.
fr: <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>.

en: Each item in the list of recently used files is identified by its URI, and can have associated metadata. The metadata can be used to specify how the file should be displayed, a description of the file, its mime type, which application registered it, whether it's private to the registering application, and several other things.
fr: 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.

en: RecentManager
fr: La classe RecentManager

en: <classname>RecentManager</classname> acts as the central database of recently used files. You use this class to register new files, remove files from the list, or look up recently used files.
fr: 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.

en: You can create a new <classname>RecentManager</classname>, but you'll most likely just want to use the default one. You can get a reference to the default <classname>RecentManager</classname> with <methodname>get_default()</methodname>.
fr: 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>.

en: Adding Items to the List of Recent Files
fr: Ajout d'éléments à la liste des fichiers récents

en: To add a new file to the list of recent documents, in the simplest case, you only need to provide the URI. For example:
fr: 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 :

en: If you want to register a file with metadata, you can pass a <classname>RecentManager::Data</classname> parameter to <methodname>add_item()</methodname>. The metadata that can be set on a particular file item is as follows:
fr: 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 :

en: <varname>app_exec</varname>: The command line to be used to launch this resource. This string may contain the "f" and "u" escape characters which will be expanded to the resource file path and URI respectively
fr: <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.

en: <varname>app_name</varname>: The name of the application that registered the resource
fr: <varname>app_name</varname> : le nom de l'application qui a enregistré la ressource.

en: <varname>description</varname>: A short description of the resource as a UTF-8 encoded string
fr: <varname>description</varname> : une courte description de la ressource sous forme d'une chaîne UTF-8.

en: <varname>display_name</varname>: The name of the resource to be used for display as a UTF-8 encoded string
fr: <varname>display_name</varname> : le nom de la ressource à utiliser pour l'affichage sous forme d'une chaîne UTF-8.

en: <varname>groups</varname>: A list of groups associated with this item. Groups are essentially arbitrary strings associated with a particular resource. They can be thought of as 'categories' (such as "email", "graphics", etc) or tags for the resource.
fr: <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.

en: <varname>is_private</varname>: Whether this resource should be visible only to applications that have registered it or not
fr: <varname>is_private</varname> : indique si la ressource ne doit être visible que des applications qui l'ont enregistrée ou non.

en: <varname>mime_type</varname>: The MIME type of the resource
fr: <varname>mime_type</varname> : le type MIME de la ressource.

en: In addition to adding items to the list, you can also look up items from the list and modify or remove items.
fr: 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.

en: Looking up Items in the List of Recent Files
fr: Examen des éléments de la liste des fichiers récents

en: To look up recently used files, <classname>RecentManager</classname> provides several functions. To look up a specific item by its URI, you can use the <methodname>lookup_item()</methodname> function, which will return a <classname>RecentInfo</classname> class. If the specified URI did not exist in the list of recent files, the <classname>RecentInfo</classname> object will be invalid. <classname>RecentInfo</classname> provides an implementation for <methodname>operator bool()</methodname> which can be used to test for validity. For example:
fr: 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 :

en: Gtk::RecentInfo info = recent_manager-&gt;lookup_item(uri);
    if (info)
    {
      // item was found
    }
fr: Gtk::RecentInfo info = recent_manager-&gt;lookup_item(uri);
    if (info)
    {
      // l'élément a été trouvé
    }

en: A <classname>RecentInfo</classname> object is essentially an object containing all of the metadata about a single recently-used file. You can use this object to look up any of the properties listed above. FIXME - add cross-reference.
fr: 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.

en: If you don't want to look for a specific URI, but instead want to get a list of all recently used items, <classname>RecentManager</classname> provides the <methodname>get_items()</methodname> function. The return value of this function can be assigned to any standard C++ container (e.g. <classname>std::vector</classname>, <classname>std::list</classname>, etc) and contains a list of all recently-used files up to a user-defined limit (FIXME: what's the default limit?). The following code demonstrates how you might get a list of recently-used files:
fr: 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 :

en: The limit on the number of items returned can be set by <methodname>set_limit()</methodname>, and queried with <methodname>get_limit()</methodname>.
fr: 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.

en: Modifying the List of Recent Files
fr: Modification de la liste des fichiers récents

en: There may be times when you need to modify the list of recent files. For instance, if a file is moved or renamed, you may need to update the file's location in the recent files list so that it doesn't point to an incorrect location. You can update an item's location by using <methodname>move_item()</methodname>.
fr: 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>.

en: In addition to changing a file's URI, you can also remove items from the list, either one at a time or by clearint them all at once. The former is accomplished with <methodname>remove_item()</methodname>, the latter with <methodname>purge_items()</methodname>.
fr: 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>.

en: The functions <methodname>move_item()</methodname>, <methodname>remove_item()</methodname> and <methodname>purge_items()</methodname> have no effect on the actual files that are referred to by the URIs, they only modify the list of recent files.
fr: 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.

en: RecentChooser
fr: La classe RecentChooser

en: <classname>RecentChooser</classname> is an interface that can be implemented by widgets displaying the list of recently used files. <application>gtkmm</application> provides three built-in implementations for choosing recent files: <classname>RecentChooserWidget</classname>, <classname>RecentChooserDialog</classname>, and <classname>RecentChooserMenu</classname>.
fr: <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>.

en: <classname>RecentChooserWidget</classname> is a simple widget for displaying a list of recently used files. <classname>RecentChooserWidget</classname> is the basic building block for <classname>RecentChooserDialog</classname>, but you can embed it into your user interface if you want to.
fr: <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.

en: The last class that implements the <classname>RecentChooser</classname> interface is <classname>RecentChooserMenu</classname>. This class allows you to list recently used files as a menu.
fr: 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.

en: Simple RecentChooserWidget example
fr: Exemple simple de l'utilisation de RecentChooserWidget

en: Shown below is a simple example of how to use the <classname>RecentChooserDialog</classname> class in a program. This simple program has a menubar with a "Recent Files Dialog" menu item. When you select this menu item, a dialog pops up showing the list of recently used files.
fr: 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.

en: If this is the first time you're using a program that uses the Recent Files framework, the dialog may be empty at first. Otherwise it should show the list of recently used documents registered by other applications.
fr: À 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.

en: After selecting the <guimenuitem>Recent Files Dialog</guimenuitem> menu item, you should see something similar to the following window.
fr: 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.

en: The constructor for <classname>ExampleWindow</classname> creates the menu using <classname>UIManager</classname> (see <xref linkend="chapter-menus-and-toolbars"/> for more information). It then adds the menu and the toolbar to the window.
fr: 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.

en: Filtering Recent Files
fr: Filtrage des fichiers récents

en: For any of the <classname>RecentChooser</classname> classes, if you don't wish to display all of the items in the list of recent files, you can filter the list to show only those that you want. You can filter the list with the help of the <classname>RecentFilter</classname> class. This class allows you to filter recent files by their name (<methodname>add_pattern()</methodname>), their mime type (<methodname>add_mime_type()</methodname>), the application that registered them (<methodname>add_application()</methodname>), or by a custom filter function (<methodname>add_custom()</methodname>). It also provides the ability to filter based on how long ago the file was modified and which groups it belongs to.
fr: 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.

en: After you've created and set up the filter to match only the items you want, you can apply a filter to a chooser widget with the <methodname>RecentChooser::add_filter()</methodname> function.
fr: 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>.

en: Plugs and Sockets
fr: Greffons et connecteurs

en: Overview
fr: Aperçu

en: From time to time, it may be useful to be able to embed a widget from another application within your application. <application>gtkmm</application> allows you to do this with the <classname>Gtk::Socket</classname> and <classname>Gtk::Plug</classname> classes. It is not anticipated that very many applications will need this functionality, but in the rare case that you need to display a widget that is running in a completely different process, these classes can be very helpful.
fr: 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.

en: The communication between a <classname>Socket</classname> and a <classname>Plug</classname> follows the XEmbed protocol. This protocol has also been implemented in other toolkits (e.g. Qt), which allows the same level of integration when embedding a Qt widget in GTK+ or vice versa.
fr: 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.

en: The way that <classname>Sockets</classname> and <classname>Plugs</classname> work together is through their window ids. Both a <classname>Socket</classname> and a <classname>Plug</classname> have IDs that can be retrieved with their <methodname>get_id()</methodname> member functions. The use of these IDs will be explained below in <xref linkend="sec-connecting-plugs-sockets"/>.
fr: 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"/>.

en: Sockets
fr: Connecteurs

en: A <classname>Socket</classname> is a special kind of container widget that provides the ability to embed widgets from one process into another process in a way that is transparent to the user.
fr: 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.

en: Plugs
fr: Greffons

en: A <classname>Plug</classname> is a special kind of Window that can be plugged into a <classname>Socket</classname>. Besides the normal properties and methods of <classname>Gtk::Window</classname>, a <classname>Plug</classname> provides a constructor that takes the ID of a <classname>Socket</classname>, which will automatically embed the <classname>Plug</classname> into the <classname>Socket</classname> that matches that ID.
fr: 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.

en: Since a <classname>Plug</classname> is just a special type of <classname>Gtk::Window</classname> class, you can add containers or widgets to it like you would to any other window.
fr: 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.

en: Connecting Plugs and Sockets
fr: Branchement des greffons et des connecteurs

en: After a <classname>Socket</classname> or <classname>Plug</classname> object is realized, you can obtain its ID with its <methodname>get_id()</methodname> function. This ID can then be shared with other processes so that other processes know how to connect to eachother.
fr: 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.

en: Create a <classname>Socket</classname> object in one process and pass the ID of that <classname>Socket</classname> to another process so that it can create a <classname>Plug</classname> object by specifying the given <classname>Socket</classname> ID in its constructor. There is no way to assign a <classname>Plug</classname> to a particular <classname>Socket</classname> after creation, so you must pass the <classname>Socket</classname> ID to the <classname>Plug</classname>'s constructor.
fr: 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>.

en: Create a <classname>Plug</classname> independantly from any particular <classname>Socket</classname> and pass the ID of the <classname>Plug</classname> to other processes that need to use it. The ID of the <classname>Plug</classname> can be associated with a particular <classname>Socket</classname> object using the <methodname>Socket::add_id()</methodname> function. This is the approach used in the example below.
fr: 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.

en: There are two basic strategies that can be used: <placeholder-1/>
fr: Il y a deux stratégies de base utilisables : <placeholder-1/>

en: Plugs and Sockets Example
fr: Exemple greffons et connecteurs

en: The following is a simple example of using sockets and plugs. The method of communication between processes is deliberately kept very simple: The <classname>Plug</classname> writes its ID out to a text file named <filename>plug.id</filename> and the process with the socket reads the ID from this files. In a real program, you may want to use a more sophisticated method of inter-process communication.
fr: 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.

en: This example creates two executable programs: <filename>socket</filename> and <filename>plug</filename>. The idea is that <filename>socket</filename> has an application window that will embed a widget from the <filename>plug</filename> program. The way this example is designed, <filename>plug</filename> must be running first before starting <filename>socket</filename>. To see the example in action, execute the following commands in order from within the example directory:
fr: 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 :

en: Start the <filename>plug</filename> program and send it to the background (or just use a different terminal).
fr: Lancez le programme <filename>plug</filename> et envoyez-le en arrière-plan (ou simplement utilisez un terminal différent) :

en: After which you should see something like the following:
fr: Après cette action, vous devriez voir s'afficher :

en: Then start the <filename>socket</filename> program:
fr: puis lancez le programme <filename>socket</filename> :

en: After starting <filename>socket</filename>, you should see the following output in the terminal:
fr: Après avoir lancé <filename>socket</filename>, vous devriez voir les sorties suivantes sur le terminal :

en: The first line of output is from <filename>plug</filename>, after it has been notified that it has been embedded inside of a <classname>Socket</classname>. The second line was emitted by <filename>socket</filename> in response to its <methodname>plug_added</methodname> signal. If everything was done as described above, the <filename>socket</filename> window should look roughly like the following:
fr: 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 :

en: If for some reason the <classname>Socket</classname> couldn't attach the <classname>Plug</classname>, the window would look something like this:
fr: Si, pour une quelconque raison, l'objet <classname>Socket</classname> ne peut pas recevoir l'objet <classname>Plug</classname>, la fenêtre ressemblera à :

en: Timeouts, I/O and Idle Functions
fr: Fonctions à délai échu, d'entrées/sorties et de temporisation

en: Timeouts
fr: Fonctions à délai échu

en: You may be wondering how to make <application>gtkmm</application> do useful work while it's idling along (well, sleeping actually) in <methodname>Gtk::Main::run()</methodname>. Happily, you have several options. Using the following methods you can create a timeout method that will be called every few milliseconds.
fr: 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.

en: 
    sigc::connection Glib::SignalTimeout::connect(const sigc::slot&lt;bool&gt;&amp; slot, unsigned int interval, int priority = Glib::PRIORITY_DEFAULT);
fr: 
    sigc::connection Glib::SignalTimeout::connect(
                             const sigc::slot&lt;bool&gt;&amp; slot,
                             unsigned int interval,
                             int priority = Glib::PRIORITY_DEFAULT);

en: The first argument is a <classname>slot</classname> you wish to have called when the timeout occurs. The second argument is the number of milliseconds between calls to that method. You receive a <classname>sigc::connection</classname> object that can be used to deactivate the connection using its <methodname>disconnect()</methodname> method:
fr: 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> :

en: Another way of destroying the connection is your signal handler. It has to be of the type <classname>sigc::slot&lt;bool&gt;</classname>. As you see from the definition your signal handler has to return a value of the type <literal>bool</literal>. A definition of a sample method might look like this: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: You can stop the timeout method by returning <literal>false</literal> from your signal handler. Therefore, if you want your method to be called repeatedly, it should return <literal>true</literal>.
fr: 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>.

en: Here's an example of this technique:
fr: Voici un exemple de cette technique :

en: Monitoring I/O
fr: Fonctions de contrôle des entrées/sorties

en: A nifty feature of Glib (one of the libraries underlying <application>gtkmm</application>) is the ability to have it check for data on a file descriptor for you. This is especially useful for networking applications. The following method is used to do this:
fr: 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 :

en: 
    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);
fr: 
    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);

en: The first argument is a slot you wish to have called when then the specified event (see argument 3) occurs on the file descriptor you specify using argument two. Argument three may be one or more (using <literal>|</literal>) of:
fr: 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 :

en: Glib::IO_IN - Call your method when there is data ready for reading on your file descriptor.
fr: Glib::IO_IN - appelle la fonction membre quand il y a des données prêtes en lecture dans le descripteur de fichier.

en: Glib::IO_OUT - Call your method when the file descriptor is ready for writing.
fr: Glib::IO_OUT - appelle la fonction membre quand le descripteur de fichier est prêt pour l'écriture.

en: Glib::IO_PRI - Call your method when the file descriptor has urgent data to be read.
fr: Glib::IO_PRI - appelle la fonction membre quand le descripteur de fichier a des données à lire d'urgence.

en: Glib::IO_ERR - Call your method when an error has occurred on the file descriptor.
fr: Glib::IO_ERR - appelle la fonction membre quand une erreur est arrivée sur le descripteur de fichier.

en: Glib::IO_HUP - Call your method when hung up (the connection has been broken usually for pipes and sockets).
fr: 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).

en: The return value is a <classname>sigc::connection</classname> that may be used to stop monitoring this file descriptor using its <methodname>disconnect()</methodname> method. The <parameter>slot</parameter> signal handler should be declared as follows:
fr: 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 :

en: where <parameter>condition</parameter> is as specified above. As usual the slot is created with <function>sigc::mem_fun()</function> (for a member method of an object.), or <function>sigc::ptr_fun()</function> (for a function).
fr: 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).

en: A little example follows. To use the example just execute it from a terminal; it doesn't create a window. It will create a pipe named <literal>testfifo</literal> in the current directory. Then start another shell and execute <literal>echo "Hello" &gt; testfifo</literal>. The example will print each line you enter until you execute <literal>echo "Q" &gt; testfifo</literal>.
fr: 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>.

en: Idle Functions
fr: Fonctions de temporisation

en: If you want to specify a method that gets called when nothing else is happening, use the following:
fr: Si vous voulez définir une fonction membre appelée quand il n'y aucune autre activité en cours, utilisez :

en: 
    sigc::connection  Glib::SignalIdle::connect(const sigc::slot&lt;bool&gt;&amp; slot, int priority = Glib::PRIORITY_DEFAULT_IDLE);
fr: 
    sigc::connection  Glib::SignalIdle::connect(
                          const sigc::slot&lt;bool&gt;&amp; slot,
                          int priority = Glib::PRIORITY_DEFAULT_IDLE);

en: This causes <application>gtkmm</application> to call the specified method whenever nothing else is happening. You can add a priority (lower numbers are higher priorities). There are two ways to remove the signal handler: calling <methodname>disconnect()</methodname> on the <classname>sigc::connection</classname> object, or returning <literal>false</literal> in the signal handler, which should be declared as follows:
fr: 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 :

en: Since this is very similar to the methods above this explanation should be sufficient to understand what's going on. However, here's a little example:
fr: 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 :

en: This example points out the difference of idle and timeout methods a little. If you need methods that are called periodically, and speed is not very important, then you want timeout methods. If you want methods that are called as often as possible (like calculating a fractal in background), then use idle methods.
fr: 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.

en: Try executing the example and increasing the system load. The upper progress bar will increase steadily; the lower one will slow down.
fr: 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.

en: Memory management
fr: Gestion de la mémoire

en: Normal C++ memory management
fr: Gestion classique de la mémoire en C++

en: <application>gtkmm</application> allows the programmer to control the lifetime (that is, the construction and destruction) of any widget in the same manner as any other C++ object. This flexibility allows you to use <literal>new</literal> and <literal>delete</literal> to create and destroy objects dynamically or to use regular class members (that are destroyed automatically when the class is destroyed) or to use local instances (that are destroyed when the instance goes out of scope). This flexibility is not present in some C++ GUI toolkits, which restrict the programmer to only a subset of C++'s memory management features.
fr: <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++.

en: Here are some examples of normal C++ memory management:
fr: Voici quelques exemples de gestion traditionnelle de la mémoire en C++ :

en: Class Scope widgets
fr: Éléments graphiques à portée de classe

en: If a programmer does not need dynamic memory allocation, automatic widgets in class scope may be used. One advantage of automatic widgets in class scope is that memory management is grouped in one place. The programmer does not risk memory leaks from failing to <literal>delete</literal> a widget.
fr: 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.

en: The primary disadvantages of using class scope widgets are revealing the class implementation rather than the class interface in the class header. Class scope widgets also require Automatic widgets in class scope suffer the same disadvantages as any other class scope automatic variable.
fr: 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.

en: 
    #include &lt;gtkmm/button.h&gt;
    class Foo
    {
    private:
      Gtk::Button theButton;
      // will be destroyed when the Foo object is destroyed
    };
fr: 
    #include &lt;gtkmm/button.h&gt;
    class Foo
    {
    private:
      Gtk::Button theButton;
      // sera détruit en même temps que l'objet Foo
    };

en: Function scope widgets
fr: Éléments graphiques à portée de fonction

en: If a programmer does not need a class scope widget, a function scope widget may also be used. The advantages to function scope over class scope are the increased data hiding and reduced dependencies. <placeholder-1/>
fr: 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. <placeholder-1/>

en: Dynamic allocation with new and delete
fr: Allocation dynamique avec new et delete

en: Although, in most cases, the programmer will prefer to allow containers to automatically destroy their children using <function>manage()</function> (see below), the programmer is not required to use <function>manage()</function>. The traditional <literal>new</literal> and <literal>delete</literal> operators may also be used.
fr: 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.

en: 
    Gtk::Button* pButton = new Gtk::Button("Test");
    
    // do something useful with pButton
    
    delete pButton;
fr: 
    Gtk::Button* pButton = new Gtk::Button("Test");
    
    // faire quelque chose d'utile avec pButton
    
    delete pButton;

en: <placeholder-1/> Here, the programmer deletes pButton to prevent a memory leak.
fr: <placeholder-1/> Ici, le programmeur détruit pButton pour prévenir une fuite de mémoire.

en: Managed Widgets
fr: Éléments graphiques gérés

en: Alternatively, you can let a widget's container control when the widget is destroyed. In most cases, you want a widget to last only as long as the container it is in. To delegate the management of a widget's lifetime to its container, first create it with <function>manage()</function> and pack it into its container with <methodname>add()</methodname>. Now, the widget will be destroyed whenever its container is destroyed.
fr: 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.

en: Dynamic allocation with manage() and add()
fr: Allocation dynamique avec manage() et add()

en: <application>gtkmm</application> provides the <function>manage()</function> function and <methodname>add()</methodname> methods to create and destroy widgets. Every widget except a top-level window must be added or packed into a container in order to be displayed. The <function>manage()</function> function marks a packed widget so that when the widget is added to a container, the container becomes responsible for deleting the widget.
fr: <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.

en: 
    MyWidget::MyWidget()
    {
      Gtk::Button* pButton = manage(new Gtk::Button("Test"));
      add(*pButton); //add aButton to MyWidget
    }
fr: 
    MyWidget::MyWidget()
    {
      Gtk::Button* pButton = manage(new Gtk::Button("Test"));
      add(*pButton); //ajoute aButton à MyWidget
    }

en: <placeholder-1/> Now, when objects of type <classname>MyWidget</classname> are destroyed, the button will also be deleted. It is no longer necessary to delete pButton to free the button's memory; its deletion has been delegated to the <classname>MyWidget</classname> object.
fr: <placeholder-1/> 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>.

en: <application>gtkmm</application> also provides the <methodname>set_manage()</methodname> method for all widgets. This can be used to generate the same result as <function>manage()</function>, but is more tedious:
fr: <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 :

en: is the same as
fr: est équivalent à

en: Of course, a top level container will not be added to another container. The programmer is responsible for destroying the top level container using one of the traditional C++ techniques. For instance, your top-level Window might just be an instance in your <function>main()</function> function..
fr: 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>.

en: Shared resources
fr: Ressources partagées

en: Some objects, such as <classname>Gdk::Pixmap</classname>s and <classname>Pango::Font</classname>s, are obtained from a shared store. Therefore you cannot instantiate your own instances. These classes typically inherit from <classname>Glib::Object</classname>. Rather than requiring you to reference and unreference these objects, <application>gtkmm</application> uses the <classname>RefPtr&lt;&gt;</classname> smartpointer.
fr: 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>.

en: Objects such as <classname>Gdk::Bitmap</classname> can only be instantiated with a <methodname>create()</methodname> function. For instance, <placeholder-1/>
fr: Les objets du type <classname>Gdk::Bitmap</classname> ne peuvent être instanciés qu'avec la fonction <methodname>create()</methodname>. Par exemple, <placeholder-1/>

en: You have no way of getting a bare <classname>Gdk::Bitmap</classname>. In the example, <varname>bitmap</varname> is a smart pointer, so you can do this, much like a normal pointer: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: When <varname>bitmap</varname> goes out of scope an <methodname>unref()</methodname> will happen in the background and you don't need to worry about it anymore. There's no <literal>new</literal> so there's no <literal>delete</literal>.
fr: 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>.

en: If you copy a <classname>RefPtr</classname>, for instance <placeholder-1/> , or if you pass it as a method argument or a return type, then <classname>RefPtr</classname> will do any necessary referencing to ensure that the instance will not be destroyed until the last <classname>RefPtr</classname> has gone out of scope.
fr: Si vous copiez un <classname>RefPtr</classname>, par exemple <placeholder-1/> 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.

en: See the <link linkend="chapter-refptr">appendix</link> for detailed information about RefPtr.
fr: Consultez cette <link linkend="chapter-refptr">annexe</link> pour une information détaillée concernant les RefPtr.

en: Bjarne Stroustrup, "The C++ Programming Language" - section 14.4.2
fr: Bjarne Stroustrup, « The C++ Programming Language » - chapitre 14.4.2

en: Nicolai M. Josuttis, "The C++ Standard Library" - section 4.2
fr: Nicolai M. Josuttis, « The C++ Standard Library » - chapitre 4.2

en: If you wish to learn more about smartpointers, you might look in these books: <placeholder-1/>
fr: Si vous voulez en savoir plus à propos des pointeurs intelligents, vous pouvez consulter les ouvrages suivants : <placeholder-1/>

en: Glade and Gtk::Builder
fr: Glade et Gtk::Builder

en: Although you can use C++ code to instantiate and arrange widgets, this can soon become tedious and repetitive. And it requires a recompilation to show changes. The <application>Glade</application> application allows you to layout widgets on screen and then save an XML description of the arrangement. Your application can then use the <application>Gtk::Builder</application> API to load that XML file at runtime and obtain a pointer to specifically named widget instances.
fr: 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é.

en: Less C++ code is required.
fr: elle requiert moins de code C++,

en: UI changes can be seen more quickly, so UIs are able to improve.
fr: les modifications apportées à l'UI sont visibles plus rapidement, donc plus facilement améliorables,

en: Designers without programming skills can create and edit UIs.
fr: des concepteurs sans capacité particulière de programmation peuvent créer et modifier des UI.

en: This has the following advantages: <placeholder-1/>
fr: Cette fonction membre présente les avantages suivants : <placeholder-1/>

en: You still need C++ code to deal with User Interface changes triggered by user actions, but using <application>Gtk::Builder</application> for the widget layout allows you to focus on implementing that functionality.
fr: 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.

en: Loading the .glade file
fr: Chargement du fichier .glade

en: 
    Glib::RefPtr&lt;Gtk::Builder&gt; builder = Gtk::Builder::create_from_file("basic.glade");
fr: 
    Glib::RefPtr&lt;Gtk::Builder&gt; builder = 
                    Gtk::Builder::create_from_file("basic.glade");

en: <classname>Gtk::Builder</classname> must be used via a <classname>Glib::RefPtr</classname>. Like all such classes, you need to use a <methodname>create()</methodname> method to instantiate it. For instance, <placeholder-1/> This will instantiate the windows defined in the .glade file, though they will not be shown immediately unless you have specified that via the <guilabel>Properties</guilabel> window in <application>Glade</application>.
fr: <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, <placeholder-1/> 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>.

en: 
    Glib::RefPtr&lt;Gtk::Builder&gt; builder = Gtk::Builder::create_from_file("basic.glade", "treeview_products");
fr: 
    Glib::RefPtr&lt;Gtk::Builder&gt; builder = 
                    Gtk::Builder::create_from_file(
                                  "basic.glade",
                                  "treeview_products");

en: To instantiate just one window, or just one of the child widgets, you can specify the name of a widget as the second parameter. For instance, <placeholder-1/>
fr: 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, <placeholder-1/>

en: Accessing widgets
fr: Accès aux éléments graphiques

en: To access a widget, for instance to <methodname>show()</methodname> a dialog, use the <methodname>get_widget()</methodname> method, providing the widget's name. This name should be specified in the <application>Glade</application> Properties window. If the widget could not be found, or is of the wrong type, then the pointer will be set to 0. <placeholder-1/>
fr: 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. <placeholder-1/>

en: <application>Gtk::Builder</application> checks for a null pointer, and checks that the widget is of the expected type, and will show warnings on the command line about these.
fr: <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.

en: Remember that you are not instantiating a widget with <methodname>get_widget()</methodname>, you are just obtaining a pointer to one that already exists. You will always receive a pointer to the same instance when you call <methodname>get_widget()</methodname> on the same <classname>Gtk::Builder</classname>, with the same widget name. The widgets are instantiated during <methodname>Gtk::Builder::create_from_file()</methodname>.
fr: 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>.

en: <methodname>get_widget()</methodname> returns child widgets that are <function>manage()</function>ed (see the <link linkend="chapter-memory">Memory Management</link> chapter), so they will be deleted when their parent container is deleted. So, if you get only a child widget from <application>Gtk::Builder</application>, instead of a whole window, then you must either put it in a <classname>Container</classname> or delete it. <classname>Windows</classname> (such as <classname>Dialogs</classname>) cannot be managed because they have no parent container, so you must delete them at some point.
fr: <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é.

en: This simple example shows how to load a <application>Glade</application> file at runtime and access the widgets with <application>Gtk::Builder</application>.
fr: 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>.

en: Using derived widgets
fr: Utilisation d'éléments graphiques dérivés

en: You can use <application>Glade</application> to layout your own custom widgets derived from <application>gtkmm</application> widget classes. This keeps your code organized and encapsulated. Of course you won't see the exact appearance and properties of your derived widget in <application>Glade</application>, but you can specify its location and child widgets and the properties of its <application>gtkmm</application> base class.
fr: 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.

en: Use <methodname>Gtk::Builder::get_widget_derived()</methodname> like so: <placeholder-1/>
fr: Utilisez <methodname>Gtk::Builder::get_widget_derived()</methodname> ainsi : <placeholder-1/>

en: Your derived class must have a constructor that takes a pointer to the underlying C type, and the <classname>Gtk::Builder</classname> instance. All relevant classes of <application>gtkmm</application> typedef their underlying C type as <classname>BaseObjectType</classname> (<classname>Gtk::Dialog</classname> typedefs <classname>BaseObjectType</classname> as <type>GtkDialog</type>, for instance).
fr: 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>).

en: 
    DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr&lt;Gtk::Builder&gt;&amp; builder)
    : Gtk::Dialog(cobject)
    {
    }
fr: 
    DerivedDialog::DerivedDialog(BaseObjectType* cobject,
                                 const Glib::RefPtr&lt;Gtk::Builder&gt;&amp; builder)
    : Gtk::Dialog(cobject)
    {
    }

en: You must call the base class's constructor in the initialization list, providing the C pointer. For instance, <placeholder-1/>
fr: Vous devez faire appel au constructeur de la classe de base dans la liste d'initialisation, en fournissant le pointeur C. Par exemple, <placeholder-1/>

en: 
    DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr&lt;Gtk::Builder&gt;&amp; builder)
    : Gtk::Dialog(cobject),
      m_builder(builder),
      m_pButton(0)
    {
      //Get the Glade-instantiated Button, and connect a signal handler:
      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) );
      }
    }
fr: 
    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) );
      }
    }

en: You could then encapsulate the manipulation of the child widgets in the constructor of the derived class, maybe using <methodname>get_widget()</methodname> or <methodname>get_widget_derived()</methodname> again. For instance, <placeholder-1/>
fr: 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, <placeholder-1/>

en: This example shows how to load a <application>Glade</application> file at runtime and access the widgets via a derived class.
fr: 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.

en: Internationalization and Localization
fr: Internationalisation et adaptation locale

en: <application>gtkmm</application> applications can easily support multiple languages, including non-European languages such as Chinese and right-to-left languages such as Arabic. An appropriately-written and translated <application>gtkmm</application> application will use the appropriate language at runtime based on the user's environment.
fr: 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.

en: You might not anticipate the need to support additional languages, but you can never rule it out. And it's easier to develop the application properly in the first place rather than retrofitting later.
fr: 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.

en: The process of writing source code that allows for translation is called <literal>internationalization</literal>, often abbreviated to <literal>i18n</literal>. The <literal>Localization</literal> process, sometimes abbreviated as <literal>l10n</literal>, provides translated text for other languages, based on that source code.
fr: 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.

en: The main activity in the internationalization process is finding strings seen by users and marking them for translation. You do not need to do it all at once - if you set up the necessary project infrastructure correctly then your application will work normally regardless of how many strings you've covered.
fr: 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.

en: String literals should be typed in the source code in English, but surrounded by a macro. The <application>gettext</application> (or intltool) utility can then extract the marked strings for tramslation, and substitute the translated text at runtime.
fr: 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.

en: Preparing your project
fr: Préparation du projet

en: In the instructions below we will assume that you will not be using <application>gettext</application> directly, but <application>intltool</application>, which was written specifically for <literal>GNOME</literal>. <application>intltool</application> uses <function>gettext()</function>, which extracts strings from source code, but <application>intltool</application> can also combine strings from other files, for example from desktop menu details, and GUI resource files such as <application>Glade</application> files, into standard <application>gettext</application><filename>.pot/.po</filename> files.
fr: 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>.

en: We also assume that you are using autotools (e.g. <application>automake</application> and <application>autoconf</application>) to build your project, and that you are using <ulink url="http://svn.gnome.org/viewcvs/gnome-common/trunk/autogen.sh?view=markup"><literal>./autogen.sh</literal> from <application>gnome-common</application></ulink>, which, among other things, takes care of some <application>intltool</application> initialization.
fr: 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>.

en: Create a sub-directory named <literal>po</literal> in your project's root directory. This directory will eventually contain all of your translations. Within it, create a file named <literal>LINGUAS</literal> and a file named <literal>POTFILES.in</literal>. It is common practice to also create a <literal>ChangeLog</literal> file in the <literal>po</literal> directory so that translators can keep track of translation changes.
fr: 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.

en: <literal>LINGUAS</literal> contains an alphabetically sorted list of codes identifying the languages for which your program is translated (comment lines starting with a <literal>#</literal> are ignored). Each language code listed in the <literal>LINGUAS</literal> file must have a corresponding <literal>.po</literal> file. So, if your program has German and Japanese translations, your <literal>LINGUAS</literal> file would look like this:
fr: <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 à :

en: (In addition, you'd have the files <literal>ja.po</literal> and <literal>de.po</literal> in your <literal>po</literal> directory which contain the German and Japanese translations, respectively.)
fr: (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).

en: <literal>POTFILES.in</literal> is a list of paths to all files which contain strings marked up for translation, starting from the project root directory. So for example, if your project sources were located in a subdirectory named <literal>src</literal>, and you had two files that contained strings that should be translated, your <literal>POTFILES.in</literal> file might look like this:
fr: <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 :

en: If you are using <application>gettext</application> directly, you can only mark strings for translation if they are in source code file. However, if you use <application>intltool</application>, you can mark strings for translation in a variety of other file formats, including <application>Glade</application> UI files, xml, <ulink url="http://standards.freedesktop.org/desktop-entry-spec/latest/">.desktop files</ulink> and several more. So, if you have designed some of the application UI in <application>Glade</application> then also add your <filename>.glade</filename> files to the list in <literal>POTFILES.in</literal>.
fr: 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>.

en: Now that there is a place to put your translations, you need to initialize <application>intltool</application> and <application>gettext</application>. Add the following code to your <literal>configure.ac</literal>, substituting 'programname' with the name of your program:
fr: 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 » :

en: IT_PROG_INTLTOOL([0.35.0])
    
    GETTEXT_PACKAGE=programname
    AC_SUBST(GETTEXT_PACKAGE)
    AC_DEFINE_UNQUOTED([GETTEXT_PACKAGE], ["$GETTEXT_PACKAGE"],
                       [The domain to use with gettext])
    AM_GLIB_GNU_GETTEXT
    
    PROGRAMNAME_LOCALEDIR=[${datadir}/locale]
    AC_SUBST(PROGRAMNAME_LOCALEDIR)
fr: 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)

en: This <varname>PROGRAMNAME_LOCALEDIR</varname> variable will be used later in the <literal>Makefile.am</literal> file, to define a macro that will be used when you initialize <application>gettext</application> in your source code.
fr: 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.

en: Add <literal>po</literal> to the <literal>SUBDIRS</literal> variable. Without this, your translations won't get built and installed when you build the program
fr: 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.

en: Define <literal>INTLTOOL_FILES</literal> as: <placeholder-1/>
fr: définissez <literal>INTLTOOL_FILES</literal> égal à : <placeholder-1/>

en: Add <literal>INTLTOOL_FILES</literal> to the <literal>EXTRA_DIST</literal> list of files. This ensures that when you do a <command>make dist</command>, these commands will be included in the source tarball.
fr: 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>.

en: Update your <literal>DISTCLEANFILES</literal>: <placeholder-1/>
fr: mettez à jour vos <literal>DISTCLEANFILES</literal> : <placeholder-1/>

en: In the top-level Makefile.am: <placeholder-1/>
fr: Dans le fichier Makefile.am principal : <placeholder-1/>

en: In your <literal>src/Makefile.am</literal>, update your <literal>AM_CPPFLAGS</literal> to add the following preprocessor macro definition:
fr: 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 :

en: This macro will be used when you initialize <literal>gettext</literal> in your source code.
fr: Cette macro sert quand vous initialisez <literal>gettext</literal> dans votre code source.

en: Marking strings for translation
fr: Marquage des chaînes à traduire

en: String literals should be typed in the source code in English, but they should be surrounded by a call to the <function>gettext()</function> function. These strings will be extracted for translation and the translations may be used at runtime instead of the original English strings.
fr: 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.

en: The <application>GNU gettext</application> package allows you to mark strings in source code, extract those strings for translation, and use the translated strings in your application.
fr: 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.

en: However, <application>Glib</application> defines <function>gettext()</function> support macros which are shorter wrappers in an easy-to-use form. To use these macros, include <literal>&lt;glibmm/i18n.h&gt;</literal>, and then, for example, substitute: <placeholder-1/> with: <placeholder-2/>
fr: 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 : <placeholder-1/> par : <placeholder-2/>

en: For reference, it is possible to generate a file which contains all strings which appear in your code, even if they are not marked for translation, together with file name and line number references. To generate such a file named <literal>my-strings</literal>, execute the following command, within the source code directory: <placeholder-1/>
fr: À 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 : <placeholder-1/>

en: Finally, to let you program use the translation for the current locale, add this code to the beginning of your <filename>main.cc</filename> file, to initialize gettext. <placeholder-1/>
fr: 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 : <placeholder-1/>

en: How gettext works
fr: Comment fonctionne gettext

en: <application>intltool</application> / <application>xgettext</application> script extracts the strings and puts them in a <filename>mypackage.pot</filename> file. The translators of your application create their translations by first copying this <filename>.pot</filename> file to a <filename>localename.po</filename> file. A locale identifies a language and an encoding for that language, including date and numerical formats. Later, when the text in your source code has changed, the <literal>msmerge</literal> script is used to update the <filename>localename.po</filename> files from the regenerated <filename>.pot</filename> file.
fr: 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>.

en: At install time, the <filename>.po</filename> files are converted to a binary format (with the extension <filename>.mo</filename>) and placed in a system-wide directory for locale files, for example <filename>/usr/share/locale/</filename>.
fr: 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>.

en: When the application runs, the <application>gettext</application> library checks the system-wide directory to see if there is a <filename>.mo</filename> file for the user's locale environment (you can set the locale with, for instance, "export LANG=de_DE.UTF-8" from a bash console). Later, when the program reaches a <literal>gettext</literal> call, it looks for a translation of a particular string. If none is found, the original string is used.
fr: 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.

en: Testing and adding translations
fr: Vérification et ajout de traductions

en: To convince yourself that you've done well, you may wish to add a translation for a new locale. In order to do that, go to the <filename>po</filename> subdirectory of your project and execute the following command: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: That will create a file named <filename>programname.pot</filename>. Now copy that file to <filename>languagecode.po</filename>, such as <filename>de.po</filename> or <filename>hu.po</filename>. Also add that language code to <literal>LINGUAS</literal>. The <filename>.po</filename> file contains a header and a list of English strings, with space for the translated strings to be entered. Make sure you set the encoding of the <filename>.po</filename> file (specified in the header, but also as content) to <literal>UTF-8</literal>.
fr: 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).

en: It's possible that certain strings will be marked as <literal>fuzzy</literal> in the <filename>.po</filename> file. These translations will not substitute the original string. To make them appear, simply remove the <literal>fuzzy</literal> tag.
fr: 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>.

en: Resources
fr: Ressources

en: Internationalizing GNOME applications
fr: Internationalisation des applications GNOME

en: Intltool README
fr: Fichier README de Intltool

en: How to use GNOME CVS as a Translator
fr: Comment utiliser GNOME CVS pour traduire

en: gettext manual
fr: Manuel gettext

en: <placeholder-1/> example package
fr: Exemple de paquet logiciel <placeholder-1/>

en: More information about what lies behind the internationalization and localization process is presented and demonstrated in: <placeholder-1/>
fr: Des informations supplémentaires sur le processus d'internationalisation et de localisation sont présentées et commentées dans : <placeholder-1/>

en: Expecting UTF8
fr: En attendant UTF8

en: A properly internationalized application will not make assumptions about the number of bytes in a character. That means that you shouldn't use pointer arithmetic to step through the characters in a string, and it means you shouldn't use <classname>std::string</classname> or standard C functions such as <function>strlen()</function> because they make the same assumption.
fr: 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.

en: However, you probably already avoid bare char* arrays and pointer arithmetic by using <classname>std::string</classname>, so you just need to start using <classname>Glib::ustring</classname> instead. See the <link linkend="sec-basics-ustring">Basics</link> chapter about <classname>Glib::ustring</classname>.
fr: 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>.

en: Glib::ustring and std::iostreams
fr: Glib::ustring et std::iostreams

en: std::ostringstream output;
    output.imbue(std::locale("")); // use the user's locale for this stream
    output &lt;&lt; percentage &lt;&lt; " % done";
    label-&gt;set_text(Glib::locale_to_utf8(output.str()));
fr: 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()));

note: <para>TODO: This section is not clear - it needs to spell things out more clearly and obviously.</para>
en: Unfortunately, the integration with the standard iostreams is not completely foolproof. <application>gtkmm</application> converts <classname>Glib::ustring</classname>s to a locale-specific encoding (which usually is not UTF-8) if you output them to an <classname>ostream</classname> with <function>operator&lt;&lt;</function>. Likewise, retrieving <classname>Glib::ustrings</classname> from <classname>istream</classname> with <function>operator&gt;&gt;</function> causes a conversion in the opposite direction. But this scheme breaks down if you go through a <classname>std::string</classname>, e.g. by inputting text from a stream to a <classname>std::string</classname> and then implicitly converting it to a <classname>Glib::ustring</classname>. If the string contained non-ASCII characters and the current locale is not UTF-8 encoded, the result is a corrupted <classname>Glib::ustring</classname>. You can work around this with a manual conversion. For instance, to retrieve the <classname>std::string</classname> from a <classname>ostringstream</classname>: <placeholder-1/>
fr: 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> : <placeholder-1/>

en: Pitfalls
fr: Embûches

en: There are a few common mistakes that you would discover eventually yourself. But this section might help you to avoid them.
fr: 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.

en: Same strings, different semantics
fr: Mêmes chaînes, sémantiques différentes

en: Sometimes two english strings are identical but have different meanings in different contexts, so they would probably not be identical when translated. Since the English strings are used as look-up keys, this causes problems.
fr: 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.

en: In these cases, you should add extra characters to the strings. For instance, use <literal>"jumps[noun]"</literal> and <literal>"jumps[verb]"</literal> instead of just <literal>"jumps"</literal>) and strip them again outside the <function>gettext</function> call. If you add extra characters you should also add a comment for the translators before the <function>gettext</function> call. Such comments will be shown in the <filename>.po</filename> files. For instance:
fr: 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 :

en: Composition of strings
fr: Composition de chaînes

en: C programmers use <function>sprintf()</function> to compose and concatenate strings. C++ favours streams, but unfortunately, this approach makes translation difficult, because each fragment of text is translated separately, without allowing the translators to rearrange them according to the grammar of the language.
fr: 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.

en: For instance, this code would be problematic:
fr: Par exemple, ce code risque d'être sujet à problèmes :

en: So you should either avoid this situation or revert to the C-style <function>sprintf()</function>. One possible solution is the <ulink url="http://www.cs.auc.dk/~olau/compose/">compose library</ulink> which supports syntax such as:
fr: 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 :

en: Assuming the displayed size of strings
fr: Hypothèse concernant la taille d'affichage des chaînes

en: You never know how much space a string will take on screen when translated. It might very possibly be twice the size of the original English string. Luckily, most <application>gtkmm</application> widgets will expand at runtime to the required size.
fr: 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.

en: Unusual words
fr: Mots inhabituels

en: You should avoid cryptic abbreviations, slang, or jargon. They are usually difficult to translate, and are often difficult for even native speakers to understand. For instance, prefer "application" to "app"
fr: 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 ».

en: Using non-ASCII characters in strings
fr: Utilisation de caractères non-ASCII dans les chaînes

en: Currently, <application>gettext</application> does not support non-ASCII characters (i.e. any characters with a code above 127) in source code. For instance, you cannot use the copyright sign (©).
fr: 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 (©).

en: To work around this, you could write a comment in the source code just before the string, telling the translators to use the special character if it is available in their languages. For english, you could then make an American English <filename>en_US.po</filename> translation which used that special charactger.
fr: 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.

en: Getting help with translations
fr: Obtenir de l'aide avec les traductions

en: If your program is free software, there is a whole <literal>GNOME</literal> subproject devoted to helping you make translations, the <ulink url="http://developer.gnome.org/projects/gtp/"><literal>GNOME</literal> Translation Project</ulink>.
fr: 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).

en: The way it works is that you contact the gnome-i18n mailing list to find out how the translators can access your <filename>po/</filename> subdirectory, and to add your project to the big <ulink url="http://developer.gnome.org/projects/gtp/status/">status tables</ulink>.
fr: 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>.

en: Then you make sure you update the file <filename>POTFILES.in</filename> in the <filename>po/</filename> subdirectory (<command>intltool-update -M</command> can help with this) so that the translators always access updated <filename>myprogram.pot</filename> files, and simply freeze the strings at least a couple of days before you make a new release, announcing it on gnome-i18n. Depending on the number of strings your program contains and how popular it is, the translations will then start to tick in as <filename>languagename.po</filename> files.
fr: 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>.

en: Note that most language teams only consist of 1-3 persons, so if your program contains a lot of strings, it might last a while before anyone has the time to look at it. Also, most translators do not want to waste their time (translating is a very time-consuming task) so if they do not assess your project as being really serious (in the sense that it is polished and being maintained) they may decide to spend their time on some other project.
fr: 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.

en: Custom Widgets
fr: Éléments graphiques personnalisés

en: <application>gtkmm</application> makes it very easy to derive new widgets by inheriting from an existing widget class, either by deriving from a container and adding child widgets, or by deriving from a single-item widget, and changing its behaviour. But you might occasionally find that no suitable starting point already exists. In this case, you can implement a widget from scratch.
fr: <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.

en: Custom Containers
fr: Conteneurs personnalisés

en: <methodname>get_request_mode_vfunc()</methodname>: Return what <literal>Gtk::SizeRequestMode</literal> is preferred by the container.
fr: <methodname>get_request_mode_vfunc()</methodname> : renvoie quel est l'objet <literal>Gtk::SizeRequestMode</literal> préféré par le conteneur.

en: <methodname>get_preferred_width_vfunc()</methodname>: Calculate the minimum and natural width of the container.
fr: <methodname>get_preferred_width_vfunc()</methodname> : calcule la largeur minimale naturelle du conteneur.

en: <methodname>get_preferred_height_vfunc()</methodname>: Calculate the minimum and natural height of the container.
fr: <methodname>get_preferred_height_vfunc()</methodname> : calcule la hauteur minimale naturelle du conteneur.

en: <methodname>get_preferred_width_for_height_vfunc()</methodname>: Calculate the minimum and natural width of the container, if it would be given the specified height.
fr: <methodname>get_preferred_width_for_height_vfunc()</methodname> : calcule la largeur minimale naturelle du conteneur compte tenu de la hauteur précisée.

en: <methodname>get_preferred_height_for_width_vfunc()</methodname>: Calculate the minimum and natural height of the container, if it would be given the specified width.
fr: <methodname>get_preferred_height_for_width_vfunc()</methodname> : calcule la hauteur minimale naturelle du conteneur compte tenu de la largeur précisée.

en: <methodname>on_size_allocate()</methodname>: Position the child widgets, given the height and width that the container has actually been given.
fr: <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.

en: <methodname>forall_vfunc()</methodname>: Call the same callback for each of the children.
fr: <methodname>forall_vfunc()</methodname> : appelle la même fonction de rappel pour chaque enfant.

en: <methodname>on_add()</methodname>: Add a child widget to the container.
fr: <methodname>on_add()</methodname> : ajoute un élément graphique enfant dans le conteneur.

en: <methodname>on_remove()</methodname>: Remove a child widget from the container.
fr: <methodname>on_remove()</methodname> : supprime un élément graphique enfant du conteneur.

en: <methodname>child_type_vfunc()</methodname>: Return what type of child can be added.
fr: <methodname>child_type_vfunc()</methodname> : renvoie le type d'enfant pouvant être ajouté.

en: When deriving from <classname>Gtk::Container</classname>, you should override the following virtual methods: <placeholder-1/>
fr: Quand vous dérivez de la classe <classname>Gtk::Container</classname>, vous pouvez surdéfinir les fonctions membres virtuelles suivantes : <placeholder-1/>

en: The <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>, and <methodname>on_size_allocate()</methodname> virtual methods control the layout of the child widgets. For instance, if your container has 2 child widgets, with one below the other, your <methodname>get_request_mode_vfunc()</methodname> might request height-for-width layout. Then your <methodname>get_preferred_width_vfunc()</methodname> might report the maximum of the widths of the child widgets, and <methodname>get_preferred_height_for_width_vfunc()</methodname> might report the sum of their heights. If you want padding between the child widgets then you would add that to the width and height too. Your widget's container will use this result to ensure that your widget gets enough space, and not less. By examining each widget's parent, and its parent, this logic will eventually decide the size of the top-level window.
fr: 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.

en: You are not guaranteed to get the <literal>Gtk::SizeRequestMode</literal> that you request. Therefore all four of the <methodname>get_preferred_xxx_vfunc()</methodname> methods must return sensible values.
fr: 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.

en: <methodname>on_size_allocate()</methodname> receives the actual height and width that the parent container has decided to give to your widget. This might be more than the minimum, or even more than the natural size, for instance if the top-level window has been expanded. You might choose to ignore the extra space and leave a blank area, or you might choose to expand your child widgets to fill the space, or you might choose to expand the padding between your widgets. It's your container, so you decide. Don't forget to call <methodname>set_allocation()</methodname> inside your <methodname>on_size_allocate()</methodname> implementation to actually use the allocated space that has been offered by the parent container.
fr: <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.

en: Unless your container is a top-level window that derives from <classname>Gtk::Window</classname>, you should probably also call <methodname>Gtk::Widget::set_has_window(false)</methodname> in your constructor. This means that your container does not create its own <classname>Gdk::Window</classname>, but uses its parent's window. (Note the difference between <classname>Gtk::Window</classname> and <classname>Gdk::Window</classname>.) If your container does need its own <classname>Gdk::Window</classname>, and does not derive from <classname>Gtk::Window</classname>, you must also override the <methodname>on_realize()</methodname> method as described in the <link linkend="sec-custom-widgets">Custom Widgets</link> section. And unless your container draws directly onto the underlying <classname>Gdk::Window</classname>, you should probably call <methodname>set_redraw_on_allocate(false)</methodname> to improve performance.
fr: À 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.

en: By overriding <methodname>forall_vfunc()</methodname> you can allow applications to operate on all of the container's child widgets. For instance, <methodname>show_all_children()</methodname> uses this to find all the child widgets and show them.
fr: 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.

en: Although your container might have its own method to set the child widgets, you should still provide an implementation for the virtual <methodname>on_add()</methodname> and <methodname>on_remove()</methodname> methods from the base class, so that the add() and remove() methods will do something appropriate if they are called.
fr: 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.

en: Your implementation of the <methodname>child_type_vfunc()</methodname> method should report the type of widget that may be added to your container, if it is not yet full. This is usually <methodname>Gtk::Widget::get_type()</methodname> to indicate that the container may contain any class derived from <classname>Gtk::Widget</classname>. If the container may not contain any more widgets, then this method should return <literal>G_TYPE_NONE</literal>.
fr: 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>.

en: This example implements a container with two child widgets, one above the other. Of course, in this case it would be far simpler just to use a <classname>Gtk::VBox</classname>.
fr: 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>.

en: Custom Container
fr: Conteneur personnalisé

en: By deriving directly from <classname>Gtk::Widget</classname> you can do all the drawing for your widget directly, instead of just arranging child widgets. For instance, a <classname>Gtk::Label</classname> draws the text of the label, but does not do this by using other widgets.
fr: 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.

en: <methodname>get_request_mode_vfunc()</methodname>: (optional) Return what <literal>Gtk::SizeRequestMode</literal> is preferred by the widget.
fr: <methodname>get_request_mode_vfunc()</methodname> : (optionelle) renvoie quel est le <literal>Gtk::SizeRequestMode</literal> préféré par l'élément graphique.

en: <methodname>get_preferred_width_vfunc()</methodname>: Calculate the minimum and natural width of the widget.
fr: <methodname>get_preferred_width_vfunc()</methodname> : calcule la largeur minimale naturelle de l'élément graphique.

en: <methodname>get_preferred_height_vfunc()</methodname>: Calculate the minimum and natural height of the widget.
fr: <methodname>get_preferred_height_vfunc()</methodname> : calcule la hauteur minimale naturelle de l'élément graphique.

en: <methodname>get_preferred_width_for_height_vfunc()</methodname>: Calculate the minimum and natural width of the widget, if it would be given the specified height.
fr: <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.

en: <methodname>get_preferred_height_for_width_vfunc()</methodname>: Calculate the minimum and natural height of the widget, if it would be given the specified width.
fr: <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.

en: <methodname>on_size_allocate()</methodname>: Position the widget, given the height and width that it has actually been given.
fr: <methodname>on_size_allocate()</methodname> : place l'élément graphique, compte tenu de la hauteur et de la largeur réellement attribuées.

en: <methodname>on_realize()</methodname>: Associate a <classname>Gdk::Window</classname> with the widget.
fr: <methodname>on_realize()</methodname> : associe un objet <classname>Gdk::Window</classname> à l'élément graphique.

en: <methodname>on_unrealize()</methodname>: (optional) Break the association with the <classname>Gdk::Window</classname>.
fr: <methodname>on_unrealize()</methodname> : (optionnelle) détruit l'association avec l'objet <classname>Gdk::Window</classname>.

en: <methodname>on_map()</methodname>: (optional)
fr: <methodname>on_map()</methodname>: (optionnelle)

en: <methodname>on_unmap()</methodname>: (optional)
fr: <methodname>on_unmap()</methodname>: (optionnelle)

en: <methodname>on_draw()</methodname>: Draw on the supplied <classname>Cairo::Context</classname>.
fr: <methodname>on_draw()</methodname> : trace sur l'objet <classname>Cairo::Context</classname> fourni.

en: When deriving from <classname>Gtk::Widget</classname>, you should override the following virtual methods. The methods marked (optional) need not be overridden in all custom widgets. The base class's methods may be appropriate. <placeholder-1/>
fr: 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. <placeholder-1/>

en: The first 6 methods in the previous table are also overridden in custom containers. They are briefly described in the <link linkend="sec-custom-containers">Custom Containers</link> section.
fr: 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>.

en: Most custom widgets need their own <classname>Gdk::Window</classname> to draw on. Then you can call <methodname>Gtk::Widget::set_has_window(true)</methodname> in your constructor. (This is the default value.) If you do not call <methodname>set_has_window(false)</methodname>, you must override <methodname>on_realize()</methodname> and call <methodname>Gtk::Widget::set_realized()</methodname> and <methodname>Gtk::Widget::set_window()</methodname> from there.
fr: 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>.

en: This example implements a widget which draws a Penrose triangle.
fr: Cet exemple implémente un élément graphique qui trace un triangle de Penrose.

en: Custom Widget
fr: Élément graphique personnalisé

en: Recommended Techniques
fr: Techniques recommandées

en: This section is simply a gathering of wisdom, general style guidelines and hints for creating <application>gtkmm</application> applications.
fr: 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>.

en: Use GNU <application>autoconf</application> and <application>automake</application>! They are your friends :) <application>Automake</application> examines C files, determines how they depend on each other, and generates a <filename>Makefile</filename> so the files can be compiled in the correct order. <application>Autoconf</application> permits automatic configuration of software installation, handling a large number of system quirks to increase portability..
fr: 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é.

en: Subclass Widgets to better organize your code. You should probably subclass your main <classname>Window</classname> at least. Then you can make your child Widgets and signal handlers members of that class.
fr: 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.

en: Create your own signals instead of passing pointers around. Objects can communicate with each other via signals and signal handlers. This is much simpler than objects holding pointers to each other and calling each other's methods. <application>gtkmm</application>'s classes uses special versions of <classname>sigc::signal</classname>, but you should use normal <classname>sigc::signal</classname>s, as described in the <application>libsigc++</application> documentation.
fr: 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>.

en: Application Lifetime
fr: Durée de vie d'une application

en: Most applications will have only one <classname>Window</classname>, or only one main window. These applications can use the <methodname>Gtk::Main::run(Gtk::Window&amp;)</methodname> overload. It shows the window and returns when the window has been hidden. This might happen when the user closes the window, or when your code decides to <methodname>hide()</methodname> the window. You can prevent the user from closing the window (for instance, if there are unsaved changes) by overriding <methodname>Gtk::Window::on_delete_event()</methodname>.
fr: 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>.

en: Most of our examples use this technique.
fr: La plupart de nos exemples utilisent cette technique.

en: Using a <application>gtkmm</application> widget
fr: Utilisation d'un élément graphique <application>gtkmm</application>

en: Our examples all tend to have the same structure. They follow these steps for using a <classname>Widget</classname>:
fr: Nos exemples adoptent tous la même structure. Ils suivent ces étapes pour l'utilisation d'un <classname>Élément graphique</classname> :

en: Declare a variable of the type of <classname>Widget</classname> you wish to use, generally as member variable of a derived container class. You could also declare a pointer to the widget type, and then create it with <literal>new</literal> in your code. Even when using the widget via a pointer, it's still probably best to make that pointer a member variable of a container class so that you can access it later.
fr: 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.

en: Set the attributes of the widget. If the widget has no default constructor, then you will need to initialize the widget in the initalizer list of your container class's constructor.
fr: 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.

en: Connect any signals you wish to use to the appropriate handlers.
fr: Connectez tout signal que vous souhaitez utiliser aux gestionnaires appropriés.

en: Pack the widget into a container using the appropriate call, e.g. <methodname>Gtk::Container::add()</methodname> or <methodname>pack_start()</methodname>.
fr: Empaquetez l'élément graphique dans un conteneur par un appel approprié, par exemple <methodname>Gtk::Container::add()</methodname> ou <methodname>pack_start()</methodname>.

en: Call <methodname>show()</methodname> to display the widget.
fr: Appelez <methodname>show()</methodname> pour afficher l'élément graphique.

en: <methodname>Gtk::Widget::show()</methodname> lets <application>gtkmm</application> know that we have finished setting the attributes of the widget, and that it is ready to be displayed. You can use <methodname>Gtk::Widget::hide()</methodname> to make it disappear again. The order in which you show the widgets is not important, but we do suggest that you show the top-level window last; this way, the whole window will appear with its contents already drawn. Otherwise, the user will first see a blank window, into which the widgets will be gradually drawn.
fr: <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.

en: Contributing
fr: Comment contribuer

en: This document, like so much other great software out there, was created for free by volunteers. If you are at all knowledgeable about any aspect of <application>gtkmm</application> that does not already have documentation, please consider contributing to this document.
fr: 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.

en: Ideally, we would like you to <ulink url="http://www.gtkmm.org/bugs.shtml">provide a patch</ulink> to the <filename>docs/tutorial/C/gtkmm-tutorial-in.xml</filename> file. This file is currently in the <literal>gtkmm-documentation</literal> module in GNOME git.
fr: 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.

en: If you do decide to contribute, please post your contribution to the <application>gtkmm</application> mailing list at <ulink url="mailto:gtkmm-list@gnome.org">&lt;gtkmm-list@gnome.org&gt;</ulink>. Also, be aware that the entirety of this document is free, and any addition you provide must also be free. That is, people must be able to use any portion of your examples in their programs, and copies of this document (including your contribution) may be distributed freely.
fr: 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.

en: The RefPtr smartpointer
fr: Le pointeur intelligent RefPtr

en: <classname>Glib::RefPtr</classname> is a smartpointer. Specifically, it is a reference-counting smartpointer. You might be familiar with <literal>std::auto_ptr&lt;&gt;</literal>, which is also a smartpointer, but <literal>Glib::RefPtr&lt;&gt;</literal> is much simpler, and more useful. We expect a future version of the C++ Standard Library to contain a reference-counting shared smartpointer, and a future version of <application>gtkmm</application> might possibly use that instead.
fr: <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.

en: A smartpointer acts much like a normal pointer. Here are a few examples.
fr: Un pointeur intelligent se comporte plus ou moins comme un pointeur normal. Voici quelques exemples.

en: Copying
fr: Copie

en: You can copy <classname>RefPtr</classname>s, just like normal pointers. But unlike normal pointers, you don't need to worry about deleting the underlying instance.
fr: 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.

en: Of course this means that you can store <classname>RefPtrs</classname> in standard containers, such as <classname>std::vector</classname> or <classname>std::list</classname>.
fr: 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>.

en: Dereferencing
fr: Déréférencement

en: You can dereference a smartpointer with the -&gt; operator, to call the methods of the underlying instance, just like a normal pointer.
fr: 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.

en: But unlike most smartpointers, you can't use the * operator to access the underlying instance.
fr: Mais contrairement à la plupart des pointeurs, vous ne pouvez pas utiliser l'opérateur <literal>*</literal> pour avoir accès à l'instance sous-jacente.

en: 
    Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap = Gdk::Bitmap::create(window,
    data, width, height);
    Gdk::Bitmap* underlying = *refBitmap; //Syntax error - will not compile.
fr: 
    Glib::RefPtr&lt;Gdk::Bitmap&gt; refBitmap = Gdk::Bitmap::create(window,
    data, width, height);
    Gdk::Bitmap* underlying = *refBitmap; // Erreur de syntaxe - ne compilera pas.

en: Casting
fr: Forçage de type

en: You can cast <classname>RefPtrs</classname> to base types, just like normal pointers.
fr: Vous pouvez forcer les <classname>RefPtrs</classname> à des types de base, comme des pointeurs normaux.

en: This means that any method which takes a <type>const Glib::RefPtr&lt;BaseType&gt;</type> argument can also take a <type>const Glib::RefPtr&lt;DerivedType&gt;</type>. The cast is implicit, just as it would be for a normal pointer.
fr: 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.

en: You can also cast to a derived type, but the syntax is a little different than with a normal pointer.
fr: 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.

en: Checking for null
fr: Vérification du pointeur NULL

en: Just like normal pointers, you can check whether a <classname>RefPtr</classname> points to anything.
fr: Comme pour les pointeurs normaux, vous pouvez vérifier si un pointeur <classname>RefPtr</classname> ne pointe sur rien.

en: But unlike normal pointers, <classname>RefPtr</classname>s are automatically initialized to null so you don't need to remember to do that yourself.
fr: Mais contrairement aux pointeurs normaux, les <classname>RefPtr</classname> sont automatiquement initialisés à NULL ; vous n'avez pas à faire cela vous-même.

en: Constness
fr: Constance

en: The use of the <literal>const</literal> keyword in C++ is not always clear. You might not realise that <type>const Something*</type> declares a pointer to a <type>const Something</type>, The pointer can be changed, but not the <type>Something</type> that it points to.
fr: 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.

en: Therefore, the <classname>RefPtr</classname> equivalent of <type>Something*</type> for a method parameter is <type>const Glib::RefPtr&lt;Something&gt;&amp;</type>, and the equivalent of <type>const Something*</type> is <type>const Glib::RefPtr&lt;const Something&gt;&amp;</type>.
fr: 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>.

en: The <literal>const ... &amp;</literal> around both is just for efficiency, like using <classname>const std::string&amp;</classname> instead of <classname>std::string</classname> for a method parameter to avoid unnecessary copying.
fr: 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.

en: Connecting signal handlers
fr: Connexion aux gestionnaires de signal

en: <application>gtkmm</application> widget classes have signal accessor methods, such as <methodname>Gtk::Button::signal_clicked()</methodname>, which allow you to connect your signal handler. Thanks to the flexibility of <application>libsigc++</application>, the callback library used by <application>gtkmm</application>, the signal handler can be almost any kind of function, but you will probably want to use a class method. Among <application>GTK+</application> C coders, these signal handlers are often named callbacks.
fr: 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).

en: Here's an example of a signal handler being connected to a signal:
fr: Voici un exemple de gestionnaire de signal connecté à un signal :

en: There's rather a lot to think about in this (non-functional) code. First let's identify the parties involved:
fr: Il y a un certain nombre de choses à considérer à propos de ce code (non fonctionnel). D'abord identifions les parties concernées :

en: The signal handler is <methodname>on_button_clicked()</methodname>.
fr: Le gestionnaire de signal est <methodname>on_button_clicked()</methodname>.

en: We're hooking it up to the <classname>Gtk::Button</classname> object called <varname>button</varname>.
fr: Nous le raccrochons à l'objet <classname>Gtk::Button</classname> nommé <varname>button</varname>.

en: When the Button emits its <literal>clicked</literal> signal, <methodname>on_button_clicked()</methodname> will be called.
fr: Quand le bouton émet le signal <literal>clicked</literal>, <methodname>on_button_clicked()</methodname> est appelé.

en: Now let's look at the connection again:
fr: Maintenant ré-examinons la connexion :

en: Note that we don't pass a pointer to <methodname>on_button_clicked()</methodname> directly to the signal's <methodname>connect()</methodname> method. Instead, we call <function>sigc::ptr_fun()</function>, and pass the result to <methodname>connect()</methodname>.
fr: 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>.

en: <function>sigc::ptr_fun()</function> generates a <classname>sigc::slot</classname>. A slot is an object which looks and feels like a function, but is actually an object. These are also known as function objects, or functors. <function>sigc::ptr_fun()</function> generates a slot for a standalone function or static method. <function>sigc::mem_fun()</function> generates a slot for a member method of a particular instance.
fr: <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.

en: Here's a slightly larger example of slots in action:
fr: Voici un exemple un peu plus développé de connecteurs en action :

en: 
    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) );
    }
fr: 
    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) );
    }

en: The first call to <methodname>connect()</methodname> is just like the one we saw last time; nothing new here.
fr: Le premier appel à <methodname>connect()</methodname> est identique à celui que nous avons vu la fois précédente ; rien de plus à dire.

en: The next is more interesting. <function>sigc::mem_fun()</function> is called with two arguments. The first argument is <parameter>some_object</parameter>, which is the object that our new slot will be pointing at. The second argument is a pointer to one of its methods. This particular version of <function>sigc::mem_fun()</function> creates a slot which will, when "called", call the pointed-to method of the specified object, in this case <methodname>some_object.on_button_clicked()</methodname>.
fr: 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>.

en: Another thing to note about this example is that we made the call to <methodname>connect()</methodname> twice for the same signal object. This is perfectly fine - when the button is clicked, both signal handlers will be called.
fr: 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.

en: We just told you that the button's <literal>clicked</literal> signal is expecting to call a method with no arguments. All signals have requirements like this - you can't hook a function with two arguments to a signal expecting none (unless you use an adapter, such as <function>sigc::bind()</function>, of course). Therefore, it's important to know what type of signal handler you'll be expected to connect to a given signal.
fr: 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é.

en: Writing signal handlers
fr: Écriture de gestionnaires de signal

en: To find out what type of signal handler you can connect to a signal, you can look it up in the reference documentation or the header file. Here's an example of a signal declaration you might see in the <application>gtkmm</application> headers:
fr: 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> :

en: Other than the signal's name (<literal>focus</literal>), two things are important to note here: the number following the word <classname>SignalProxy</classname> at the beginning (1, in this case), and the types in the list (<type>bool</type> and <type>Gtk::DirectionType</type>). The number indicates how many arguments the signal handler should have; the first type, <type>bool</type>, is the type that the signal handler should return; and the next type, <type>Gtk::DirectionType</type>, is the type of this signal's first, and only, argument. By looking at the reference documentation, you can see the names of the arguments too.
fr: 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.

en: The same principles apply for signals which have more arguments. Here's one with three (taken from <filename>&lt;gtkmm/editable.h&gt;</filename>):
fr: 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>) :

en: It follows the same form. The number 3 at the end of the type's name indicates that our signal handler will need three arguments. The first type in the type list is <type>void</type>, so that should be our signal handler's return type. The following three types are the argument types, in order. Our signal handler's prototype could look like this:
fr: 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 :

en: Disconnecting signal handlers
fr: Déconnexion des gestionnaires de signal

en: Let's take another look at a Signal's <literal>connect</literal> method:
fr: Examinons à nouveau la fonction membre <literal>connect</literal> d'un signal :

en: Notice that the return value is of type <classname>sigc::signal&lt;void,int&gt;::iterator</classname>. This can be implicitely converted into a <classname>sigc::connection</classname> which in turn can be used to control the connection. By keeping a connection object you can disconnect its associated signal handler using the method <methodname>sigc::connection::disconnect()</methodname>.
fr: 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>.

en: Overriding default signal handlers
fr: Surdéfinition du gestionnaire de signal par défaut

en: So far we've told you to perform actions in response to button-presses and the like by handling signals. That's certainly a good way to do things, but it's not the only way.
fr: 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.

en: Instead of laboriously connecting signal handlers to signals, you can simply make a new class which inherits from a widget - say, a Button - and then override the default signal handler, such as Button::on_clicked(). This can be a lot simpler than hooking up signal handlers for everything.
fr: 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.

en: Subclassing isn't always the best way to accomplish things. It is only useful when you want the widget to handle its own signal by itself. If you want some other class to handle the signal then you'll need to connect a separate handler. This is even more true if you want several objects to handle the same signal, or if you want one signal handler to respond to the same signal from different objects.
fr: 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.

en: <application>gtkmm</application> classes are designed with overriding in mind; they contain virtual member methods specifically intended to be overridden.
fr: 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.

en: Let's look at an example of overriding:
fr: Regardons un exemple de surdéfinition :

en: 
    #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;
    
        // call the base class's version of the method:
        Gtk::Button::on_clicked();
    }
fr: 
    #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();
    }

en: Here we define a new class called <classname>OverriddenButton</classname>, which inherits from <classname>Gtk::Button</classname>. The only thing we change is the <methodname>on_clicked()</methodname> method, which is called whenever <classname>Gtk::Button</classname> emits the <literal>clicked</literal> signal. This method prints "Hello World" to <literal>stdout</literal>, and then calls the original, overridden method, to let <classname>Gtk::Button</classname> do what it would have done had we not overridden.
fr: 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.

en: You don't always need to call the parent's method; there are times when you might not want to. Note that we called the parent method <emphasis>after</emphasis> writing "Hello World", but we could have called it before. In this simple example, it hardly matters much, but there are times when it will. With signals, it's not quite so easy to change details like this, and you can do something here which you can't do at all with connected signal handlers: you can call the parent method in the <emphasis>middle</emphasis> of your custom code.
fr: 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é.

en: Binding extra arguments
fr: Liaison avec des paramètres supplémentaires

en: 
    m_button1.signal_clicked().connect( sigc::bind&lt;Glib::ustring&gt;( sigc::mem_fun(*this, &amp;HelloWorld::on_button_clicked), "button 1") );
fr: 
    m_button1.signal_clicked().connect( 
                sigc::bind&lt;Glib::ustring&gt;( 
                                     sigc::mem_fun(
                                                   *this, 
                                                   &amp;HelloWorld::on_button_clicked
                                                  ),
                                     "bouton 1")
                                      );

en: If you use one signal handler to catch the same signal from several widgets, you might like that signal handler to receive some extra information. For instance, you might want to know which button was clicked. You can do this with <function>sigc::bind()</function>. Here's some code from the <link linkend="sec-helloworld2">helloworld2</link> example, which you will encounter later. <placeholder-1/> This says that we want the signal to send an extra <classname>Glib::ustring</classname> argument to the signal handler, and that the value of that argument should be "button 1". Of course we will need to add that extra argument to the declaration of our signal handler: <placeholder-2/> Of course, a normal "clicked" signal handler would have no arguments.
fr: 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. <placeholder-1/> 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 : <placeholder-2/> Bien évidemment encore, un gestionnaire normal de signal « clicked » ne comporterait pas de paramètre.

en: <function>sigc::bind()</function> is not commonly used, but you might find it helpful sometimes. If you are familiar with <application>GTK+</application> programming then you have probably noticed that this is similar to the extra <literal>gpointer data</literal> arguments which all GTK+ callbacks have. This is generally overused in <application>GTK+</application> to pass information that should be stored as member data in a derived widget, but widget derivation is very difficult in C. We have far less need of this hack in <application>gtkmm</application>.
fr: <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>.

en: X Event signals
fr: Signaux des événements X

en: The <classname>Widget</classname> class has some special signals which correspond to the underlying X-Windows events. These are suffixed by <literal>_event</literal>; for instance, <methodname>Widget::signal_button_pressed_event()</methodname>.
fr: 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>.

en: You might occasionally find it useful to handle X events when there's something you can't accomplish with normal signals. <classname>Gtk::Button</classname>, for example, does not send mouse-pointer coordinates with its <literal>clicked</literal> signal, but you could handle <literal>button_pressed_event</literal> if you needed this information. X events are also often used to handle key-presses.
fr: 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.

en: These signals behave slightly differently. The value returned from the signal handler indicates whether it has fully "handled" the event. If the value is <literal>false</literal> then <application>gtkmm</application> will pass the event on to the next signal handler. If the value is <literal>true</literal> then no other signal handlers will need to be called.
fr: 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é.

en: Handling an X event doesn't affect the Widget's other signals. If you handle <literal>button_pressed_event</literal> for <classname>Gtk::Button</classname>, you'll still be able to get the <literal>clicked</literal> signal. They are emitted at (nearly) the same time.
fr: 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.

en: Note also that not all widgets receive all X events by default. To receive additional X events, you can use <methodname>Gtk::Widget::set_events()</methodname> before showing the widget, or <methodname>Gtk::Widget::add_events()</methodname> after showing the widget. However, some widgets must first be placed inside an <classname>EventBox</classname> widget. See the <link linkend="chapter-widgets-without-xwindows">Widgets Without X-Windows</link> chapter.
fr: 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>.

en: 
    bool on_button_press(GdkEventButton* event);
    Gtk::Button button("label");
    button.signal_button_press_event().connect( sigc::ptr_fun(&amp;on_button_press) );
fr: 
    bool on_button_press(GdkEventButton* event);
    Gtk::Button button("label");
    button.signal_button_press_event().connect(
                      sigc::ptr_fun(&amp;on_button_press) 
                                              );

en: Here's a simple example: <placeholder-1/>
fr: Voici un exemple simple : <placeholder-1/>

en: When the mouse is over the button and a mouse button is pressed, <methodname>on_button_press()</methodname> will be called.
fr: Quand la souris est au dessus du bouton et qu'un bouton de souris est pressé, <methodname>on_button_press()</methodname> est appelé.

en: <type>GdkEventButton</type> is a structure containing the event's parameters, such as the coordinates of the mouse pointer at the time the button was pressed. There are several different types of <type>GdkEvent</type> structures for the various events.
fr: <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.

en: Signal Handler sequence
fr: Séquencement des gestionnaires de signaux

en: 
    button.signal_button_press_event().connect( sigc::ptr_fun(&amp;on_mywindow_button_press), false );
fr: 
    button.signal_button_press_event().connect( 
                    sigc::ptr_fun(&amp;on_mywindow_button_press), 
                    false );

en: By default, your signal handlers are called after any previously-connected signal handlers. However, this can be a problem with the X Event signals. For instance, the existing signal handlers, or the default signal handler, might return true to stop other signal handlers from being called. To specify that your signal handler should be called before the other signal handlers, so that will always be called, you can specify <literal>false</literal> for the optional <literal>after</literal> parameter. For instance, <placeholder-1/>
fr: 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, <placeholder-1/>

en: Creating your own signals
fr: Création de vos propres signaux

en: Now that you've seen signals and signal handlers in <application>gtkmm</application>, you might like to use the same technique to allow interaction between your own classes. That's actually very simple by using the <application>libsigc++</application> library directly.
fr: 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>.

en: This isn't purely a <application>gtkmm</application> or GUI issue. <application>gtkmm</application> uses <application>libsigc++</application> to implement its proxy wrappers for the <application>GTK+</application> signal system, but for new, non-GTK+ signals, you can create pure C++ signals, using the <classname>sigc::signal&lt;&gt;</classname> template.
fr: 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>.

en: For instance, to create a signal that sends 2 parameters, a <type>bool</type> and an <type>int</type>, just declare a <classname>sigc::signal</classname>, like so: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: 
    class Server
    {
    public:
      //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;
    };
    
    Server::type_signal_something Server::signal_something()
    {
      return m_signal_something;
    }
fr: 
    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;
    }

en: You could just declare that signal as a public member variable, but some people find that distasteful and prefer to make it available via an accessor method, like so: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: You can then connect to the signal using the same syntax used when connecting to <application>gtkmm</application> signals. For instance, <placeholder-1/>
fr: 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, <placeholder-1/>

en: This is a full working example that defines and uses custom signal.
fr: Voici un exemple pleinement fonctionnel définissant et utilisant un signal personnalisé.

en: Comparison with other signalling systems
fr: Comparaison avec les autres systèmes de signalisation

en: (An aside: <application>GTK+</application> calls this scheme "signalling"; the sharp-eyed reader with GUI toolkit experience will note that this same design is often seen under the name of "broadcaster-listener" (e.g., in Metrowerks' PowerPlant framework for the Macintosh). It works in much the same way: one sets up <literal>broadcasters</literal>, and then connects <literal>listeners</literal> to them; the broadcaster keeps a list of the objects listening to it, and when someone gives the broadcaster a message, it calls all of its objects in its list with the message. In <application>gtkmm</application>, signal objects play the role of broadcasters, and slots play the role of listeners - sort of. More on this later.)
fr: (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.)

en: <application>gtkmm</application> signal handlers are strongly-typed, whereas <application>GTK+</application> C code allows you to connect a callback with the wrong number and type of arguments, leading to a segfault at runtime. And, unlike <application>Qt</application>, <application>gtkmm</application> achieves this without modifying the C++ language.
fr: 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++.

en: Re. Overriding signal handlers: You can do this in the straight-C world of GTK+ too; that's what GTK's object system is for. But in GTK+, you have to go through some complicated procedures to get object-oriented features like inheritance and overloading. In C++, it's simple, since those features are supported in the language itself; you can let the compiler do the dirty work.
fr: 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 ».

en: This is one of the places where the beauty of C++ really comes out. One wouldn't think of subclassing a GTK+ widget simply to override its action method; it's just too much trouble. In GTK+, you almost always use signals to get things done, unless you're writing a new widget. But because overriding methods is so easy in C++, it's entirely practical - and sensible - to subclass a button for that purpose.
fr: 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.

en: <application>gtkmm</application> and Win32
fr: <application>gtkmm</application> et Win32

en: One of the major advantages of <application>gtkmm</application> is that it is crossplatform. <application>gtkmm</application> programs written on other platforms such as GNU/Linux can generally be transferred to Windows (and vice versa) with few modifications to the source.
fr: 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.

en: <application>gtkmm</application> currently works with the <ulink url="http://mingw.org/">MingW/GCC3.4 compiler</ulink> and Microsoft Visual C++ 2005 or later (including the freely available express editions) on the Windows platform. There is an <ulink url="ftp://ftp.gnome.org/pub/GNOME/binaries/win32/gtkmm"> installer</ulink> available for gtkmm on Microsoft Windows. Refer to <ulink url="http://live.gnome.org/gtkmm/MSWindows/"> http://live.gnome.org/gtkmm/MSWindows</ulink> for instructions how to use it.
fr: <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.

en: Building <application>gtkmm</application> on Win32
fr: Construction de <application>gtkmm</application> sur Win32

en: Please see <ulink url="http://live.gnome.org/gtkmm/MSWindows/BuildingGtkmm">http://live.gnome.org/gtkmm/MSWindows/BuildingGtkmm</ulink> for instructions on how to build gtkmm on Windws.
fr: 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.

en: Working with gtkmm's Source Code
fr: Travail avec le code source de gtkmm

en: If you are interested in helping out with the development of <application>gtkmm</application>, or fixing a bug in <application>gtkmm</application>, you'll probably need to build the development version of <application>gtkmm</application>. However, you should not to install a development version over your stable version. Instead, you should install it alongside your existing <application>gtkmm</application> installation, in a separate path.
fr: 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é.

en: The easiest way to do this is using <ulink url="http://library.gnome.org/devel/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://library.gnome.org/devel/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>.
fr: <ulink url="http://library.gnome.org/devel/jhbuild/unstable/">jhbuild</ulink> facilite cette opération. <application>jhbuild</application> est un programme qui rend la construction des logiciels GNOME plus aisée en calculant les dépendances et en les construisant dans un ordre correct. Ce paragraphe vous donnera quelques explications sur la manière de paramétrer <application>jhbuild</application> pour construire et installer <application>gtkmm</application> à partir du dépôt des sources (git). Pour actualiser l'information concernant <application>jhbuild</application>, veuillez vous reporter au <ulink url="http://library.gnome.org/devel/jhbuild/unstable/">manuel de jhbuild</ulink>. Si vous avez besoin d'aide pour utiliser <application>jhbuild</application>, adressez-vous à la <ulink url="http://mail.gnome.org/mailman/listinfo/gnome-love">liste de diffusion gnome-love</ulink>.

en: Note that to build <application>gtkmm</application> from git, you'll often need to build all of its dependencies from git as well. <application>jhbuild</application> makes this easier than it would normally be, but it will take quite a while to build and install them all. You will probably encounter build problems, though these will usually be corrected quickly if you report them.
fr: 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.

en: Setting up jhbuild
fr: Paramétrage de jhbuild

en: To set up <application>jhbuild</application>, follow the basic installation instructions from the <ulink url="http://library.gnome.org/devel/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>
fr: Pour paramétrer <application>jhbuild</application>, suivez les instructions d'installation de base du <ulink url="http://library.gnome.org/devel/jhbuild/unstable/">manuel de jhbuild</ulink>. Après avoir installé <application>jhbuild</application>, recopiez le fichier d'exemple de configuration de <application>jhbuild</application> dans votre répertoire personnel en lançant la commande suivante à partir du répertoire de <application>jhbuild</application> : <command>$ cp sample.jhbuildrc ~/.jhbuildrc</command>

en: The <application>gtkmm</application> module is defined in the GNOME moduleset (i.e. <filename>gnome-2.xx.modules</filename>, so edit your <filename>.jhbuildrc</filename> file and set your moduleset setting to the latest version of GNOME like so: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: After setting the correct moduleset, you need to tell <application>jhbuild</application> which module or modules to build. To build <application>gtkmm</application> and all of its dependencies, set <varname>modules</varname> like so: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: You can build all GNOME C++ modules by setting the <varname>modules</varname> variable to the meta-package named <literal>meta-gnome-c++</literal> or build all of the core GNOME modules with <literal>meta-gnome-desktop</literal>. The <varname>modules</varname> variable specifies which modules that will be built when you don't explicitly specify anything on the command line. You can always build a different moduleset later by specifying it on the commandline (e.g. <command>jhbuild build gtkmm</command>).
fr: 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>).

en: Setting a prefix
fr: Définition d'un préfixe

en: By default, <application>jhbuild</application>'s configuration is configured to install all software built with <application>jhbuild</application> under the <filename>/opt/gnome2</filename> prefix. You can choose a different prefix, but it is recommended that you keep this prefix different from other software that you've installed (don't set it to <filename>/usr</filename>!) If you've followed the jhbuild instructions then this prefix belongs to your user, so you don't need to run jhbuild as <literal>root</literal>.
fr: 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>.

en: Installing and Using the git version of <application>gtkmm</application>
fr: Installation et utilisation de la version git de <application>gtkmm</application>

en: Once you've configured <application>jhbuild</application> as described above, building <application>gtkmm</application> should be relatively straightforward. The first time you run <application>jhbuild</application>, you should run the following sequence of commands to ensure that <application>jhbuild</application> has the required tools and verify that it is set up correctly: <screen>$ jhbuild bootstrap
    $ jhbuild sanitycheck</screen>
fr: 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>

en: Installing <application>gtkmm</application> with <application>jhbuild</application>
fr: Installation de <application>gtkmm</application> avec <application>jhbuild</application>

en: If everything worked correctly, you should be able to build <application>gtkmm</application> and all of its dependencies from git by executing <command>jhbuild build</command> (or, if you didn't specify <application>gtkmm</application> in the <varname>modules</varname> variable, with the command <command>jhbuild build gtkmm</command>).
fr: 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>).

en: This command will build and install a series of modules and will probably take quite a long time the first time through. After the first time, however, it should go quite a bit faster since it only needs to rebuild files than changed since the last build. Alternatively, after you've built and installed <application>gtkmm</application> the first time, you can rebuild <application>gtkmm</application> by itself (without rebuilding all of its dependencies) with the command <command>jhbuild buildone gtkmm</command>.
fr: 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>.

en: Using the git version of <application>gtkmm</application>
fr: Utilisation de la version git de <application>gtkmm</application>

en: After you've installed the git version of <application>gtkmm</application>, you're ready to start using and experimenting with it. In order to use the new version of <application>gtkmm</application> you've just installed, you need to set some environment variables so that your <filename>configure</filename> script knows where to find the new libraries. Fortunately, <application>jhbuild</application> offers an easy solution to this problem. Executing the command <command>jhbuild shell</command> will start a new shell with all of the correct environment variables set. Now if you re-configure and build your project just as you usually do, it should link against the newly installed libraries. To return to your previous environment, simply exit the <application>jhbuild</application> shell.
fr: 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>.

en: Once you've built your software, you'll need to run your program within the jhbuild environment as well. To do this, you can again use the <command>jhbuild shell</command> command to start a new shell with the <application>jhbuild</application> environment set up. Alternatively, you can execute a one-off command in the <application>jhbuild</application> environment using the following command: <command>jhbuild run command-name</command>. In this case, the command will be run with the correct environment variables set, but will return to your previous environment after the program exits.
fr: 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.

en: Wrapping C Libraries with gmmproc
fr: Habillage des bibliothèques C avec gmmproc

en: <application>gtkmm</application> uses the <command>gmmproc</command> tool to generate most of its source code, using .defs files that define the APIs of <classname>GObject</classname>-based libraries. So it's quite easy to create additional gtkmm-style wrappers of other glib/GObject-based libraries.
fr: <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.

en: This involves a variety of tools, some of them crufty, but it does at least work, and has been used successfully by several projects.
fr: Cela implique divers outils, dont certains sont retors, mais qui au moins fonctionnent ; ils ont été utilisés avec succès par plusieurs projets.

en: The build structure
fr: La structure de construction

en: Generation of the source code for a gtkmm-style wrapper API requires use of tools such as <command>gmmproc</command> and <filename>generate_wrap_init.pl</filename>. In theory you could write your own build files to use these appropriately, but a much better option is to make use of the build infrastructure provided by the mm-common module. To get started, it helps a lot to pick an existing binding module as an example to look at.
fr: 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.

en: For instance, let's pretend that we are wrapping a C library called libexample. It provides a <classname>GObject</classname>-based API with types named, for instance, <classname>ExampleThing</classname> and <classname>ExampleStuff</classname>.
fr: 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>.

en: Copying the skeleton project
fr: Copie du squelette du projet

en: Typically our wrapper library would be called libsomethingmm. We can start by copying the <ulink url="http://git.gnome.org/cgit/mm-common/tree/skeletonmm">skeleton source tree</ulink> from the mm-common module. <placeholder-1/>
fr: 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. <placeholder-1/>

en: <filename>libsomethingmm</filename>: The top-level directory.
fr: <filename>libsomethingmm</filename> : le répertoire de plus haut niveau.

en: <filename>libsomething</filename>: Contains the main include file and the pkg-config .pc file.
fr: <filename>libsomething</filename> : contient le fichier include principal et le fichier pkg-config .pc.

en: <filename>src</filename>: Contains .hg and .ccg source files.
fr: <filename>src</filename> : contient les fichiers source .hg et .ccg.

en: <filename>libsomethingmm</filename>: Contains generated and hand-written .h and .cc files.
fr: <filename>libsomethingmm</filename> : contient les fichiers .h et .cc générés et écrits à la main.

en: <filename>private</filename>: Contains generated <filename>*_p.h</filename> files.
fr: <filename>private</filename> : contient les fichiers générés <filename>*_p.h</filename>.

en: This provides a directory structure for the source .hg and .ccg files and the generated .h and .cc files, with <filename>filelist.am</filename> Automake include files that can specify the various files in use, in terms of generic Automake variables. The directory structure usually looks like this, after we have renamed the directories appropriately: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: As well as renaming the directories, we should rename some of the source files. For instance: <placeholder-1/> A number of the skeleton files must still be filled in with project-specific content later.
fr: De la même manière que nous avons renommé les répertoires, nous devons renommer certains fichiers sources. Par exemple : <placeholder-1/> Un certain nombre de fichiers squelettes doivent être complétés plus tard avec les données spécifiques au contenu du projet.

en: Note that files ending in <filename>.in</filename> will be used to generate files with the same name but without the <filename>.in</filename> suffix, by replacing some variables with actual values during the configure stage.
fr: 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.

en: Modifying build files
fr: Modification des fichiers de construction

en: Now we edit the files to adapt them to to our needs. You might prefer to use a multiple-file search-replace utility for this, such as <command>regexxer</command>. Note that nearly all of the files provided with the skeleton source tree contain placeholder text. Thus, the substitutions should be performed globally, and not be limited to the Automake and Autoconf files.
fr: 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.

en: All mentions of <varname>skeleton</varname> should be replaced by the correct name of the C library you are wrapping, such as "something" or "libsomething". In the same manner, all instances of <varname>SKELETON</varname> should be replaced by "SOMETHING" or "LIBSOMETHING", and all occurrences of <varname>Skeleton</varname> changed to "Something".
fr: 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 ».

en: Likewise, replace all instances of <varname>Joe Hacker</varname> by the name of the intended copyright holder, which is probably you. Do the same for the <varname>joe@example.com</varname> email address.
fr: 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>.

en: The <function>AC_CONFIG_SRCDIR()</function> line must mention a file in our source tree. We can edit this later if we don't yet know the names of any of the files that we will create.
fr: 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.

en: It is common for binding modules to track the version number of the library they are wrapping. So, for instance, if the C library is at version 1.23.4, then the initial version of the binding module would be 1.23.0. However, avoid starting with an even minor version number as that usually indicates a stable release.
fr: 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.

en: The <function>AC_CONFIG_HEADERS()</function> line is used to generate two or more configuration header files. The first header file in the list contains all configuration macros which are set during the configure run. The remaining headers in the list contain only a subset of configuration macros and their corresponding <filename>configh.h.in</filename> file will not be autogenerated. The reason for this separation is that the namespaced configuration headers are installed with your library and define publically visible macros.
fr: 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.

en: The <function>AC_SUBST([SOMETHINGMM_MODULES], ['...'])</function> line may need to be modified to check for the correct dependencies.
fr: 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.

en: The <function>AC_CONFIG_FILES()</function> block must mention the correct directory names, as described above.
fr: le bloc <function>AC_CONFIG_FILES()</function> doit mentionner les noms de répertoires corrects, tels que décrits ci-dessus.

en: In <filename>configure.ac</filename>, <placeholder-1/>
fr: Dans <filename>configure.ac</filename>, <placeholder-1/>

en: Makefile.am files
fr: Fichiers Makefile.am

en: In <filename>skeleton/src/Makefile.am</filename> we must mention the correct values for the generic variables that are used elsewhere in the build system:
fr: 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 :

en: The name of the library, such as libsomethingmm.
fr: le nom de la bibliothèque, comme libsomethingmm.

en: Additional command-line flags passed to the <filename>generate_wrap_init.pl</filename> script, such as the C++ namespace and the parent directory prefix of include files.
fr: 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.

en: In <filename>skeleton/skeletonmm/Makefile.am</filename> we must mention the correct values for the generic variables that are used elsewhere in the build system:
fr: 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 :

en: This variable must mention the correct library name, and this library name must be used to form the <varname>_SOURCES</varname>, <varname>_LDFLAGS</varname>, and <varname>_LIBADD</varname> variable names. It is permissible to use variables substituted by <filename>configure</filename> like <varname>@SOMETHINGMM_API_VERSION@</varname> as part of the variable names.
fr: 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.

en: The command line options passed to the C preprocessor.
fr: les options en ligne de commande passées au préprocesseur C.

en: The command line options passed to the C++ compiler.
fr: les options en ligne de commande passées au compilateur C++.

en: Next we must adapt the various <filename>Makefile.am</filename> files: <placeholder-1/>
fr: Ensuite nous devons adapter les divers fichiers <filename>Makefile.am</filename> : <placeholder-1/>

en: Creating .hg and .ccg files
fr: Création des fichiers .hg et .ccg

en: We should now create our first <filename>.hg</filename> and <filename>.ccg</filename> files, to wrap one of the objects in the C library. One pair of example source files already exists: <filename>skeleton.ccg</filename> and <filename>skeleton.hg</filename>. Create copies of these files as necessary.
fr: 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.

en: We must mention all of our <filename>.hg</filename> and <filename>.ccg</filename> files in the <filename>skeleton/src/filelist.am</filename> file, typically in the <varname>files_hg</varname> variable.
fr: 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>.

en: Any additional non-generated <filename>.h</filename> and <filename>.cc</filename> source files may be placed in <filename>skeleton/skeletonmm/</filename> and listed in <filename>skeleton/skeletonmm/filelist.am</filename>, typically in the <varname>files_extra_h</varname> and <varname>files_extra_cc</varname> variables.
fr: 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>.

en: In the <link linkend="sec-wrapping-hg-files">.hg and .ccg files</link> section you can learn about the syntax used in these files.
fr: Dans le paragraphe <link linkend="sec-wrapping-hg-files">Fichiers .hg et .ccg</link> vous pouvez voir la syntaxe utilisée dans ces fichiers.

en: Generating the .defs files.
fr: Génération des fichiers .defs

en: objects (GObjects, widgets, interfaces, boxed-types and plain structs)
fr: objets (GObjects, éléments graphiques, interfaces, types de boîtes et structures brutes)

en: functions
fr: fonctions

en: enums
fr: énumérations

en: signals
fr: signaux

en: properties
fr: propriétés

en: vfuncs
fr: fonctions virtuelles.

en: The <filename>.defs</filename> file are text files, in a lisp format, that describe the API of a C library, including its <placeholder-1/>
fr: Les fichiers <filename>.defs</filename> sont des fichiers texte, au format lisp, décrivant l'API de la bibliothèque C, y compris ses <placeholder-1/>

en: Includes the other files.
fr: inclut les autres fichiers.

en: Objects and functions.
fr: objets et fonctions

en: Enumerations.
fr: énumérations.

en: Signals and properties.
fr: signaux et propriétés

en: vfuncs (function pointer member fields in structs), written by hand.
fr: fonctions virtuelles (champs de pointeurs membres de fonction dans des structures), écrites à la main.

en: At the moment, we have separate tools for generating different parts of these <filename>.defs</filename>, so we split them up into separate files. For instance, in the <filename>gtk/src</filename> directory of the <application>gtkmm</application> sources, you will find these files: <placeholder-1/>
fr: À 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 : <placeholder-1/>

en: Generating the methods .defs
fr: Génération des .defs pour les fonctions membres

en: This <filename>.defs</filename> file describes objects and their functions. It is generated by the <command>h2def.py</command> script which you can find in pygobject's <filename>codegen</filename> directory. For instance, <placeholder-1/>
fr: 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, <placeholder-1/>

en: Generating the enums .defs
fr: Génération des .defs pour les énumérations

en: This <filename>.defs</filename> file describes enum types and their possible values. It is generated by the <filename>enum.pl</filename> script which you can find in glibmm's <filename>tools</filename> directory. For instance, <placeholder-1/>
fr: 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, <placeholder-1/>

en: Generating the signals and properties .defs
fr: Génération des .defs pour les signaux et les propriétés

en: This <filename>.defs</filename> file describes signals and properties. It is generated by the special <filename>extra_defs</filename> utility that is in every wrapping project, such as <filename>gtkmm/tools/extra_defs_gen/</filename>. For instance <placeholder-1/>
fr: 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  <placeholder-1/>

en: You must edit the source code of your own <filename>generate_extra_defs</filename> tool in order to generate the <filename>.defs</filename> for the GObject C types that you wish to wrap. In the skeleton source tree, the source file is named <filename>codegen/extradefs/generate_extra_defs_skeleton.cc</filename>. If not done so already, the file should be renamed, with the basename of your new binding substituted for the <varname>skeleton</varname> placeholder. The <filename>codegen/Makefile.am</filename> file should also mention the new source filename.
fr: 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.

en: Then edit the <filename>.cc</filename> file to specify the correct types. For instance, your <function>main()</function> function might look like this: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: Writing the vfuncs .defs
fr: Écriture des .defs pour les fonctions virtuelles

en: The .hg and .ccg files
fr: Les fichiers .hg et .ccg

en: The .hg and .ccg source files are very much like .h and .cc C++ source files, but they contain extra macros, such as <function>_CLASS_GOBJECT()</function> and <function>_WRAP_METHOD()</function>, from which <command>gmmproc</command> generates appropriate C++ source code, usually at the same position in the header. Any additional C++ source code will be copied verbatim into the corresponding .h or .cc file.
fr: 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.

en: 
    #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)
    };
    
    } // namespace Gtk
fr: 
    #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

en: A .hg file will typically include some headers and then declare a class, using some macros to add API or behaviour to this class. For instance, gtkmm's <filename>button.hg</filename> looks roughly like this: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: Specifies the destination directry for generated sources, and the name of the main .defs file that <command>gmmproc</command> should parse.
fr: 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.

en: Tells <command>gmmproc</command> to include a header from the generated private/button_p.h file.
fr: indique à <command>gmmproc</command> d'inclure un en-tête à partir du fichier private/button_p.h.

en: Tells <command>gmmproc</command> to add some typedefs, constructors, and standard methods to this class, as appropriate when wrapping a GtkObject-derived type.
fr: 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.

en: <function>_WRAP_METHOD()</function>, <function>_WRAP_SIGNAL()</function>, and <function>_WRAP_PROPERTY()</function>
fr: <function>_WRAP_METHOD()</function>, <function>_WRAP_SIGNAL()</function> et <function>_WRAP_PROPERTY()</function>

en: Add methods to wrap parts of the C API.
fr: ajoute des fonctions membres pour habiller des parties de l'API C.

en: The macros in this example do the following: <placeholder-1/>
fr: Les macros employées dans cet exemple effectuent les tâches suivantes : <placeholder-1/>

en: The .h and .cc files will be generated from the .hg and .ccg files by processing them with <command>gmmproc</command> like so, though this happens automatically when using the above build structure: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: Notice that we provided <command>gmmproc</command> with the path to the .m4 convert files, the path to the .defs file, the name of a .hg file, the source directory, and the destination directory.
fr: 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.

en: You should avoid including the C header from your C++ header, to avoid polluting the global namespace, and to avoid exporting unnecessary public API. But you will need to include the necessary C headers from your .ccg file.
fr: 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.

en: The macros are explained in more detail in the following sections.
fr: Les macros sont expliquées plus en détail dans les paragraphes suivants.

en: m4 Conversions
fr: Conversions m4

en: The macros that you use in the .hg and .ccg files often need to know how to convert a C++ type to a C type, or vice-versa. gmmproc takes this information from an .m4 file in your <literal>tools/m4/</literal> directory. This allows it to call a C function in the implementation of your C++ method, passing the appropriate parameters to that C functon. For instance, this tells gmmproc how to convert a GtkTreeView pointer to a Gtk::TreeView pointer: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: <literal>$3</literal> will be replaced by the parameter name when this conversion is used by gmmproc.
fr: <literal>$3</literal> sera remplacé par le nom du paramètre lorsque cette conversion est utilisée par gmmproc.

en: Some extra macros make this easier and consistent. Look in gtkmm's .m4 files for examples. For instance: <placeholder-1/>
fr: Quelques macros supplémentaires rendent ceci plus facile et plus cohérent. Regardez dans les fichiers .m4 pour des exemples. Ainsi :<placeholder-1/>

en: Class macros
fr: Macros de classes

en: The class macro declares the class itself and its relationship with the underlying C type. It generates some internal constructors, the member <varname>gobject_</varname>, typedefs, the <function>gobj()</function> accessors, type registration, and the <function>Glib::wrap()</function> method, among other things.
fr: 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.

en: Other macros, such as <function>_WRAP_METHOD()</function> and <function>_SIGNAL()</function> may only be used after a call to a <function>_CLASS_*</function> macro.
fr: 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>.

en: This macro declares a wrapper for a type that is derived from <classname>GObject</classname>, but which is not derived from <classname>GtkObject</classname>.
fr: Cette macro déclare un habillage pour un type dérivé de <classname>GObject</classname>, mais non-dérivé de <classname>GtkObject</classname>.

en: For instance, from <filename>accelgroup.hg</filename>: <placeholder-1/>
fr: Par exemple, à partir de <filename>accelgroup.hg</filename> : <placeholder-1/>

en: This macro declares a wrapper for a type that is derived from <classname>GtkObject</classname>, such as a widget or dialog.
fr: 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.

en: For instance, from <filename>button.hg</filename>: <placeholder-1/>
fr: Par exemple, à partir de <filename>button.hg</filename> : <placeholder-1/>

en: This macro declares a wrapper for a non-<classname>GObject</classname> struct, registered with <function>g_boxed_type_register_static()</function>.
fr: Cette macro déclare un habillage pour une structure non-<classname>GObject</classname>, enregistrée avec <function>g_boxed_type_register_static()</function>.

en: For instance, for <classname>Gdk::Color</classname>: <placeholder-1/>
fr: Par exemple, pour <classname>Gdk::Color</classname> : <placeholder-1/>

en: This macro declares a wrapper for a simple assignable struct such as <classname>GdkRectangle</classname>. It is similar to <function>_CLASS_BOXEDTYPE</function>, but the C struct is not allocated dynamically.
fr: 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.

en: For instance, for <classname>Gdk::Rectangle</classname>: <placeholder-1/>
fr: Par exemple, pour <classname>Gdk::Rectangle</classname> : <placeholder-1/>

en: This macro declares a wrapper for an opaque struct that has copy and free functions. The new, copy and free functions will be used to instantiate the default constructor, copy constructor and destructor.
fr: 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.

en: _CLASS_OPAQUE_COPYABLE( C++ class, C class, new function, copy function, free function )
fr: _CLASS_OPAQUE_COPYABLE( C++ class,
                            C class,
                            new function,
                            copy function,
                            free function )

en: 
    _CLASS_OPAQUE_COPYABLE(Region, GdkRegion, gdk_region_new, gdk_region_copy, gdk_region_destroy)
fr: 
    _CLASS_OPAQUE_COPYABLE(Region, 
                           GdkRegion,
                           gdk_region_new,
                           gdk_region_copy,
                           gdk_region_destroy)

en: For instance, for <classname>Gdk::Region</classname>: <placeholder-1/>
fr: Par exemple, pour <classname>Gdk::Region</classname> : <placeholder-1/>

en: This macro declares a wrapper for a reference-counted opaque struct. The C++ wrapper cannot be directly instantiated and can only be used with <classname>Glib::RefPtr</classname>.
fr: 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>.

en: 
    _CLASS_OPAQUE_REFCOUNTED(Coverage, PangoCoverage, pango_coverage_new, pango_coverage_ref, pango_coverage_unref)
fr: 
    _CLASS_OPAQUE_REFCOUNTED(Coverage, 
                             PangoCoverage, 
                             pango_coverage_new, 
                             pango_coverage_ref, 
                             pango_coverage_unref)

en: For instance, for <classname>Pango::Coverage</classname>: <placeholder-1/>
fr: Par exemple, pour <classname>Pango::Coverage</classname> : <placeholder-1/>

en: This macro can be used to wrap structs which don't fit into any specialized category.
fr: Cette macro peut être utilisée pour habiller les structures n'entrant pas dans une catégorie particulière.

en: For instance, for <classname>Pango::AttrIter</classname>: <placeholder-1/>
fr: Par exemple, pour <classname>Pango::AttrIter</classname> : <placeholder-1/>

en: 
      _CLASS_INTERFACE(CellEditable, GtkCellEditable, GTK_CELL_EDITABLE, GtkCellEditableIface)
fr: 
      _CLASS_INTERFACE(CellEditable,
                       GtkCellEditable,
                       GTK_CELL_EDITABLE,
                       GtkCellEditableIface)

en: For instance, from <filename>celleditable.hg</filename>: <placeholder-1/>
fr: Par exemple, pour <filename>celleditable.hg</filename> : <placeholder-1/>

en: 
      _CLASS_INTERFACE(LoadableIcon, GLoadableIcon, G_LOADABLE_ICON, GLoadableIconIface, Icon, GIcon)
fr: 
      _CLASS_INTERFACE(LoadableIcon,
                       GLoadableIcon,
                       G_LOADABLE_ICON,
                       GLoadableIconIface,
                       Icon,
                       GIcon)

en: Two extra parameters are optional, for the case that the interface derives from another interface, which should be the case when the GInterface has another GInterface as a prerequisitite. For instance, from <filename>loadableicon.hg</filename>: <placeholder-1/>
fr: 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> : <placeholder-1/>

en: Constructor macros
fr: Macros de constructeurs

en: The <function>_CTOR_DEFAULT()</function> and <function>_WRAP_CTOR()</function> macros add constructors, wrapping the specified <function>*_new()</function> C functions. These macros assume that the C object has properties with the same names as the function parameters, as is usually the case, so that it can supply the parameters directly to a <function>g_object_new()</function> call. These constructors never actually call the <function>*_new()</function> C functions, because gtkmm must actually instantiate derived GTypes, and the <function>*_new()</function> C functions are meant only as convenience functions for C programmers.
fr: 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.

en: 
    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())
fr: 
    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())

en: When using <function>_CLASS_GOBJECT()</function>, the constructors should be protected (rather than public) and each constructor should have a corresponding <function>_WRAP_CREATE()</function> in the public section. This prevents the class from being instantiated without using a <classname>RefPtr</classname>. For instance: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: This macro creates a default constructor with no arguments.
fr: Cette macro crée un constructeur par défaut sans paramètre.

en: This macro creates a constructor with arguments, equivalent to a <function>*_new()</function> C function. It won't actually call the <function>*_new()</function> function, but will simply create an equivalent constructor with the same argument types. It takes a C++ constructor signature, and a C function name.
fr: 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.

en: Hand-coding constructors
fr: Constructeurs codés à la main

en: When a constructor must be partly hand written because, for instance, the <function>*_new()</function> C function's parameters do not correspond directly to object properties, or because the <function>*_new()</function> C function does more than call <function>g_object_new()</function>, the <function>_CONSTRUCT()</function> macro may be used in the .ccg file to save some work. The <function>_CONSTRUCT</function> macro takes a series of property names and values. For instance, from <filename>button.ccg</filename>: <placeholder-1/>
fr: 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> : <placeholder-1/>

en: Method macros
fr: Macros pour fonctions membres

en: This macro generates the C++ method to wrap a C function.
fr: Cette macro génère une fonction membre C++ habillant une fonction C.

en: For instance, from <filename>entry.hg</filename>: <placeholder-1/>
fr: Par exemple, pour <filename>entry.hg</filename> : <placeholder-1/>

en: The C function (e.g. <function>gtk_entry_set_text</function>) is described more fully in the .defs file, and the <filename>convert*.m4</filename> files contain the necessary conversion from the C++ parameter type to the C parameter type. This macro also generates doxygen documentation comments based on the <filename>*_docs.xml</filename> and <filename>*_docs_override.xml</filename> files.
fr: 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>.

en: Do an extra reference() on the return value, in case the C function does not provide a reference.
fr: effectue un appel supplémentaire à reference() sur la valeur de retour au cas où la fonction C ne fournirait pas de référence.

en: Use the last GError* parameter of the C function to throw an exception.
fr: utilise le dernier paramètre GError* de la fonction C pour déclencher une exception.

en: Puts the generated code in #ifdef blocks. Text about the deprecation can be specified as an optional parameter.
fr: 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.

en: Just call the non-const version of the same function, instead of generating almost duplicate code.
fr: appelle simplement la version non-const de la même fonction au lieu de générer du code dupliqué.

en: There are some optional extra arguments: <placeholder-1/>
fr: Il y a quelques paramètres optionnels supplémentaires : <placeholder-1/>

en: Objects used via <classname>RefPtr</classname>: Pass the <classname>RefPtr</classname> as a const reference. For instance, <code>const Glib::RefPtr&lt;Gtk::Action&gt;&amp; action</code>.
fr: 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>.

en: Const Objects used via <classname>RefPtr</classname>: If the object should not be changed by the function, then make sure that the object is const, even if the <classname>RefPtr</classname> is already const. For instance, <code>const Glib::RefPtr&lt;const Gtk::Action&gt;&amp; action</code>.
fr: 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>.

en: 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 an appropriate intermediate type, such as <classname>Glib::ListHandle</classname> or <classname>Glib::SListHandle</classname>. These are templates, so you can specify the item type. For instance, <code>Glib::ListHandle&lt; Glib::RefPtr&lt;Action&gt; &gt;</code>. Existing typedefs exist for some common list types. You may need to define a Traits type to specify how the C and C++ types should be converted.
fr: Habillage des paramètres <classname>GList*</classname> et <classname>GSList*</classname> : d'abord, vous devez découvrir quels objets sont contenus dans les champs des données de la liste pour chaque élément, généralement en lisant la documentation de la fonction C. La liste peut être habillée dans un type intermédiaire approprié, tel que <classname>Glib::ListHandle</classname> ou <classname>Glib::SListHandle</classname>. Ce sont des contenus génériques ; vous pouvez donc préciser le type d'élément, par exemple, <code>Glib::ListHandle&lt; Glib::RefPtr&lt;Action&gt; &gt;</code>. Il y a des définitions de type existantes pour quelques types de listes courants. Vous pouvez avoir besoin de définir un type Traits pour préciser comment les types C et C++ doivent être convertis.

en: Wrapping <classname>GList*</classname> and <classname>GSList*</classname> return types: You must discover whether the caller should free the list and whether it should release the items in the list, again by reading the documentation of the C function. With this information you can choose the ownership (none, shallow or deep) for the m4 conversion rule, which you should probably put directly into the .hg file because the ownership depends on the function rather than the type. For instance: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: Though it's usually obvious what C++ types should be used in the C++ method, here are some hints: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: This macro is like <function>_WRAP_METHOD()</function>, but it generates only the documentation for a C++ method that wraps a C function. Use this when you must hand-code the method, but you want to use the documentation that would be generated if the method was generated.
fr: 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.

en: For instance, from <filename>container.hg</filename>: <placeholder-1/>
fr: Par exemple, pour <filename>container.hg</filename> : <placeholder-1/>

en: <command>gmmproc</command> will warn you on stdout about functions that you have forgotten to wrap, helping to ensure that you are wrapping the complete API. Buf if you don't want to wrap some functions or if you chose to hand-code some methods then you can use the _IGNORE() macro the make <command>gmmproc</command> stop complaining.
fr: <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.

en: For instance, from <filename>buttonbox.hg</filename>: <placeholder-1/>
fr: Par exemple, pour <filename>buttonbox.hg</filename> : <placeholder-1/>

en: This macro generates the C++ libsigc++-style signal to wrap a C GObject signal. It actually generates a public accessor method, such as <function>signal_clicked()</function>, which returns a proxy object. <command>gmmproc</command> uses the .defs file to discover the C parameter types and the .m4 convert files to discover appropriate type conversions.
fr: 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.

en: Signals usually have function pointers in the GTK struct, with a corresponding enum value. and a <function>g_signal_new()</function> in the .c file.
fr: 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.

en: Do not generate an <function>on_something()</function> virtual method to allow easy overriding of the default signal handler. Use this when adding a signal with a default signal handler would break the ABI by increasing the size of the class's virtual function table.
fr: 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.

en: This macro generates the C++ method to wrap a C GObject property. You must specify the property name and the wanted C++ type for the property. <command>gmmproc</command> uses the .defs file to discover the C type and the .m4 convert files to discover appropriate type conversions.
fr: 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.

en: Other macros
fr: Autres macros :

en: This macro generates a C++ enum to wrap a C enum. You must specify the desired C++ name and the name of the underlying C enum.
fr: 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.

en: For instance, from <filename>widget.hg</filename>: <placeholder-1/>
fr: Par exemple, pour <filename>widget.hg</filename> : <placeholder-1/>

en: If the enum is not a <classname>GType</classname>, you must pass a third parameter NO_GTYPE. This is the case when there is no <function>*_get_type()</function> function for the C enum, but be careful that you don't just need to include an extra header for that function. You should also file a bug against the C API, because all enums should be registered as GTypes.
fr: 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.

en: For example: <placeholder-1/>
fr: Par exemple : <placeholder-1/>

en: This macro generates a C++ exception class, derived from Glib::Error, with a Code enum and a code() method. You must specify the desired C++ name, the name of the corresponding C enum, and the prefix for the C enum values.
fr: 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.

en: This exception can then be thrown by methods which are generated from _WRAP_METHOD() with the errthrow option.
fr: Cette exception peut alors être déclenchée par des fonctions membres générées par _WRAP_METHOD() avec l'option errthrow.

en: For instance, from <filename>pixbuf.hg</filename>: <placeholder-1/>
fr: Par exemple, pour <filename>pixbuf.hg</filename> : <placeholder-1/>

en: Use these macros if you're wrapping a simple struct or boxed type that provides direct access to its data members, to create getters and setters for the data members.
fr: 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.

en: For example, in <filename>rectangle.hg</filename>: <placeholder-1/>
fr: Par exemple, dans <filename>rectangle.hg</filename> : <placeholder-1/>

en: Use these macros to automatically provide getters and setters for a data member that is a pointer type. For the getter function, it will create two methods, one const and one non-const.
fr: 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>.

en: For example, in <filename>dialog.hg</filename>: <placeholder-1/>
fr: Par exemple, dans <filename>dialog.hg</filename> : <placeholder-1/>

en: Use this macro to provide getters and setters for a data member that is a <classname>GObject</classname> type that must be referenced before being returned.
fr: 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.

en: For example, in <filename>progress.hg</filename>: <placeholder-1/>
fr: Par exemple, dans <filename>progress.hg</filename> : <placeholder-1/>

en: Basic Types
fr: Types de base

en: Some of the basic types that are used in C APIs have better alternatives in C++. For example, there's no need for a <type>gboolean</type> type since C++ has <type>bool</type>. The following list shows some commonly-used types in C APIs and what you might convert them to in a C++ wrapper library.
fr: 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++.

en: Basic Type equivalents
fr: Équivalents des types de base

en: C type
fr: Types C

en: C++ type
fr: Types C++

en: <placeholder-1/> (or <placeholder-2/> for filenames)
fr: <placeholder-1/> (ou <placeholder-2/> pour les noms de fichiers)

en: Hand-coded source files
fr: Fichiers sources codés à la main

en: You might want to include additional source files that will not be generated by <command>gmmproc</command> from <filename>.hg</filename> and <filename>.ccg</filename> files. You can simply place these in your <filename>libsomething/libsomethingmm</filename> directory and mention them in the <filename>Makefile.am</filename> in the <varname>files_extra_h</varname> and <varname>files_extra_cc</varname> variables.
fr: 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>.

en: Initialization
fr: Initialisation

en: 
    void init()
    {
      Gtk::Main::init_gtkmm_internals(); //Sets up the g type system and the Glib::wrap() table.
      wrap_init(); //Tells the Glib::wrap() table about the libsomethingmm classes.
    }
fr: 
    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();
    }

en: Your library must be initialized before it can be used, to register the new types that it makes available. Also, the C library that you are wrapping might have its own initialization function that you should call. You can do this in an <function>init()</function> function that you can place in hand-coded <filename>init.h</filename> and <filename>init.cc</filename> files. This function should initialize your dependencies (such as the C function, and <application>gtkmm</application>) and call your generated <function>wrap_init()</function> function. For instance: <placeholder-1/>
fr: 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 : <placeholder-1/>

en: The implementation of the <function>wrap_init()</function> method in <filename>wrap_init.cc</filename> is generated by <filename>generate_wrap_init.pl</filename>, but the declaration in <filename>wrap_init.h</filename> is hand-coded, so you will need to adjust <filename>wrap_init.h</filename> so that the <function>init()</function> function appears in the correct C++ namespace.
fr: 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.

en: Problems in the C API.
fr: Problèmes dans l'API C

en: You are likely to encounter some problems in the library that you are wrapping, particularly if it is a new project. Here are some common problems, with solutions.
fr: 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.

en: Unable to predeclare structs
fr: Impossibilité de pré-déclarer des structures

en: By convention, structs are declared in glib/GTK+-style headers like so: <placeholder-1/>
fr: Par convention, les structures sont déclarées comme suit dans les en-têtes de style glib/GTK+ : <placeholder-1/>

en: The extra typedef allows the struct to be used in a header without including its full defintion, simply by predeclaring it, by repeating that typedef. This means that you don't have to include the C library's header in your C++ header, thus keeping it out of your public API. <command>gmmproc</command> assumes that this technique was used, so you will see compiler errors if that is not the case.
fr: 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.

en: 
    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
fr: 
    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

en: 
    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'
fr: 
    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'

en: This compiler error might look like this: <placeholder-1/> or this: <placeholder-2/>
fr: L'erreur de compilation ressemble à quelque chose comme : <placeholder-1/> ou bien encore : <placeholder-2/>

en: This is easy to correct in the C library, so do send a patch to the relevant maintainer.
fr: C'est facile à corriger dans la bibliothèque C ; n'envoyez pas de correctif au mainteneur concerné.

en: Lack of properties
fr: Perte de propriétés

en: 
    GtkWidget* example_widget_new(int something, const char* thing)
    {
            return g_object_new (EXAMPLE_TYPE_WIDGET, "something", something, "thing", thing, NULL);
    }
fr: 
    GtkWidget* example_widget_new(int something, const char* thing)
    {
            return g_object_new (EXAMPLE_TYPE_WIDGET,
                                 "something", something, 
                                 "thing", thing, NULL);
    }

en: By convention, glib/GTK+-style objects have <function>*_new()</function> functions, such as <function>example_widget_new()</function> that do nothing more than call <function>g_object_new()</function> and return the result. The input parameters are supplied to <function>g_object_new()</function> along with the names of the properties for which they are values. For instance, <placeholder-1/>
fr: 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, <placeholder-1/>

en: This allows language bindings to implement their own equivalents (such as C++ constructors), without using the <function>*_new()</function> function. This is often necessary so that they can actually instantiate a derived GType, to add their own hooks for signal handlers and vfuncs.
fr: 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.

en: At the least, the <function>_new()</function> function should not use any private API (functions that are only in a .c file). Even when there are no functions, we can sometimes reimplement 2 or 3 lines of code in a <function>_new()</function> function as long as those lines of code use API that is available to us.
fr: 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.

en: 
    GtkWidget* example_widget_new(int something, const char* thing)
    {
            ExampleWidget* widget;
            widget = g_object_new (EXAMPLE_TYPE_WIDGET, NULL);
            example_widget_construct(widget, "something", something, "thing", thing);
    }
    
    void example_widget_construct(ExampleWidget* widget, int something, const char* thing)
    {
            //Do stuff that uses private API:
            widget-&gt;priv-&gt;thing = thing;
            do_something(something);
    }
fr: 
    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);
    }

en: Another workaround is to add a <function>*_construct()</function> function that the C++ constructor can call after instantiating its own type. For instance, <placeholder-1/>
fr: 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, <placeholder-1/>

en: Adding properties, and ensuring that they interact properly with each other, is relatively difficult to correct in the C library, but it is possible, so do file a bug and try to send a patch to the relevant maintainer.
fr: 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é.

en: In general, gtkmm-style projects use Doxygen, which reads specially formatted C++ comments and generates HTML documentation. You may write these doxygen comments directly in the header files.
fr: 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.

en: Reusing C documentation
fr: Réutilisation de la documentation C

en: You might wish to reuse documentation that exists for the C library that you are wrapping. GTK-style C libraries typically use gtk-doc and therefore have source code comments formatted for gtk-doc and some extra documentation in .tmpl files. The docextract_to_xml.py script, from pygobject's codegen directory, can read these files and generate an .xml file that <command>gmmproc</command> can use to generate doxygen comments. <command>gmmproc</command> will even try to transform the documentation to make it more appropriate for a C++ API.
fr: 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++.

en: ./docextract_to_xml.py -s /gnome/head/cvs/gtk+/gtk/ -s /gnome/head/cvs/gtk+/docs/reference/gtk/tmpl/ &gt; gtk_docs.xml
fr: ./docextract_to_xml.py -s /gnome/head/cvs/gtk+/gtk/ \
    -s /gnome/head/cvs/gtk+/docs/reference/gtk/tmpl/ &gt; gtk_docs.xml

en: Because this automatic transformation is not always appropriate, you might want to provide hand-written text for a particular method. You can do this by copying the XML node for the function from your <filename>something_docs.xml</filename> file to the <filename>something_docs_override.xml</filename> file and changing the contents.
fr: 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.

en: Documentation build structure
fr: Structure de construction de la documentation

en: If you copied the skeleton source tree in mm-common and substituted the placeholder text, then you will already have suitable <filename>Makefile.am</filename> and <filename>Doxyfile.in</filename> files. With the mm-common build setup, the list of Doxygen input files is not defined in the Doxygen configuration file, but passed along from <command>make</command> to the standard input of <command>doxygen</command>. The input file list is defined by the <varname>doc_input</varname> variable in the <filename>Makefile.am</filename> file.
fr: 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>.
