<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
<!ENTITY mdash "&#38;#x2014;">
<!ENTITY hellip "&#x2026;">
<!ENTITY introduction SYSTEM "introduction.xml">
<!ENTITY interface SYSTEM "interface.xml">
<!ENTITY fileoperations SYSTEM "fileoperations.xml">
<!ENTITY projects SYSTEM "projects.xml">
<!ENTITY build SYSTEM "build.xml">
<!ENTITY debugger SYSTEM "debugger.xml">
<!ENTITY glade SYSTEM "glade.xml">
<!ENTITY preferences SYSTEM "preferences.xml">
<!ENTITY tools SYSTEM "tools.xml">
<!ENTITY authors SYSTEM "authors.xml">
<!ENTITY license SYSTEM "license.xml">
<!ENTITY appversion "2.0.2">
<!ENTITY manrevision "2.7">
<!ENTITY date "April 2006">
<!ENTITY app "anjuta">
]>
<!-- =============Document Header ============================= -->
<book id="index" lang="fr">
 <bookinfo>
  <title>Manuel de l'environnement de développement intégré Anjuta</title>
  <edition>V 1.0.0</edition>
  <abstract role="description">
  	<para>Manuel de l'environnement de développement intégré Anjuta</para>
  </abstract>
  
	<author role="maintainer">
		<firstname>Naba</firstname>
		<surname>Kumar</surname>
	</author>
	<author>
		<firstname>Andy</firstname>
		<surname>Piper</surname>
	</author>
	<author>
		<firstname>Biswapesh</firstname>
		<surname>Chattopadhyayr</surname>
	</author>
	<author>
		<firstname>Johannes</firstname>
		<surname>Schmid</surname>
	</author>

  <copyright>
   <year>2001-2002</year>
   <year>2006-2008</year>
   <holder>Naba Kumar, Andy Piper, Biswapesh Chattopadhyay</holder>
   <holder>Johannes Schmid</holder>
  </copyright><copyright><year>2009-2010.</year><holder>Bruno Brouard (annoa.b@gmail.com)</holder></copyright><copyright><year>2010.</year><holder>Gérard Baylard (gerard.b|@|bbox.fr)</holder></copyright>
  
  <legalnotice>
   <para>Permission vous est donnée de copier, distribuer et/ou modifier ce document selon les termes de la <citetitle>Licence GNU Free Documentation License</citetitle>, Version 1.1 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 trouverez un exemplaire de la <citetitle>Licence GNU Free Documentation License</citetitle> de la Free Software Foundation en visitant <ulink type="http" url="http://www.fsf.org">leur site Web</ulink> ou en écrivant à : Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.</para>
   <para>La plupart des noms utilisés par les entreprises pour distinguer leurs produits et services sont des marques déposées. Lorsque ces noms apparaissent dans la documentation GNOME et que les membres du projet de documentation GNOME sont informés de l'existence de ces marques déposées, soit ces noms entiers, soit leur première lettre est en majuscule.</para>
  </legalnotice>

	<revhistory>
		<revision>
		  <revnumber>Manuel de Anjuta 2.1.0</revnumber>
		  <date>2007</date>
		  <revdescription>
			 <para role="author">Johannes Schmid<email>jhs@gnome.org</email></para>
			 <para role="publisher">Équipe Anjuta</para>
		  </revdescription>
		</revision>
	</revhistory>
		
 </bookinfo>
 <!-- Document Body -->
 <!-- Introduction -->
  <!-- ============= Introduction ============================== -->
 <chapter id="introduction">
  <title>Introduction</title>
  <para><application>Anjuta</application> est un environnement de développement intégré (IDE) polyvalent pour le bureau GNOME. Il intègre de nombreuses facilités de programmation avancée comprenant la gestion de projet, des assistants pour applications, un débogueur interactif, le concepteur d'interface utilisateur intégré Glade, l'API d'aide intégrée Devhelp, le profileur de mémoire intégré Valgrind, le profileur de performances intégré gprof, un générateur de classes, un éditeur de source puissant, un navigateur de source et plus encore.</para>

  <para>Anjuta DevStudio a été conçu pour être simple d'emploi mais suffisamment puissant pour répondre à tous vos besoins en programmation. Beaucoup de fonctionnalités ont été ajoutées à Anjuta depuis le début de son développement. Notre but est de fournir puissance et fonctionnalités conjointement et de rendre votre développement de logiciels agréable sans faire trop de fioritures. Nous voulons continuer à améliorer et rendre stable Anjuta pour vous fournir la meilleure expérience d'environnement de développement intégré (IDE). Nous espérons que vous apprécierez l'usage d'Anjuta. Dans le cas contraire, aidez-nous à l'améliorer en rapportant les bogues et en faisant des suggestions.</para>
  <para>La capture d'écran suivante illustre une partie des éléments que vous trouverez dans Anjuta.</para>

  <para>
  <figure id="anjuta-scrshot">
   <title>Anjuta en action</title>
   <screenshot>
   <screeninfo>Anjuta en action</screeninfo>
   <graphic format="PNG" fileref="figures/anjuta-in-action.png" srccredit="jhs"/>
   </screenshot>
   </figure>
  </para>

  <para>Anjuta possède un système de zones d'ancrage flexible et avancé qui vous permet de disposer toutes les vues comme vous le souhaitez. Vous pouvez faire glisser les vues en utilisant les barres de glissement et modifier leur disposition. Chaque projet conserve les placements ; vous pouvez donc avoir un arrangement personnalisé pour chaque projet. Toutes les vues ancrées peuvent être minimisées pour éviter l'encombrement dans la fenêtre principale. Les vues minimisées apparaissent sous forme d'icônes sur le côté gauche de la fenêtre principale. Vous pouvez activer toutes les actions des menus, soit en cliquant lorsque le curseur est au dessus d'un élément de menu (manière classique sous GNOME), soit via une interface utilisateur avec une configuration dédiée de raccourcis clavier.</para>

  <para>Merci de signaler tous problèmes rencontrés avec <application>Anjuta</application>. Cela nous aidera à améliorer le logiciel tout en aidant la communauté des logiciels libres.</para>
 </chapter>

 <!-- Getting Familiar with Anjuta -->
 <chapter id="familiar">
  <title>Familiarisation avec Anjuta</title>
 <!-- ============= Getting Familiar: Menus  ============-->
  <sect1 id="menu-and-shortcuts">
   <title>Menus et raccourcis clavier</title>
   <para>En haut de la fenêtre principale de <application>Anjuta</application> se trouve la barre de menus. Elle vous permet d'accéder à presque toutes les fonctionnalités de Anjuta. Les actions sont regroupées par type. Par exemple, les actions concernant les fichiers sont regroupées dans le menu <guisubmenu>Fichier</guisubmenu>.</para>
	
    <figure id="menubar">
      <title>Barre des menus</title>
	  <screenshot>
      <screeninfo>Barre des menus d'Anjuta</screeninfo>
       <graphic fileref="figures/menubar.png" format="PNG" srccredit="jhs"/>
      </screenshot>
    </figure>
    
    <figure id="file-menu">
      <title>Menu Fichier</title>
      <screenshot>
      <screeninfo>Menu Fichier</screeninfo>
       <graphic fileref="figures/file_menu.png" format="PNG" srccredit="jhs"/>
      </screenshot>
    </figure>
	
   <para>Des raccourcis clavier sont disponibles pour la plupart des éléments de menu. Tous les raccourcis clavier sont affichés en face des éléments de menu correspondants. D'autres raccourcis clavier utiles sont décrits ci-après.</para>
	
   <para>
    <itemizedlist>
     <listitem>
      <para><emphasis>Navigation parmi les onglets de l'éditeur :</emphasis> <keycombo><keycap>Ctrl</keycap><keycap>Alt</keycap><keycap>Page Haut</keycap></keycombo> (en avant) et <keycombo><keycap>Ctrl</keycap><keycap>Alt</keycap><keycap>Page Bas</keycap></keycombo> (en arrière). Vous pouvez également changer de page en faisant un clic-droit sur les onglets de l'éditeur et en choisissant un nom de fichier dans le menu contextuel (c'est pratique quand tous les onglets de l'éditeur ne sont pas entièrement visibles). Il se peut que ces raccourcis clavier soient déjà attribués par certaines configurations de bureau. Dans ce cas, vous devrez les reconfigurer (pas dans Anjuta car ils sont figés) si vous voulez les utiliser.</para>
     </listitem>
     <listitem>
      <para><emphasis>Aide contextuelle :</emphasis> <keycombo><keycap>Majuscule</keycap><keycap>F1</keycap></keycombo>. Positionnez le curseur sur un mot (par exemple, le nom d'une fonction) sur lequel vous voulez obtenir l'aide par l'API et utilisez ce raccourci. L'aide contextuelle ne fonctionne que si <application>Devhelp</application> est installé, sinon le menu d'aide contextuelle et le bouton de la barre d'outils sont inactifs. Vous pouvez obtenir Devhelp à partir du site Web de <application>Devhelp</application>. Vous devez également installer les livres relatifs à <application>Devhelp</application>.</para>
     </listitem>
     <listitem>
      <para><emphasis>Auto-complétion :</emphasis> <keycombo><keycap>Ctrl</keycap><keycap>Entrée</keycap></keycombo>. Utilisez ce raccourci quand le curseur est situé à la fin d'un mot incomplet pour faire apparaître une liste des mots complétant la fin du mot. Faites défiler et choisissez le mot souhaité dans la liste si vous le trouvez.</para>
     </listitem>
     <listitem>
      <para><emphasis>Plus de raccourcis :</emphasis> recherchez les raccourcis affichés à droite des étiquettes des éléments de menu. Les raccourcis peuvent également être modifiés comme expliqué dans l'astuce ci-dessous.</para>
     </listitem>
    </itemizedlist>
   <tip>
   <title>Personnalisation des raccourcis</title>
   <para>Vous pouvez modifier les raccourcis par défaut en choisissant <menuchoice><guisubmenu>Édition</guisubmenu><guimenuitem>Préférences</guimenuitem></menuchoice> et en sélectionnant l'onglet <interface>Raccourcis</interface>.</para>
   </tip>
   </para>
  </sect1>

<!-- ============= Getting Familiar: Main window  ============-->
  <sect1 id="main-win">
   <title>Fenêtre principale</title>
   <para>La fenêtre principale contient plusieurs fenêtres d'affichage qui peuvent être réarrangées en déplaçant leurs barres de titre. Elles peuvent également être minimisées en cliquant sur les boutons minimiser à gauche dans les barres de titre.</para>

   <para>
    <orderedlist>
     <listitem>
      <para>La <interface>fenêtre Documents</interface> ne contient qu'un document actif à la fois (s'il y a des fichiers ouverts). Toutes les commandes fichier s'appliquent à ce document actif. Vous pouvez basculer vers tout document en cliquant sur son onglet. Vous pouvez aussi faire un clic-droit sur les onglets et choisir le document dans le menu déroulant qui apparaît. Ceci est particulièrement pratique lorsqu'il y a beaucoup de fichiers ouverts et qu'ils ne sont pas tous visibles dans la zone des onglets.</para>
	 </listitem>
     <listitem>
      <para>La <interface>fenêtre Projet</interface> affiche l'arborescence des fichiers du projet si un projet est ouvert. Sinon, la <interface>fenêtre Projet</interface> est généralement cachée. En double-cliquant sur un élément de la <interface>fenêtre Projet</interface> vous ouvrez ce fichier.</para>
     </listitem>
      <listitem>
      <para>La <interface>fenêtre Fichiers</interface> affiche l'arborescence des fichiers. Si aucun projet n'est ouvert, l'arborescence pointe habituellement vers la racine du système de fichiers mais vous pouvez modifier ce paramètre dans les préférences. Si un projet est ouvert, la fenêtre affiche tous les fichiers du projet. Un double-clic ouvre le fichier en utilisant l'application appropriée configurée dans les préférences MIME de GNOME. Un clic-droit ouvre un menu contextuel vous permettant de choisir la façon d'ouvrir le fichier.</para>
     </listitem>
      <listitem>
      <para>La <interface>fenêtre Symboles</interface> affiche l'arborescence de tous les symboles disponibles dans le projet, générée par l'analyseur <application>ctags</application>. Un double-clic ouvre une fenêtre de l'éditeur contenant le fichier à la ligne correspondante.</para>
      <para>Un <interface>onglet Rechercher</interface> dans la fenêtre Symboles vous permet de rechercher un symbole donné.</para>
     </listitem>
     <listitem>
      <para>La <interface>fenêtre Messages</interface> affiche tous les messages (les deux sorties <filename>stdout</filename> (standard) et <filename>stderr</filename> (erreurs)) quand une commande externe est exécutée. Généralement cachée, la <interface>fenêtre Messages</interface> apparaît dès qu'une commande externe est exécutée, comme lors de la compilation d'un fichier ou du projet, de sessions de débogage, de recherches et nombre d'autres opérations. <application>Anjuta</application> y ajoute également ses propres messages si nécessaire.</para>
      <para>Les couleurs utilisées pour afficher les messages ont leur importance. Les messages normaux sont affichés avec la couleur d'arrière-plan standard (généralement noir). Les messages d'avertissement sont affichés en orangé et ceux d'erreur en rouge. Les messages d'avertissement et d'erreur sont des <emphasis>liens</emphasis> : un double-clic sur un message de ce type déplace dans le fichier concerné au numéro de ligne indiqué.</para>
      <para>Par exemple, quand vous compilez un fichier qui contient des erreurs, des messages en rouge apparaissent pour vous indiquer la nature des problèmes et leur localisation. Un double-clic sur de tels messages ouvre le fichier et met en surbrillance la ligne contenant l'erreur.</para>
     </listitem>
     <listitem>
      <para>La <interface>fenêtre Terminal</interface> est une émulation de terminal dans laquelle vous pouvez saisir des commandes exactement comme dans le terminal de GNOME.</para>
     </listitem>
    </orderedlist>
   </para>
   <note>
   <title>Gestion des sessions</title>
   <para>Tous les réglages, y compris taille et position des fenêtres, sont enregistrés lorsque vous quittez <application>Anjuta</application>. La gestion des sessions est toujours en cours de développement, aussi vous ne devez pas quitter <application>Anjuta</application> tant qu'il y a des documents non enregistrés. <application>Anjuta</application> affichera un avertissement si vous essayez de quitter avec des documents non sauvegardés encore ouverts.</para>
   </note>
  </sect1>
 </chapter>

 <!-- File operations -->
  <chapter id="file-operations">
  <title>Opérations sur les fichiers</title>
  
  <!-- ============= File operations: Creating a new file === -->
  <sect1 id="creating-files">
   <title>Création d'un nouveau fichier et insertion de texte</title>
    <sect2 id="new-file">
    <title>Création d'un nouveau fichier</title>
     <para>Pour créer un nouveau fichier, choisissez <menuchoice><guisubmenu>Fichier</guisubmenu><guimenuitem>Nouveau</guimenuitem></menuchoice> dans la barre de menus ou cliquez sur le bouton <guibutton>Nouveau fichier</guibutton> de la barre d'outils principale. Un nouvel onglet apparaît dans l'éditeur (ou une nouvelle fenêtre si le document parent est dans une fenêtre). Les nouveaux documents seront appelés <filename>Document non enregistré 1</filename>, <filename>Document non enregistré 2</filename>, <filename>Document non enregistré 3</filename>, etc.</para>
	   <important>
	   <title>Enregistrement de fichier</title>
	   <para>Vous devriez enregistrer les nouveaux documents dès que possible pour éviter de perdre des données en cas d'arrêt brutal.</para>
	   </important>
    </sect2>
    <sect2 id="file-wizard">
    <title>Assistant fichier</title>
     <para>Pour créer un nouveau fichier, il est possible d'utiliser un assistant. Choisissez <menuchoice><guisubmenu>Fichier</guisubmenu><guisubmenu>Nouveau</guisubmenu><guimenuitem>Fichier</guimenuitem></menuchoice> dans la barre des menus. Cela ouvre la boîte de dialogue « Nouveau fichier ». Choisissez le type de fichier. Saisissez le nom du fichier. L'extension sera automatiquement ajoutée. Vous pouvez ajouter de l'information sur la licence (selon votre choix de licence) et créer un fichier d'en‑tête. Dans le cas d'un fichier d'en-tête C/C++, vous pouvez également ajouter un modèle d'en-tête. Cliquez sur <guibutton>Valider</guibutton> pour créer le fichier. <figure id="new-file-wizard">
       <title>Assistant nouveau fichier</title>
       <screenshot>
        <screeninfo>La boîte de dialogue ouvrir un fichier</screeninfo>
        <graphic fileref="figures/new_file_wizard.png" format="PNG" srccredit="jnoel"/>
       </screenshot>
      </figure></para>
     <para>Il se peut que <application>Anjuta</application> crée si besoin des fenêtres de nouveaux fichiers au cours de certaines opérations. Par exemple, des commandes Subversion telles que <command>Diff</command> et <command>View Log</command> créent des nouvelles fenêtres de fichier et y ajoutent leur sortie. Vous pouvez enregistrer les contenus de ces fenêtres dans de vrais fichiers si vous le désirez.</para>
     </sect2>
     <sect2 id="inserting-macros">
      <title>Insertion de macros</title>
       <para>Vous pouvez utiliser des <emphasis>macros</emphasis> pour saisir rapidement des séquences répétitives de texte.</para>
       <important>
       <para>Le greffon Macro doit être activé.</para>
       </important>
      <sect3 id="inserting">
       <title>Insertion</title>
       <para>Il y a deux types de macros à votre disposition : les macros Anjuta et les macros utilisateur (affichées comme « Mes macros »). Les macros Anjuta ne sont pas modifiables mais vous pouvez définir et modifier vos propres macros utilisateur.</para>
       <para>Pour insérer une macro, déplacez le curseur à l'endroit souhaité. Choisissez <menuchoice><guisubmenu>Édition</guisubmenu><guisubmenu>Macros</guisubmenu><guimenuitem>Macros...</guimenuitem></menuchoice>. Une boîte de dialogue apparaît. Choisissez la macro désirée dans la liste. Le résultat du développement de la macro est affiché dans la fenêtre et un résumé montré dans la boîte de dialogue. Cliquez sur <guibutton>Insérer</guibutton> pour insérer le texte de la macro à la position du curseur.</para>
       <para>Une autre manière d'insérer une macro est de choisir <menuchoice><guisubmenu>Édition</guisubmenu><guisubmenu>Macros</guisubmenu><guimenuitem>Insérer une macro...</guimenuitem></menuchoice>, puis d'utiliser le raccourci clavier de la macro désirée. <figure id="display-macro">
         <title>Macro</title>
          <screenshot>
           <screeninfo>La boîte de dialogue macro</screeninfo>
           <graphic fileref="figures/display_macro.png" format="PNG" srccredit="jnoel"/>
          </screenshot>
        </figure></para>
       </sect3>
       <sect3 id="defining-macro">
        <title>Définition de macros</title>
        <para>Dans la boîte de dialogue « Insérer une macro », cliquez sur <guibutton>Ajouter</guibutton> ou sélectionnez <menuchoice><guisubmenu>Édition</guisubmenu><guisubmenu>Macros</guisubmenu><guimenuitem>Ajouter une macro...</guimenuitem></menuchoice>. La fenêtre « Ajouter ou modifier une macro » apparaît. Saisissez le nom de la macro, choisissez ou définissez une catégorie et associez un raccourci clavier. Puis, saisissez le texte de la macro. Le caractère « | » indique la position du curseur après l'insertion de la macro. Cliquez sur <guibutton>Valider</guibutton>. La macro est ajoutée à la liste.</para>
        <para>Vous pouvez également supprimer une macro en la sélectionnant dans la liste et en cliquant sur <guibutton>Supprimer</guibutton>. Ceci n'est bien sûr possible que pour les macros utilisateurs (Mes macros).</para>
        <para>De la même manière, vous pouvez éditer et modifier une macro en la sélectionnant dans la liste et en cliquant sur le bouton <guibutton>Modifier</guibutton>. <figure id="add-edit-macro">
          <title>Ajouter ou modifier une macro</title>
          <screenshot>
           <screeninfo>La boîte de dialogue ajout/modification</screeninfo>
           <graphic fileref="figures/add_edit_macro.png" format="PNG" srccredit="jnoel"/>
          </screenshot>
         </figure></para>
       </sect3>
       <sect3 id="macro-keyword">
        <title>Mots-clés de macros</title>
        <para>Des mots-clés pour macros sont disponibles. Ils peuvent être incorporés dans des définitions de macro. Ces mots-clés de macros commencent et se terminent par le caractère « @ ».</para>
        <para>Les mots-clés de macro disponibles sont @DATE_TIME@, @DATE_YMD@, @DATE_Y@, @USER_NAME@, @FILE_NAME@, @FILE_NAME_UP@, @FILE_NAME_UP_PREFIX@, @EMAIL@, @TABSIZE@, @INDENTSIZE@ et @USETABS@. <figure id="keyword-macro">
         <title>Mots-clés de macros</title>
          <screenshot>
           <screeninfo>Les mots-clés de macros</screeninfo>
           <graphic fileref="figures/keyword_macro.png" format="PNG" srccredit="jnoel"/>
          </screenshot>
         </figure></para>
      </sect3>
     </sect2>
  </sect1>

 <!-- ============= File operations: Opening and saving files === -->
  <sect1 id="open-save-files">
   <title>Ouverture et enregistrement de fichiers</title>
   <para>
    <orderedlist>
     <listitem>
      <para><emphasis>Ouverture d'un fichier :</emphasis> Pour ouvrir un fichier existant, soit choisissez <menuchoice><guisubmenu>Fichier</guisubmenu><guimenuitem>Ouvrir</guimenuitem></menuchoice> dans la barre de menus, soit cliquez sur le bouton <guibutton>Ouvrir</guibutton> dans la barre d'outils, soit pressez <keycombo><keycap>Ctrl</keycap><keycap>O</keycap></keycombo>. La boîte de dialogue <interface>Ouvrir un fichier</interface> apparaît. <figure id="open-file">
        <title>Boîte de dialogue pour ouvrir un fichier</title>
        <screenshot>
		<screeninfo>La boîte de dialogue ouvrir un fichier</screeninfo>
         <graphic fileref="figures/open_file.png" format="PNG" srccredit="jnoel"/>
        </screenshot>
       </figure> Choisissez ou saisissez le nom du fichier que vous souhaitez ouvrir, puis cliquez sur <guibutton>Ouvrir</guibutton>. Pour ouvrir plus d'un fichier à la fois, sélectionnez les fichiers à ouvrir en maintenant enfoncée la touche <keycap>Ctrl</keycap> et en cliquant sur chacun des fichiers, puis cliquez sur <guibutton>Ouvrir</guibutton>. Si vous changez d'avis, cliquez sur <guibutton>Annuler</guibutton> pour fermer la boîte de dialogue sans ouvrir de fichier.</para>
	  <para>
	   <figure id="open-file-multiple">
        <title>Boîte de dialogue pour ouvrir plusieurs fichiers à la fois</title>
        <screenshot>
		<screeninfo>La boîte de dialogue « Ouvrir un fichier » en mode sélection-multiple</screeninfo>
         <graphic fileref="figures/open_file_multiple.png" format="PNG" srccredit="jnoel"/>
        </screenshot>
       </figure>
	  </para>
	  <para>Vous pouvez activer l'option <emphasis>Afficher les fichiers cachés</emphasis> par l'intermédiaire du menu contextuel qui apparaît lorsque vous faites un clic-droit dans la boîte de dialogue « Ouvrir un fichier ». Cette option rend visibles dans la liste les fichiers cachés (fichiers commençant par « . »). Décochez l'option pour les masquer. La boîte de dialogue « Ouvrir un fichier » intègre également un filtre sur le type des fichiers. Choisissez le filtre approprié au type de fichier dans la boîte de dialogue : la liste des fichiers sera limitée à ceux du type choisi.</para>
     </listitem>
     
     <listitem>
      <para><emphasis>Enregistrement d'un fichier :</emphasis> Pour enregistrer un fichier, soit choisissez <menuchoice><guisubmenu>Fichier</guisubmenu><guimenuitem>Enregistrer</guimenuitem></menuchoice> dans la barre de menus, soit cliquez sur le bouton <guibutton>Enregistrer</guibutton> dans la barre d'outils, soit pressez <keycombo><keycap>Ctrl</keycap><keycap>S</keycap></keycombo>. Le fichier sera enregistré. Si le fichier est nouveau, une boîte de dialogue <interface>Enregistrer le fichier sous</interface> apparaît. Saisissez un nom de fichier et cliquez sur <guibutton>Enregistrer</guibutton> pour enregistrer le nouveau fichier sous le nom indiqué. <screenshot>
	    <screeninfo>Enregistrer le fichier sous</screeninfo>
            <graphic fileref="figures/save_as_file.png" format="PNG" srccredit="jnoel"/>
           </screenshot></para>
	   <note>
	   <title>Sauvegarde automatique des fichiers</title>
		<para>Même si vous avez activé l'enregistrement automatique, Anjuta n'effectuera pas l'opération sur des nouveaux fichiers. Il faut les enregistrer manuellement une première fois. Il en est de même pour l'option <guimenuitem>Tout enregistrer</guimenuitem>. <emphasis>Vous devez enregistrer manuellement un fichier avant que l'enregistrement automatique ou <guimenuitem>Tout enregistrer</guimenuitem> ne s'applique à lui.</emphasis></para>
	   </note>
     </listitem>

     <listitem>
      <para><emphasis>Enregistrement d'un fichier sous un nouveau nom :</emphasis> Vous pouvez explicitement enregistrer un fichier sous un nouveau nom. Pour ce faire, choisissez <menuchoice><guisubmenu>Fichier</guisubmenu><guimenuitem>Enregistrer sous</guimenuitem></menuchoice> dans la barre de menus. Une boîte de dialogue <interface>Enregistrer le fichier sous</interface> apparaît et vous demande de saisir un nom de fichier. Saisissez le nom et cliquez sur <guibutton>Enregistrer</guibutton>.</para>
      <note>
       <title>Écrasement d'un fichier lors d'un enregistrement sous</title>
       <para>Lorsque vous utilisez <guimenuitem>Enregistrer le fichier sous</guimenuitem> avec un nom de fichier existant, l'original n'est pas supprimé. Il reste dans l'état où il était lors de son dernier enregistrement. Si un fichier de ce nom existe déjà, une boîte de dialogue apparaît pour vous demander de confirmer que vous souhaitez bien l'écraser. En cliquant sur <guibutton>Oui</guibutton> vous écrasez le fichier existant avec le fichier en cours d'enregistrement.</para>
      </note>
     </listitem>
     
     <listitem>
      <para><emphasis>Fermeture d'un fichier :</emphasis> Pour fermer un fichier, soit choisissez <menuchoice><guisubmenu>Fichier</guisubmenu><guimenuitem>Fermer</guimenuitem></menuchoice> dans la barre de menus, soit cliquez sur le bouton <guibutton>Fermer</guibutton> dans la barre d'outils (vous pouvez également fermer un fichier en cliquant sur le X dans l'onglet avec son nom de fichier). Cela ferme le fichier courant. Si le fichier n'a pas été enregistré ou si c'est un nouveau fichier, alors <application>Anjuta</application> vous demandera d'enregistrer le fichier avant de le fermer.</para>
     </listitem> 
    </orderedlist>
   </para>
  </sect1>
 
 <!-- ============= File operations: Editing files === -->
  <sect1 id="editing-files">
   <title>Modification des fichiers</title>
   <para><application>Anjuta</application> possède un grand nombre de fonctionnalités qui vous aident à modifier et à travailler avec les fichiers sources. Les paragraphes suivants vous indiquent comment utiliser quelques unes des intéressantes fonctionnalités à votre disposition.</para>
   <sect2 id="editor-margins-sec">
   <title>Marges de l'éditeur</title>
      <para><emphasis>Les marges de l'éditeur :</emphasis> des marges sont ménagées sur la gauche de l'éditeur de texte ; chacune d'entre elles vise un objectif particulier. Trois marges sont disponibles : une pour <emphasis>les numéros de ligne</emphasis>, une pour <emphasis>des marqueurs</emphasis> et une pour <emphasis>des enroulements de code</emphasis>. Par défaut, (i.e. lorsque vous lancez <application>Anjuta</application> pour la première fois) seule la marge des enroulements de code est visible. Les autres peuvent être affichées avec <menuchoice><guimenu>Affichage</guimenu><guisubmenu>Éditeur</guisubmenu></menuchoice>. <figure id="editor-margins">
        <title>Marges de l'éditeur</title>
        <screenshot>
         <screeninfo>La barre d'outils Marqueurs</screeninfo>
         <graphic fileref="figures/editor_margins.png" format="PNG" srccredit="naba"/>
        </screenshot>
       </figure></para>
       <para>La <emphasis>marge des numéros de ligne</emphasis> est la plus grande des trois (et légèrement plus foncée que les autres) ; elle affiche les numéros des lignes du document. La <emphasis>marge des numéros de ligne</emphasis> est affichée/masquée en cochant/décochant <menuchoice><guimenu>Affichage</guimenu><guisubmenu>Éditeur</guisubmenu><guimenuitem>Numéros de ligne en marge</guimenuitem></menuchoice>. Un clic-gauche sur cette marge sélectionne la ligne complète (y compris le caractère de fin de ligne final, s'il existe). Vous pouvez paramétrer les caractéristiques de la police de la marge des numéros de ligne dans les préférences.</para>
	  <para>La <emphasis>marge des marqueurs</emphasis> peut être affichée ou cachée via <menuchoice><guimenu>Affichage</guimenu><guisubmenu>Éditeur</guisubmenu><guimenuitem>Marqueurs en marge</guimenuitem></menuchoice>. Cette marge affiche des icônes pour marquer une ligne donnée. La marge peut afficher des marqueurs de signets (bleus et rectangulaires), des marqueurs de points d'arrêt (rouges et circulaires) et des marqueurs index de ligne (qui ressemblent à une flèche directionnelle jaune). Un marqueur de signet indique une ligne étiquetée ; il peut être affiché ou masqué via <menuchoice><guimenu>Aller à</guimenu><guisubmenu>Signets</guisubmenu><guimenuitem> Basculer le signet</guimenuitem></menuchoice> avec le curseur sur cette ligne. Un marqueur de point d'arrêt est utilisé dans le débogueur pour indiquer un point d'arrêt de débogage (consultez le chapitre Débogage pour plus d'informations). Le marqueur indicateur de ligne s'utilise pour indiquer la position actuelle dans le programme lors du débogage.</para>
       <para>La <emphasis>marge des enroulements de code</emphasis> est l'endroit où s'affiche l'arborescence des enroulements. En cliquant sur les nœuds de l'arborescence, vous masquez ou affichez des blocs de code. Un symbole souligné est dessiné sous une ligne enroulée pour bien mettre en évidence la présence d'un bloc de code enroulé sous la ligne. Pour plus de détails sur l'enroulement de code, consultez le paragraphe <emphasis>Enroulement de code</emphasis> ci-dessous.</para>
       <note>
       <title>Marqueur invisible en marge</title>
        <para>Si le marqueur en marge n'est pas visible, Anjuta affiche les marqueurs en modifiant la couleur d'arrière-plan d'une ligne. Par exemple, si un marqueur de point d'arrêt est positionné sur une ligne et que le marqueur en marge n'est pas visible, cette ligne sera affichée avec un arrière-plan rouge. De même pour les marqueurs de signets et l'index de ligne, les arrières-plans seront respectivement bleu ciel et jaune. Si vous n'appréciez pas cela (peut-être à cause du contraste de votre thème), activez la marge des marqueurs via <menuchoice><guimenu>Affichage</guimenu><guisubmenu>Éditeur</guisubmenu><guimenuitem>Marqueurs en marge</guimenuitem></menuchoice>. <figure id="editor-markers">
          <title>Marqueurs de l'éditeur lorsque les marqueurs en marge sont invisibles</title>
          <screenshot>
           <screeninfo>La barre d'outils Marqueurs</screeninfo>
           <graphic fileref="figures/editor_markers.png" format="PNG" srccredit="naba"/>
          </screenshot>
         </figure></para>
       </note>
      </sect2>
      <sect2 id="editor-guides-sec">
      <title>Guides de l'éditeur</title>
      <para>L'éditeur peut être configuré pour afficher certaines informations habituellement invisibles sur le document : les <emphasis>guides d'indentation</emphasis>, les <emphasis>espaces blancs</emphasis> et les <emphasis>caractères de fin de ligne</emphasis>. Ces informations sont rendues visibles ou invisibles en cochant ou pas les éléments de menu correspondants dans <menuchoice><guimenu>Affichage</guimenu><guisubmenu>Éditeur</guisubmenu></menuchoice>. Les guides d'indentation sont de petites lignes en pointillé reliant les accolades correspondantes dans le code source. Lorsque le curseur est sur une accolade, son guide d'indentation est mis en surbrillance pour mettre visuellement en valeur le niveau d'indentation.</para>
       <figure id="editor-guides">
        <title>Éditeur avec guides</title>
        <screenshot>
         <screeninfo>Éditeur avec guides</screeninfo>
         <graphic fileref="figures/editor_guides.png" format="PNG" srccredit="naba"/>
        </screenshot>
      </figure>
    </sect2>
   <sect2 id="highlighting">
   <title>Coloration syntaxique</title>
   <para><application>Anjuta</application> sait faire de la coloration syntaxique pour nombre de divers langages. Normalement, cette opération est automatique, le type du fichier étant défini par son extension. Si <application>Anjuta</application> ne sait pas déterminer le type de fichier, il n'y a pas coloration syntaxique. Vous pouvez forcer explicitement un style de coloration particulier en sélectionnant le style dans le menu <menuchoice><guimenu>Affichage</guimenu><guisubmenu>Éditeur</guisubmenu><guisubmenu> Coloration syntaxique</guisubmenu></menuchoice>.</para>
    <note>
     <para>Anjuta utilise un fichier de propriétés nommé <filename>$prefix/share/anjuta/properties/anjuta.properties</filename>, de même format qu'un fichier de propriétés SciTE mais sans les utiliser toutes. Le style de chaque élément pour chacun des langages est défini dans un fichier nommé <filename>$prefix/share/anjuta/properties/styles.properties</filename>. Il utilise quelques propriétés communes définies par Anjuta dans le fichier <filename>$home/.config/anjuta/scintilla/editor-style.properties</filename>.</para>
   </note>
   </sect2>
   <sect2 id="codefolding">
    <title>Enroulement de code</title>
    <para>Anjuta peut afficher les fichiers sources des langages structurés par blocs (tels que C, C++, Pascal et Java) avec des <emphasis>enroulements de code</emphasis>. Tous les blocs de code d'un fichier source sont enroulés ou déroulés en cliquant sur les points d'enroulement dans la marge des enroulements de code de la fenêtre <interface>Éditeur</interface> (habituellement un symbole +/- ou une flèche vers le haut/bas). Ces points d'enroulement apparaissent automatiquement pour les fichiers source qui utilisent des blocs de code.</para>
    <para>L'enroulement du code est particulièrement utile lors de l'édition de grands fichiers source contenant des milliers de lignes. Une fois le code enroulé, le document apparaît condensé, facilitant le parcours et l'édition du fichier.</para>
    <note>
     <para>Veuillez noter que les enroulements de code et les guides d'édition ne sont disponibles qu'avec l'éditeur fondé sur Scintilla.</para>
	</note>
   </sect2>
   <sect2 id="autoformat">
    <title>Mise en forme automatique du code source</title>
    <para>Anjuta peut indenter automatiquement (mise en forme automatique) les fichiers d'en-tête ou les sources C ou C++. Les indentations donnent un aspect clair au code source, augmentent la lisibilité, réduisent la probabilité d'erreurs de syntaxe et surtout font gagner du temps. Pour indenter automatiquement le fichier source en cours, choisissez <menuchoice><guimenu>Édition</guimenu><guimenuitem>Indentation automatique</guimenuitem></menuchoice> dans la barre de menu. Vous pouvez modifier le style de format en personnalisant vos choix dans les préférences.</para>
   </sect2>
  </sect1>

 <!-- ============= File operations: Browsing with the tags browser ===   -->
  <sect1 id="browsing-files">
   <title>Analyseur de symboles</title>
   <para>Vous pouvez parcourir les fichiers source C, C++ et d'en-tête en utilisant les <emphasis>étiquettes</emphasis> des fichiers. Une étiquette (ou <emphasis>symbole</emphasis>) fait référence à une entité nommée telle une définition de fonction, une structure ou une macro. Anjuta scrute les étiquettes disponibles dans les fichiers source C, C++ et d'en-tête ouverts.</para>
   <para><application>Anjuta</application> scrute automatiquement les étiquettes dans tous les fichiers source et d'en-tête des projets ouverts. Vous pouvez aller à n'importe quelle définition de fonction, de structure, de classe ou autres étiquettes sans avoir à ouvrir expressément le fichier la contenant. Vous n'avez même pas besoin de savoir dans quel fichier se trouve l'étiquette. L'afficheur de symboles donne la liste de tous les symboles disponibles dans le projet. <figure id="symbol-browser">
     <title>Parcourir les symboles</title>
     <screenshot>
      <screeninfo>Parcourir les symboles</screeninfo>
      <graphic fileref="figures/symbol_browser.png" format="PNG" srccredit="jhs"/>
     </screenshot>
    </figure></para>
   <tip>
    <title>Synchronisation des étiquettes</title>
    <para>Vous n'avez pas à vous préoccuper de la synchronisation ou de la mise à jour de la base de données des étiquettes. <application>Anjuta</application> se charge de tout. Vous avez juste à décider à quelle étiquette vous désirez vous rendre !</para>
   </tip>
   
  </sect1>

  <!-- ============= File operations: Searching and replacing in files === -->
  <sect1 id="search-replace-files">
   <title>Recherche et remplacement de texte dans les fichiers</title>
    <sect2 id="searching">
    <title>Recherche</title>
      <para>Pour rechercher une <emphasis>chaîne</emphasis> ou une <emphasis>expression régulière</emphasis> dans le fichier en cours, choisissez <menuchoice><guimenu>Édition</guimenu><guisubmenu>Rechercher</guisubmenu><guimenuitem>Rechercher...</guimenuitem></menuchoice> ou pressez <keycombo><keycap>Ctrl</keycap><keycap>Alt</keycap><keycap>F</keycap></keycombo> pour ouvrir la boîte de dialogue <interface>Rechercher et remplacer</interface>.</para>
      <para>Utilisez la zone de saisie pour indiquer la chaîne à rechercher et indiquez s'il s'agit d'une chaîne normale ou d'une expression régulière. Vous pouvez également indiquer la direction, la sensibilité à la casse ou pas et la portée de la recherche. Cliquez sur <guibutton>Rechercher</guibutton> pour lancer la recherche.</para>
      <para>Si la recherche est fructueuse, Anjuta se rend au texte correspondant ou réalise une autre action (selon l'<guilabel>action de recherche</guilabel> choisie dans l'onglet <guilabel>Cible de la recherche</guilabel>). Si la recherche est infructueuse, Anjuta affiche un message indiquant que le texte recherché n'a pas été trouvé.</para>
      <para>Si vous voulez poursuivre la recherche, cliquez à nouveau sur le bouton <guibutton>Rechercher</guibutton> ou pressez <keycombo><keycap>Ctrl</keycap><keycap>G</keycap></keycombo> pour rechercher la correspondance suivante (utilisez <keycombo><keycap>Maj</keycap><keycap>Ctrl</keycap><keycap>G</keycap></keycombo> pour la correspondance précédente). Vous pouvez même modifier le texte à rechercher au cours de l'opération : saisissez la nouvelle chaîne dans la zone de texte <guilabel>Rechercher l'expression</guilabel> de la boîte de dialogue de recherche.</para>
      <figure id="search-expr">
      <title>Boîte de dialogue de recherche de texte</title>
        <screenshot>
        <graphic fileref="figures/search_expr.png" format="PNG" srccredit="jhs"/>
        </screenshot>
      </figure>
	  <para>Pour mettre fin à une longue recherche, appuyez sur le bouton <guibutton>Arrêter</guibutton>.</para>
    </sect2>
    <sect2 id="search-range">
    <title>Définition de la portée de la recherche</title>
      <para>Dans l'onglet <interface>Cible de la recherche</interface>, définissez la portée de la recherche et l'action à réaliser en cas de recherche fructueuse.</para>
      <para>Vous pouvez définir le nombre maximum d'actions à réaliser.</para>
      <figure id="search-target">
      <title>Boîte de dialogue cible de la recherche</title>
        <screenshot>
        <graphic fileref="figures/search_target.png" format="PNG" srccredit="jhs"/>
        </screenshot>
      </figure>
      <para>Vous pouvez choisir l'emplacement de la recherche.</para>
      <figure id="search-target-in">
      <title>Choix de l'emplacement de la cible de la recherche</title>
       <screenshot>
       <graphic fileref="figures/search_target_in.png" format="PNG" srccredit="jhs"/>
       </screenshot>
      </figure>
      <sect3 id="search-file">
      <title>Recherche dans des fichiers</title>
       <para>Pour rechercher du texte dans le projet, définissez la valeur de <guilabel>Rechercher dans</guilabel> à « Tous les fichiers du projet ».</para>
       <para>Dans l'onglet <guilabel>Recherche d'expression</guilabel>, saisissez le texte à rechercher et indiquez vos options de recherche, telles que les options <guilabel>Respecter la casse</guilabel> ou <guilabel>Correspondance sur les mots entiers</guilabel>. Cliquez sur <guibutton>Rechercher</guibutton> pour lancer la recherche.</para>
       <para>Pour rechercher du texte dans un ensemble de fichiers, définissez la valeur de <guilabel>Rechercher dans</guilabel> à « Indiquez les motifs de fichiers ». Paramétrez la recherche et cliquez sur <guibutton>Rechercher</guibutton> pour la lancer.</para>	 
         <figure id="search-file-pattern">
         <title>Recherche dans des types de fichiers donnés</title>
          <screenshot>
          <graphic fileref="figures/search_file_pattern.png" format="PNG" srccredit="jhs"/>
          </screenshot>
       </figure>

      </sect3>		 

	</sect2>
    <sect2 id="search-action">
    <title>Spécification d'une action de recherche</title>
      <para>Vous pouvez choisir l'action à réaliser lorsqu'une recherche aboutit.</para>
      <para>Selon les choix précédents (<guilabel>Recherche dans</guilabel>, <guilabel>Direction de recherche</guilabel>, etc.), il se peut que certaines actions ne soient pas disponibles.</para>
      <figure id="search-target-action">
      <title>Choix de l'action sur la cible de la recherche</title>
       <screenshot>
       <graphic fileref="figures/search_target_action.png" format="PNG" srccredit="jhs"/>
       </screenshot>
      </figure>
  
    </sect2>
    <sect2 id="replacing">
    <title>Remplacement</title>
      <para>« Rechercher et remplacer » se fait de manière similaire à une simple recherche de texte, excepté le fait que vous devez également indiquer un texte de remplacement dans la zone de saisie <guilabel>Remplacer par</guilabel> ; vous préciserez également si vous désirez ou pas être consulté avant chaque remplacement (« Remplacer la prochaine correspondance » ou « Remplacer toutes les correspondances »).</para>
      <figure id="replace">
      <title>Remplacement</title>
        <screenshot>
        <graphic fileref="figures/search_replace.png" format="PNG" srccredit="jhs"/>
        </screenshot>
      </figure>
	  <para>Choisissez <guibutton>Remplacer</guibutton> pour remplacer le texte correspondant ou <guibutton>Rechercher</guibutton> pour aller à la correspondance suivante.</para>

	</sect2>
    <sect2 id="search-setting">
    <title>Paramètres de la recherche</title>
      <para>Vous pouvez également enregistrer des options de recherche.</para>
      <para>L'élément en surbrillance rouge est l'élément actif. L'élément par défaut indique les paramètres de recherche chargés lorsque Anjuta démarre.</para>
      <figure id="search-setting-fig">
      <title>Boîte de dialogue des paramètres de la recherche</title>
        <screenshot>
        <graphic fileref="figures/search_setting.png" format="PNG" srccredit="jhs"/>
        </screenshot>
       </figure>
    </sect2>

  </sect1>

 <!-- ============= File operations: Printing Files === -->
   <sect1 id="printing">
    <title>Impression d'un fichier</title>
    <para>Vous pouvez afficher un aperçu avant impression en choisissant <menuchoice><guisubmenu>Fichier</guisubmenu><guimenuitem>Aperçu avant impression</guimenuitem></menuchoice>. L'aperçu d'impression affiché correspond au traitement du fichier actuel. La mise en valeur du code source dans l'éditeur est conservée à l'identique dans l'aperçu (et l'impression qui en découle). L'onglet <guilabel>Impression</guilabel> des préférences relatives au greffon de l'éditeur contient des options supplémentaires : elles vous permettent d'imprimer les numéros de ligne, d'activer la césure des lignes et/ou d'ajouter un en-tête de page. <figure>
       <title>Aperçu avant impression d'un fichier C</title>
       <screenshot>
       <screeninfo>Aperçu avant impression</screeninfo>
        <graphic fileref="figures/print_preview.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure></para> 
    <para>
	 <figure>
       <title>Préférences de l'impression</title>
       <screenshot>
	   <screeninfo>Préférences de l'impression</screeninfo>
        <graphic fileref="figures/prefs_print.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
	</para>
	<para>Si, satisfait de l'aperçu, vous êtes prêt à lancer l'impression, choisissez <menuchoice><guisubmenu>Fichier</guisubmenu><guimenuitem>Imprimer</guimenuitem></menuchoice> ou <guibutton>Imprimer</guibutton> dans la fenêtre de l'aperçu pour afficher la boîte de dialogue d'impression montrée ci-dessous. Sélectionnez les paramètres d'imprimante appropriés et cliquez sur <guibutton>Imprimer</guibutton> pour imprimer le fichier.</para>
	<para>Vous pouvez également choisir une orientation paysage ou portrait pour la page, la taille du papier, l'impression recto-verso et le type de papier. Faites les réglages correspondant à votre type d'imprimante, sinon il se pourrait que l'impression ne soit pas correcte.</para>
	<para>
	 <figure>
       <title>Boîte de dialogue impression</title>
       <screenshot>
	   <screeninfo>Boîte de dialogue impression</screeninfo>
        <graphic fileref="figures/print_dlg.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
	</para>
   </sect1>
 </chapter>


 <!-- Project Management -->
 <!-- ============= Project management ====================== -->
 <chapter id="project-management">
  <title>Gestion de projet</title>
  
  <para>Anjuta possède un puissant greffon de gestion de projet, greffon capable d'ouvrir la plupart des projets basés sur <ulink type="info" url="info:automake">automake/autoconf</ulink>. Il se peut qu'il échoue pour certains projets configurés de manière exotique, mais si le projet utilise automake/autoconf de manière standard, cela devrait fonctionner.</para>

  <para>Le côté élégant de la chose est que Anjuta n'enregistre dans la structure du projet aucune information supplémentaire par rapport à celle déjà existante. Autrement dit : il n'y a aucune donnée de projet gérée séparément par Anjuta et tout le traitement du projet s'effectue directement dans sa structure. Il est donc possible de maintenir ou de développer un projet en dehors de Anjuta sans avoir à le convertir d'un ou vers un format spécifique à Anjuta. Puisque les projets Anjuta ne sont techniquement que des projets automake, un développement mixte (à la fois avec et sans utilisation de Anjuta ) ou des allers-retours entre Anjuta et d'autres outils sont possibles sans aucune interférence.</para>

  <sect1 id="new-project">
   <title>Création d'un nouveau projet</title>
   <sect2 id="new-project-from-template">
   <title>Création d'un projet à partir d'un modèle</title>
   <para>Le greffon assistant de projet utilise un puissant outil de génération de modèles appelé <application>autogen</application>. Tous les nouveaux projets sont créés à partir de modèles écrits en utilisant la syntaxe <application>autogen</application>. L'assistant de projet vous permet de créer de nouveaux projets à partir d'un choix parmi des modèles de projet. La sélection se fait parmi des projets simples génériques, plats (sans sous-dossier), GTK+, GNOME, Java, Python, etc. De nouveaux modèles peuvent être facilement téléchargés et installés puisque chaque modèle n'est qu'une collection de fichiers textes.</para>

   <para>Pour créer un projet, choisissez l'élément de menu <menuchoice><guisubmenu>Fichier</guisubmenu><guisubmenu>Nouveau</guisubmenu><guimenuitem>Projet</guimenuitem></menuchoice> pour lancer l'assistant d'application. Lisez attentivement la première page. Cliquez sur <guibutton>Suivant</guibutton> pour poursuivre.</para>
   <para>À la deuxième page, choisissez le type d'application à créer. Cliquez sur <guibutton>Suivant</guibutton> pour poursuivre.</para>

   <para>Aux pages suivantes, saisissez les informations nécessaires pour le projet. Vous pourrez modifier ces réglages plus tard, mais il est conseillé de les définir correctement dès le départ afin de conserver l'intégrité du projet. L'espace ou tout caractère non-alphanumérique, sauf le souligné (_) et le tiret (-), est interdit dans la plupart des zones de saisie de texte qui suivent (sauf peut-être la zone <guilabel>Auteur</guilabel>).</para>

   <para>Vous indiquerez également si le projet doit gérer l'<emphasis>internationalisation</emphasis> en utilisant <application>gettext</application> (consultez <ulink type="info" url="info:gettext">la page d'information sur gettext</ulink> pour plus de détails). Cette fonctionnalité construit un projet plurilingue avec prise en charge de diverses langues telles que anglais, français et néerlandais. Les autres options servent à paramétrer, en début de chaque fichier, l'insertion ou non du commentaire sur le statut du copyright GNU et à activer des informations dans le menu du bureau GNOME si nécessaire. La prise en charge des bibliothèques partagées vous permet d'ajouter les modules correspondants plus tard. Si vous prévoyez d'utiliser des bibliothèques dans votre projet, il est bon de l'activer. Selon le type de projet créé, il se peut que Anjuta demande des informations supplémentaires.</para>

   <para>La dernière étape consiste à vérifier les informations fournies. Cliquez sur <guibutton>Terminer</guibutton> pour lancer la génération du projet.</para>

   <para>Une fois le projet généré, vous pouvez l'essayer en le construisant et en l'exécutant.</para>
  </sect2>
   <sect2 id="importing-project">
    <title>Importation de projets</title>
    <para>La fonction d'importation de projets s'utilise pour importer un projet existant en le convertissant en projet <application>Anjuta</application>. Lancez l'assistant d'importation de projet avec <menuchoice><guimenu>Fichier</guimenu><guimenu>Nouveau</guimenu><guimenuitem>Projet basé sur des sources existantes</guimenuitem></menuchoice> et suivez les instructions de l'assistant. Une fois importé, le projet peut ensuite être ouvert dans <application>Anjuta</application> comme tout autre projet <application>Anjuta</application>.</para>
	<note>
	<para>La fonction d'importation de projet ne fonctionne correctement que si le projet existant utilise <ulink type="info" url="info:automake">autoconf/automake</ulink> ou, à l'extrême limite, un fichier Makefile brut.</para>
	</note>
   </sect2>
  </sect1>
  
  <sect1 id="load-save-projects">
   <title>Chargement et enregistrement de projets</title>
   <sect2 id="loading-project">
    <title>Chargement de projets</title>
    <para>Pour ouvrir un projet, choisissez l'élément de menu <menuchoice><guisubmenu>Fichier</guisubmenu><guimenuitem>Ouvrir…</guimenuitem></menuchoice>. Choisissez le fichier projet (<filename>*.anjuta</filename>) dans la boîte de dialogue et cliquez sur <guibutton>Ouvrir</guibutton>.</para> 

    <para>Si le projet a récemment été ouvert, il sera alors listé dans le menu <menuchoice><guisubmenu>Fichier</guisubmenu><guisubmenu>Ouvrir un document récent</guisubmenu></menuchoice>. Choisissez le nom du fichier projet dans la liste pour l'ouvrir.</para>
    <para>Dès que le projet est ouvert, <application>Anjuta</application> se place en <emphasis>mode projet</emphasis>. La fenêtre projet comporte trois volets. Le premier est le volet Projet qui énumère les fichiers du projet classés par type. Le second est l'analyseur de symboles dont il a été question à la section <emphasis>Analyseur de symboles</emphasis>. Le troisième liste les fichiers du projet de manière plus ou moins semblable à un mini explorateur de fichiers. Dans le volet Fichiers, tous les fichiers faisant partie de l'arborescence du projet sont visibles. Un clic droit sur l'un des fichiers fait apparaître un menu contextuel d'opérations sur ces fichiers.</para>
    <para>Également, si le projet est une structure CVS, les numéros correspondant aux révisions du fichier seront affichés à droite du nom dans le volet d'affichage des fichiers.</para>
   </sect2>
   <sect2 id="saving-project">
    <title>Enregistrement de projets</title>
    <para>Le projet est automatiquement enregistré quand vous le fermez étant donné que toutes les modifications sont réalisées directement dans la structure du projet.</para>
   </sect2>
  </sect1>

  <sect1 id="projects-structure">
  <title>Structure du projet</title>
  <para>Voici la <interface>fenêtre Projet</interface> avec son menu contextuel (accessible par un clic droit). <figure id="project-window">
    <title>Fenêtre Projet</title>
    <screenshot>
     <screeninfo>La fenêtre projet</screeninfo>
     <graphic fileref="figures/project-window.png" format="PNG" srccredit="jhs"/>
    </screenshot>
   </figure></para>
  <para>La <interface>fenêtre projet</interface> affiche la hiérarchie <ulink type="info" url="info:automake"><application>automake</application></ulink> du projet organisée en <emphasis>groupes</emphasis> de <emphasis>cibles</emphasis>. Les groupes correspondent aux répertoires du projet et les cibles aux cibles normales d'<application>automake</application> (à ne pas confondre avec les cibles make). La <interface>fenêtre Projet</interface> possède en fait deux parties : la partie basse affiche la hiérarchie complète du projet alors que la partie haute liste directement les cibles importantes. Les cibles importantes comprennent celle des exécutables et celle des bibliothèques ; cette vue les rend accessibles facilement. Cette disposition est utile particulièrement dans le cas de gros projets pour lesquels la hiérarchie peut être profonde et difficile à parcourir à partir de l'arborescence seule. Les cibles sont, à leur tour, composées de fichiers sources.</para>

  <para>
  <itemizedlist>
   <listitem>
    <para>Les <emphasis>groupes</emphasis> s'utilisent pour organiser les cibles de manière logique. Un projet peut contenir un nombre quelconque de groupes. Chaque groupe peut posséder des sous-groupes et également des cibles. Dans les projets automake, les groupes ne sont que des sous-répertoires du projet. Le groupe de plus haut niveau est toujours désigné par « / ».</para>
   </listitem>
   <listitem>
    <para>Les <emphasis>cibles</emphasis> sont les cibles construites dans le projet, telles que programmes (binaires exécutables), scripts, bibliothèques et données diverses. Toutes les cibles ne sont pas construites à partir de sources, certaines existent uniquement pour organiser les sources ; par conséquent elles peuvent ne pas exister physiquement (par ex. une cible de données diverses). Les cibles font partie des groupes. Consultez <link linkend="adding-target">« Ajout de cibles »</link> pour obtenir une liste complète des types de cibles disponibles.</para>
   </listitem>
   <listitem>
    <para>Les <emphasis>fichiers source</emphasis> peuvent être utilisés pour construire des cibles, quoique certains fichiers sources ne soient que relatifs aux cibles. Ils n'existent que dans des cibles. Beaucoup de cibles demandent des types bien définis de fichiers source (par ex. les types de cible Programmes et Bibliothèques), mais certains acceptent n'importe quels fichiers (par ex. une cible Données Diverses).</para>
   </listitem>
  </itemizedlist>
  </para>

  <para>Chaque groupe et cible du projet peut être configuré dans la manière standard <application>automake</application>. Vous pouvez paramétrer les drapeaux du compilateur et de l'éditeur de liens directement pour chaque cible ou préciser des options utilisateur pour <application>configure</application>. Les groupes vous permettent de définir une destination d'installation pour leurs cibles.</para>

  <para>Tout comme le gestionnaire de fichiers, la vue du gestionnaire de projets dispose également d'actions de commodité (accessibles à partir du menu contextuel) pour les fichiers sources et les cibles.</para>

  <para>De nombreux outils en ligne de commande sont disponibles pour maintenir et gérer un projet ; chaque outil possède ses règles et possibilités propres. <application>Anjuta</application> essaye d'automatiser la plupart des opérations courantes en utilisant des greffons. Cependant, il se peut qu'à l'occasion vous ayez quand même besoin de réaliser certaines opérations manuellement.</para>
  
  <para>Vous pouvez modifier une structure de projet en utilisant un outil externe ou en modifiant à la main des fichiers du projet. Que le projet soit chargé ou pas dans <application>Anjuta</application> n'a pas d'importance. <application>Anjuta</application> se mettra à jour en tenant compte de toutes les modifications externes effectuées sur le projet.</para>
  </sect1>
 
  <sect1 id="groups-and-targets">
   <title>Groupes et cibles</title>

   <sect2 id="adding-groups">
    <title>Ajout de groupes</title>
    <para>Pour ajouter un nouveau groupe (qui est un dossier dans les projets fondés sur automake) : <itemizedlist>
         <listitem>
           <para>choisissez <menuchoice><guisubmenu>Projet</guisubmenu><guimenuitem>Ajouter un groupe</guimenuitem></menuchoice> pour faire apparaître la boîte de dialogue « Nouveau groupe »,</para>
         </listitem>
         <listitem>
           <para>choisissez le groupe dans lequel vous voulez ajouter un nouveau groupe,</para>
         </listitem>
         <listitem>
            <para>saisissez le nom du nouveau groupe et cliquez sur <guibutton>Ajouter</guibutton>.</para>
         </listitem>
        </itemizedlist></para>
     <para>Avec les projets automake, un nouveau dossier portant le nom indiqué est créé dans le répertoire du groupe parent.</para>
    <para>Vous pouvez également ajouter un nouveau groupe directement à partir de la fenêtre <interface>Projet</interface>. Faites un clic droit sur le groupe dans lequel vous voulez ajouter un nouveau groupe, puis choisissez <guimenuitem>Ajouter un groupe</guimenuitem> dans le menu contextuel.</para>
   </sect2>

   <sect2 id="removing-group">
    <title>Suppression de groupes</title>
    <para>Pour supprimer un groupe : <itemizedlist>
     <listitem>
       <para>faites un clic droit sur le groupe dans la vue du <interface>gestionnaire de projet</interface>,</para>
     </listitem>
     <listitem>
       <para>choisissez <guimenuitem>Retirer</guimenuitem> dans le menu contextuel.</para>
     </listitem>
    </itemizedlist></para>
    <para>La cible et les sources associées à ce groupe sont ainsi retirées du projet (elles ne sont pas pour autant supprimées du système de fichiers ; vous pourrez les rajouter au projet plus tard si vous le souhaitez).</para>
   </sect2>

   <sect2 id="adding-target">
    <title>Ajout de cibles</title>
    <para>Pour ajouter une nouvelle cible : <itemizedlist>
      <listitem>
       <para>choisissez <menuchoice><guisubmenu>Projet</guisubmenu><guimenuitem>Ajouter une cible</guimenuitem></menuchoice> pour faire apparaître la boîte de dialogue « Nouvelle cible »,</para>
     </listitem>
     <listitem>
      <para>choisissez le groupe dans lequel vous voulez ajouter la cible,</para>
     </listitem>
     <listitem>
      <para>sélectionnez le type de cible,</para>
     </listitem>
     <listitem>
      <para>saisissez le nom de la nouvelle cible et cliquez sur <guibutton>Ajouter</guibutton>.</para>
     </listitem>
    </itemizedlist></para>
    <para>Vous pouvez aussi ajouter une nouvelle cible directement à partir de la fenêtre <interface>Projet</interface>. Faites un clic droit sur le groupe dans lequel vous voulez ajouter la cible, puis choisissez <guimenuitem>Ajouter une cible</guimenuitem> dans le menu contextuel.</para>
    <para>Les noms des cibles doivent normalement avoir des préfixes et des suffixes normalisés selon le type de la cible. Anjuta vous prévient si un nom n'est pas valide et il se peut qu'il vous suggère un exemple de nom valide.</para>
    <para>Voici les différents types de cibles pour des projets automake : <itemizedlist>
     <listitem>
      <para><emphasis>Programme</emphasis> pour les binaires exécutables. Choisissez ce type pour ajouter un exécutable au projet. Par défaut, toutes les cibles programmes sont installées dans le répertoire standard des exécutables, par ex. /usr/bin ou /usr/local/bin. Vous pouvez modifier ce comportement en indiquant un autre dossier d'installation dans les propriétés du groupe contenant la cible.</para>
     </listitem>
     <listitem>
      <para><emphasis>Bibliothèque partagée</emphasis> pour les bibliothèques partagées ou dynamiques. Choisissez ce type si vous ajoutez une bibliothèque partagée au projet. Par défaut, toutes les bibliothèques partagées sont installées dans le répertoire standard des bibliothèques, par ex. /usr/lib ou /usr/local/lib. Vous pouvez modifier ce comportement en indiquant un répertoire d'installation différent dans les propriétés du groupe contenant la cible.</para>
     </listitem>
     <listitem>
      <para><emphasis>Bibliothèque statique</emphasis> pour les bibliothèques statiques. Choisissez ce type si vous ajoutez une bibliothèque statique au projet. Par défaut, toutes les bibliothèques statiques sont installées dans le répertoire standard des bibliothèques, par ex. /usr/lib ou /usr/local/lib. Vous pouvez modifier ce comportement en indiquant un autre répertoire d'installation dans les propriétés du groupe contenant la cible.</para>
     </listitem>
     <listitem>
      <para><emphasis>Module Java</emphasis> pour les modules Java. Choisissez ce type si vous regroupez des sources Java dans un module. Pour ce type de cible vous devez préciser un répertoire d'installation dans lequel les fichiers .class seront placés. Le nom du répertoire est à définir dans les propriétés du groupe contenant la cible.</para>
      <note>
       <para>Il ne peut y avoir qu'un seul module Java par groupe. Il s'agit d'une restriction imposée par automake. Veuillez lire la page d'information sur automake pour plus de détails.</para>
      </note>
     </listitem>
     <listitem>
      <para><emphasis>Module Python</emphasis> pour des modules Python. Choisissez ce type si vous regroupez des sources Python dans un module. Pour ce type de cible vous devez préciser le répertoire d'installation dans lequel les fichiers sources seront installés. Le nom du répertoire est à définir dans les propriétés du groupe contenant la cible.</para>
     </listitem>
     <listitem>
      <para><emphasis>Scripts</emphasis> pour regrouper des scripts. Ils seront installés dans le répertoire standard des exécutables.</para>
     </listitem>
     <listitem>
      <para><emphasis>Données diverses</emphasis> pour regrouper de simples fichiers dans un projet. Vous devez préciser un répertoire d'installation dans les propriétés du groupe.</para>
     </listitem>
     <listitem>
      <para><emphasis>Fichiers d'en-tête</emphasis> pour regrouper les fichiers d'en-tête C/C++ à installer sur un système (par exemple ceux faisant partie d'une bibliothèque d'API). Pour les fichiers d'en-tête qui n'ont pas besoin d'être installés, placez-les dans la cible Programme parmi les fichiers sources. Les fichiers d'en-tête seront installées dans le répertoire standard « include » à moins qu'un autre chemin d'installation n'ait été précisé dans les propriétés du groupe.</para>
     </listitem>
     <listitem>
      <para><emphasis>Documentation Man</emphasis> et <emphasis>Documentation Info</emphasis> pour regrouper respectivement les documentations man et info. Par défaut, les fichiers de documentation sont placés dans les répertoires standard d'installation.</para>
     </listitem>
    </itemizedlist></para>
   </sect2>
   <sect2 id="removing-target">
    <title>Suppression de cibles</title>
    <para>Pour supprimer une cible : <itemizedlist>
       <listitem>
        <para>faites un clic droit sur la cible dans le volet du <interface>Projet</interface>,</para>
       </listitem>
       <listitem>
        <para>choisissez <guimenuitem>Retirer</guimenuitem> dans le menu contextuel.</para>
       </listitem>
      </itemizedlist></para>
    <para>Les sources associées aux cibles sont également retirées du projet (elles ne sont pas pour autant supprimées du système de fichiers).</para>
   </sect2>
  </sect1>

  <sect1 id="adding-removing-sources">
   <title>Ajout et retrait de fichiers</title>
   <sect2 id="adding-sources">
    <title>Ajout de fichiers source</title>
    <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Projet</guisubmenu><guimenuitem>Ajouter un fichier source...</guimenuitem></menuchoice>. Dans la boîte de dialogue, choisissez la cible dans laquelle le fichier doit être ajouté et le fichier lui-même. Vous pouvez ajouter plusieurs fichiers à la fois. Pour cela, sélectionnez plusieurs fichiers dans la boîte de dialogue en utilisant, soit la touche <keycap>Maj</keycap>, soit la touche <keycap>Ctrl</keycap>, puis cliquez sur <guibutton>Ajouter</guibutton> pour joindre les fichiers au projet.</para>
    <para>Dans la boîte de dialogue, le fichier actif dans l'éditeur est présélectionné par défaut pour ajout. Une autre méthode pratique pour ajouter un fichier consiste à faire un clic droit sur celui-ci dans le volet <interface>Fichiers</interface> et à choisir <guimenuitem>Ajouter au projet</guimenuitem> dans le menu contextuel.</para>
    <para>Si le fichier choisi fait déjà partie du projet, <application>Anjuta</application> ne le rajoute pas et vous prévient que le fichier a déjà été incorporé.</para>
    <para>Si le fichier choisi n'est pas dans le répertoire du projet, vous devrez confirmer que vous acceptez qu'une copie du fichier soit déposée dans le dossier cible. <application>Anjuta</application> ne peut pas ajouter des fichiers hors du répertoire projet sans les y copier au préalable.</para>
   </sect2>
   <sect2 id="removing-sources">
    <title>Retrait de fichiers source</title>
    <para>Pour retirer un fichier du projet, faites un clic droit sur le fichier à retirer dans le volet <interface>Projet</interface> et choisissez <guimenuitem>Retirer</guimenuitem> dans le menu contextuel.</para>
    <para>Un boite de dialogue de confirmation apparaît et le fichier est retiré du projet.</para>
    <important>
     <title>Le fichier n'est pas détruit !</title>
     <para>Le fichier n'est pas supprimé du système de fichiers. Il existe toujours ; vous pourrez le rajouter au projet si vous le souhaitez. Le fichier est seulement retiré de la liste du projet et il ne prendra part à aucune opération du projet telle que compilation, construction ou distribution.</para>
     </important>
   </sect2>
  </sect1>
  
  <sect1 id="project-config">
   <title>Configuration du projet</title>
   <para>La configuration du projet présuppose le paramétrage correct des drapeaux de construction pour les cibles, les groupes et pour le projet lui-même. Vous pouvez configurer ces drapeaux dans les boîtes de dialogue respectives concernant les propriétés.</para>

   <para>Vous pouvez utiliser sans restriction les variables autoconf et automake automatiquement définies pour le projet lors de la configuration. Outre ces variables, vous pouvez également définir vos propres variables dans <link linkend="project-properties">Propriétés du projet</link> et les utiliser dans des définitions de propriétés. Cela facilite la mise à jour ultérieure des drapeaux, particulièrement lorsqu'une variable est utilisée dans plusieurs cibles.</para>

   <para>Quelques-unes des nombreuses variables habituelles sont énumérées ci-après. Pour obtenir une liste complète, consultez la <ulink url="info:automake">documentation info d'automake</ulink>. <itemizedlist>
      <listitem>
       <para><emphasis>$(prefix)</emphasis> : le préfixe d'installation. Le projet est installé dans divers sous-répertoires sous ce préfixe. Sa valeur par défaut est /usr/local.</para>
      </listitem>
      <listitem>
       <para><emphasis>$(bindir)</emphasis> : le répertoire d'installation pour les exécutables binaires. Toutes vos cibles exécutables et vos scripts sont installés dans ce répertoire. Sa valeur par défaut est $(prefix)/bin.</para>
      </listitem>
      <listitem>
       <para><emphasis>$(libdir)</emphasis> : le répertoire d'installation pour les bibliothèques. Toutes vos bibliothèques (partagées et statiques) sont installées dans ce répertoire ou dans un sous-répertoire. Sa valeur par défaut est $(prefix)/lib.</para>
      </listitem>
      <listitem>
       <para><emphasis>$(module_CFLAGS)</emphasis> et $(module_LIBS) : ces drapeaux sont définis par <application>configure</application> pour les dépendances de votre projet. Les paquets utilisés par le projet sont définis dans <link linkend="project-properties">Propriétés du projet</link>. 'module' représente un groupe de paquets que vous avez précisé dans les propriétés du projet comme indiqué ci-dessous.</para>
      </listitem>
     </itemizedlist></para>


   <sect2 id="project-properties">
    <title>Propriétés du projet</title>
    <para>La boîte de dialogue « Propriétés du projet » ne s'ouvre qu'à l'aide de l'élément de menu <menuchoice><guisubmenu>Projet</guisubmenu><guimenuitem>Propriétés</guimenuitem></menuchoice> à partir de la barre de menu principale. Vous pouvez : <itemizedlist>
     <listitem>
      <para>définir le nom, la version et l'URL du projet dans l'onglet <guibutton>Général</guibutton>. Des variables <application>configure</application> peuvent aussi être utilisées dans ces champs. L'URL sert pour les rapports d'anomalies du projet.</para>
     </listitem>
     <listitem>
      <para>ajouter ou supprimer des dépendances à votre projet dans l'onglet <guibutton>Paquets</guibutton>. Voir ci-dessous pour plus de détails.</para>
     </listitem>
     <listitem>
      <para>créer d'autres variables configure dans l'onglet <guibutton>Variables</guibutton> afin de les utiliser dans des propriétés de groupe ou de cible.</para>
     </listitem>
    </itemizedlist></para>
    <para>Les dépendances sont des paquets externes utilisés par le projet ; ils sont donc requis pour la construction. Seuls les paquets installés en utilisant <ulink url="info:pkg-config">pkg-config</ulink> peuvent être ajoutés à partir de cette interface. Pour les autres, le fichier configure.ac doit être modifié manuellement. <figure>
       <title>Boîte de dialogue « Propriétés du projet »</title>
       <screenshot>
	   <screeninfo>Boîte de dialogue « Propriétés du projet »</screeninfo>
        <graphic fileref="figures/project_info.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure></para>
   <para>Les dépendances de paquets externes sont regroupées dans des <emphasis>modules</emphasis> afin que les combinaisons des drapeaux de construction puissent être définis de manière pratique pour les différentes cibles. Les <emphasis>modules</emphasis> ne sont que des groupements arbitraires de paquets ; ils peuvent recevoir n'importe quel nom (seuls les caractères alphanumériques et « _ » sont autorisés dans les noms de modules). Habituellement, leur nom s'inspire de celui des cibles dans lesquelles ils sont utilisés. Par conséquent, pour de petits projets avec une seule cible, un seul module suffit pour contenir toutes les dépendances.</para>
   <para>Chaque paquet exporte un jeu de <emphasis>drapeaux pour le compilateur</emphasis> et <emphasis>pour les bibliothèques</emphasis>. Ils sont regroupés pour tous les paquets dans un même module ; les variables <application>configure</application> <emphasis>$(module_CFLAGS)</emphasis> et <emphasis>$(module_LIBS)</emphasis> y sont définies. Ces variables peuvent être utilisées dans les <link linkend="group-properties">Propriétés de groupe</link> et <link linkend="target-properties">Propriétés de cible</link>.</para>
   <para>Pour ajouter une dépendance de paquet : <itemizedlist>
     <listitem>
      <para>choisissez <menuchoice><guisubmenu>Projet</guisubmenu><guimenuitem>Propriétés</guimenuitem></menuchoice> pour afficher la boîte de dialogue « Propriétés du projet »,</para>
     </listitem>
     <listitem>
      <para>sélectionnez l'onglet <guibutton>Paquets</guibutton> pour faire apparaître la page correspondante,</para>
     </listitem>
     <listitem>
      <para>choisissez le <emphasis>module</emphasis> auquel ajouter le paquet. S'il n'y a encore pas de module créé ou pas de module approprié, créez-le en cliquant sur <guibutton>Ajouter un module</guibutton>. Donnez-lui un nom judicieux, de préférence en MAJUSCULES pour être en harmonie avec les autres variables <application>configure</application> (n'utilisez que des caractères alphanumériques et « _ ») et pressez sur <keycap>Entrée</keycap> pour le créer.</para>
     </listitem>
     <listitem>
      <para>cliquez sur <guibutton>Ajouter un paquet</guibutton> pour faire apparaître la boîte de dialogue de sélection du paquet,</para>
     </listitem>
     <listitem>
      <para>choisissez le paquet à ajouter et cliquez sur <guibutton>Ajouter</guibutton>,</para>
     </listitem>
     <listitem>
      <para>cliquez sur <guibutton>Fermer</guibutton> pour fermer la boîte de dialogue des propriétés.</para>
     </listitem>
    </itemizedlist></para>
   </sect2>

   <sect2 id="group-properties">
    <title>Propriétés du groupe</title>
    <para>Pour modifier les propriétés d'un groupe, double-cliquez sur le groupe dans le volet <interface>Projet</interface> pour ouvrir la boîte de dialogue <interface>Propriétés du groupe</interface> (vous pouvez aussi cliquer avec le bouton droit sur le groupe et choisir <guimenuitem>Propriétés</guimenuitem> dans le menu contextuel). <figure>
       <title>Boîte de dialogue « Propriétés du groupe »</title>
       <screenshot>
	   <screeninfo>Boîte de dialogue « Propriétés du groupe »</screeninfo>
        <graphic fileref="figures/project_group.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure></para>

    <para>La totalité des propriétés d'un groupe s'applique à toutes les cibles qu'il contient. Ainsi, tous les drapeaux de compilation ou d'édition des liens définis pour un groupe feront automatiquement partie des cibles qu'il contient (en plus des propriétés individuelles de chaque cible). Les champs suivants sont disponibles dans la boîte dialogue Propriétés : <itemizedlist>
		    <listitem>
		     <para><emphasis>Includes</emphasis> : définissez ici les répertoires include pour les cibles C et C++. Vous devez donner la syntaxe complète de l'option include du compilateur ici, par ex. -I/usr/include/blabla. Les chemins include sont utilisés pour rechercher les fichiers d'en-tête inclus dans les fichiers source (vous pouvez également ajouter ici d'autres drapeaux de compilation mais il est préférable de les définir dans le champ <emphasis>drapeaux de compilation</emphasis> comme indiqué ci-dessous).</para>
           </listitem>
		    <listitem>
		     <para><emphasis>Drapeaux du compilateur</emphasis> : définissez ici les drapeaux spécifiques au compilateur. Il y a différents champs pour les diverses catégories de compilateurs. Les drapeaux pouvant être définis ici dépendent du compilateur réellement utilisé. Le compilateur utilisé par défaut pour le C/C++ est gcc/g++ (le compilateur C GNU). Consultez la <ulink url="info:gcc">documentation info gcc</ulink> pour plus de détails.</para>
           </listitem>
		    <listitem>
		     <para><emphasis>Répertoires d'installation</emphasis> : la boîte de dialogue affiche un champ pour chaque cible du groupe qui nécessite un répertoire d'installation. Définissez chaque répertoire d'installation relativement à l'une des nombreuses variables de répertoire <application>automake</application> telles que $(prefix), $(bindir), $(libdir) ou $(datadir).</para>
           </listitem>
          </itemizedlist></para>
   </sect2>

   <sect2 id="target-properties">
    <title>Propriétés de cible</title>
    <para>Toute propriété définie pour une cible ne s'applique qu'à cette cible. Une cible hérite également des propriétés du groupe auquel elle appartient.</para>
	  <para>Pour définir une propriété de la cible, double-cliquez sur la cible dans le volet <interface>Projet</interface>. Vous ouvrez ainsi la boîte de dialogue <interface>Propriétés de la cible</interface> (vous pouvez aussi cliquer avec le bouton droit sur la cible et choisir <guimenuitem>Propriétés</guimenuitem> dans le menu contextuel). <figure>
       <title>Boîte de dialogue « Propriétés de la cible »</title>
       <screenshot>
	   <screeninfo>Boîte de dialogue « Propriétés de la cible »</screeninfo>
        <graphic fileref="figures/project_target.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure></para>
    <para>Vous pouvez ajouter ici, pour une cible donnée, les modules que vous avez incorporés dans <link linkend="project-properties">Propriétés du projet</link>. Pour activer un module, cochez la case en face de son nom. Cela ajoute automatiquement les chemins include et les drapeaux du compilateur à cette cible et active l'utilisation du module dans cette cible.</para>
    <sect3 id="target-advanced">
    <title>Options de cible avancées</title>
    <para>Les champs suivants sont disponibles pour la configuration avancée de la cible. Ils apparaissent en cliquant sur le bouton <guibutton>Avancé...</guibutton> de la boîte de dialogue « Propriétés de la cible ».</para>
    <para>
    <figure>
       <title>Boîte de dialogue « Propriétés de la cible »</title>
       <screenshot>
	   <screeninfo>Boîte de dialogue « Propriétés de la cible »</screeninfo>
        <graphic fileref="figures/project_target_details.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
		   <itemizedlist>
		    <listitem>
		     <para><emphasis>Paramètres du compilateur</emphasis> : définissez ici les drapeaux spécifiques au compilateur. Il y a divers champs selon les différentes catégories de compilateurs. Les drapeaux définis ici dépendent du compilateur réellement utilisé. Le compilateur par défaut utilisé pour le C/C++ est gcc/g++ (le compilateur C GNU). Consultez la <ulink url="info:gcc">documentation info gcc</ulink> pour plus de détails.</para>
            </listitem>
		    <listitem>
		     <para><emphasis>Drapeaux de l'éditeur de liens</emphasis> : définissez ici les drapeaux de l'éditeur de liens à utiliser au cours de l'édition de lien de la cible. Ces drapeaux ne s'appliquent qu'aux cibles Programmes et Bibliothèques. Consultez la <ulink url="info:ld">documentation info ld</ulink> pour connaître les options disponibles de l'éditeur de liens.</para>
            </listitem>
		    <listitem>
		     <para><emphasis>Bibliothèques</emphasis> : définissez ici les bibliothèques dont la cible dépend.</para>
           </listitem>
          </itemizedlist>

    </para>
    </sect3>
   </sect2>
  </sect1>
  
 </chapter>

 <!-- Build -->
 <!-- ============= Build ====================== -->
 <chapter id="building">
  <title>Construction</title>
  <para>Anjuta gère les projets <application>autotools</application>. Il est capable de se débrouiller avec d'autres types de projets, tels que les projets utilisant un Makefile écrit par l'utilisateur, mais l'interface de construction actuelle cible les projets autotools. Une certaine connaissance de ceux-ci est utile pour mieux comprendre comment un projet est construit.</para>
  <para>Un projet autotools est construit en trois étapes :</para>
  <para>
     <orderedlist>
      <listitem><para>Génération</para></listitem>
      <listitem><para>Configuration</para></listitem>
      <listitem><para>Construction</para></listitem>
     </orderedlist>
  </para>
  <para>La <emphasis>construction</emphasis> est l'étape principale au cours de laquelle tous les fichiers cibles sont générés à partir des fichiers source. Elle se divise en deux phases : <emphasis>compilation</emphasis> et <emphasis>édition des liens</emphasis>. Pendant la phase de <emphasis>compilation</emphasis> chaque fichier objet est généré à partir du fichier source correspondant. Par exemple, un fichier source <filename>hello.c</filename> génère <filename>hello.o</filename> après compilation. Normalement, vous n'avez pas à vous soucier de ces fichiers objets — considérez-les comme des fichiers intermédiaires. Pendant la phase d'<emphasis>édition des liens</emphasis>, tous les fichiers objet et les bibliothèques sont liés ensemble pour créer l'exécutable final. Certains langages de programmation ne nécessitent pas les phases <emphasis>compilation</emphasis> et <emphasis>édition de liens</emphasis>. De plus, l'étape <emphasis>construction</emphasis> peut être utilisée pour générer d'autres fichiers, comme une documentation qui ne nécessite pas de telles phases.</para>
  <para>La <emphasis>configuration</emphasis> est l'étape pendant laquelle l'arborescence des sources est adaptée à votre système. Les projets <application>autotools</application> peuvent être construits sur un large éventail de systèmes utilisant des compilateurs différents et possédant des fonctions de bibliothèques différentes. Cette étape lance un script appelé <filename>configure</filename> qui vérifie les diverses caractéristiques du système et crée quelques uns des fichiers nécessaires à la réalisation de la construction (tels que <filename>Makefile</filename> et <filename>config.h</filename>). Cette étape est également utilisée pour sélectionner les options de construction ; par exemple une option de construction peut désactiver l'optimisation afin de rendre plus facile le débogage ou désactiver des parties expérimentales d'un programme.</para>
  <para>La <emphasis>génération</emphasis> est l'étape pendant laquelle le script <filename>configure</filename> et d'autres fichiers en relation sont créés. Le script <filename>configure</filename> utilisé ci-dessus doit être capable de s'exécuter sur des systèmes différents tout en vérifiant beaucoup de choses. Il serait très difficile de l'écrire à la main. De plus <application>autotools</application> impose des règles d'organisation de projet telles que la présence obligatoire de certains fichiers : <filename>NEWS</filename> et <filename>COPYING</filename> par exemple. Il comprend plusieurs outils pour créer les fichiers nécessaires à partir de fichiers plus simples écrits par le développeur tels que <filename>configure.in</filename> (ou <filename>configure.ac</filename>) et <filename>Makefile.am</filename>. Tous ces outils sont ordinairement lancés par un script appelé <filename>autogen.sh</filename> dans le répertoire du projet. Cette étape n'est utile qu'au développeur (quelqu'un qui modifie les sources) car le script <filename>configure</filename> ne dépend que des fichiers sources et est distribué dans le paquet du projet. Notez que les fichiers <filename>Makefile</filename> créés par <application>configure</application> comprennent des règles pour régénérer automatiquement le projet si besoin est, il ne sera donc souvent pas nécessaire de le relancer directement.</para>
 <para>Lisez les pages info relatives à <ulink type="info" url="info:automake"><application>automake</application></ulink> et <ulink type="info" url="info:autoconf"><application>autoconf</application></ulink> pour plus de détails sur la manière dont ces outils fonctionnent.</para>


 <!-- Build: Generate and Configure -->

 <sect1 id="build-configure">
  <title>Génération et configuration</title>
  <sect2 id="configure">
   <title>Configuration d'un projet</title>
   <para>Vous devez mener à bonne fin l'étape de configuration pour pouvoir construire le projet. Elle est habituellement lancée une seule fois avant une première construction — par exemple, tout de suite après avoir extrait l'archive tar des sources d'une distribution de projet. Après cela, la configuration est automatiquement gérée par les processus ultérieurs de construction. Si vous avez utilisé l'<emphasis>Assistant projet</emphasis> pour créer l'application, vous n'avez alors pas à lancer cette étape séparément : l'assistant l'exécute, considérant qu'elle fait partie du processus de génération du projet.</para>
   <para>Il n'est pas obligatoire de ne lancer la configuration qu'une seule fois. Elle peut être relancée n'importe quand, habituellement quand les options de configuration sont à modifier. Vous noterez que si le fichier <filename>config.h</filename> dans le répertoire de plus haut niveau est modifié, une nouvelle exécution de <filename>configure</filename> ne l'écrasera pas.</para>
   <para>Les deux étapes génération et configuration se lancent à partir du même élément de menu : <menuchoice><guisubmenu>Construire</guisubmenu><guimenuitem>Configurer le projet…</guimenuitem></menuchoice>. Cet élément de menu fait apparaître une boîte de dialogue dans laquelle vous pouvez choisir :<itemizedlist>
     <listitem><para>l'alternative du lancement ou non de la génération</para>
      <para>La génération doit être effectuée une fois au début du projet ; par la suite, le processus de construction la gère automatiquement. Vous pouvez forcer une nouvelle exécution en cochant la case <interface>Régénérer le projet</interface> ; vous serez peut-être amené à faire cela si vous rencontrez des problèmes au cours de la construction d'un projet (par ex. si des erreurs de construction sont signalées après avoir modifié beaucoup de fichiers de construction).</para>
     </listitem>
     <listitem><para>le nom de la configuration</para>
      <para>Ce nom est utilisé pour se référer à chaque configuration. Certaines configurations (défaut, débogage, optimisée) sont déjà prédéfinies. Chaque configuration possède son répertoire de construction et ses options de configuration.</para>
     </listitem>
     <listitem><para>le répertoire de construction</para>
      <para>C'est le nom du répertoire de construction. Dans la configuration par défaut, c'est le même répertoire que celui des sources, mais autotools sait gérer la construction dans un autre répertoire.</para> 
      <note><para>Chaque configuration doit avoir un répertoire de construction distinct ; donc, si une configuration utilise le répertoire des sources, vous ne pourrez pas y placer une autre configuration en même temps. Vous devez lancer <menuchoice><guisubmenu>Construire</guisubmenu><guimenuitem>Enlever la configuration</guimenuitem></menuchoice> et supprimer la configuration utilisant le répertoire source avant d'y placer la nouvelle.</para></note>
     </listitem>
     <listitem><para>les options de configuration</para>
      <para>Ces options sont transmises au script <filename>configure</filename>. Certaines sont standards, telles que --prefix et CFLAGS ; d'autres dépendent du projet. Vous pouvez obtenir une liste des options de configuration autorisées en lançant le script <filename>configure</filename> avec l'option <option>--help</option>.</para>
     </listitem>
    </itemizedlist></para>
  </sect2>
  <sect2 id="select-configure">
   <title>Sélection d'une configuration</title>
   <para>Si vous avez créé différentes configurations, vous pouvez choisir celle qui sera active en la sélectionnant dans <menuchoice><guisubmenu>Construire</guisubmenu><guimenuitem>Sélectionner la configuration</guimenuitem></menuchoice>.</para>
  </sect2>
  <sect2 id="clean-configure">
   <title>Effacement d'une configuration</title>
   <para>Pour nettoyer le projet et le retrouver dans un état nécessitant de relancer la configuration, choisissez <menuchoice><guisubmenu>Construire</guisubmenu><guimenuitem>Enlever la configuration</guimenuitem></menuchoice>. La commande <command>make distclean</command> sera exécutée ; elle supprime plus de fichiers que l'option <guimenuitem>Nettoyer le projet</guimenuitem>. En d'autres termes, le projet sera comme s'il venait d'être extrait d'une archive tar de distribution. Notez que cela n'efface pas le répertoire de la configuration ; ce que vous pouvez faire si vous le souhaitez.</para>
  </sect2>
 </sect1>


 <!-- Build: Compile and Build -->

 <sect1 id="build-compile-and-build">
  <title>Compilation et construction</title>
  <sect2 id="build-compile">
   <title>Compilation d'un fichier</title>
   <para>Dans un projet, des fichiers sources particuliers peuvent être compilés isolément en fichiers objets (fichiers <filename>*.o</filename>). Même si vous n'avez pas en règle générale à vous occuper de ces fichiers objets, il est parfois pratique de compiler un fichier au préalable (pour vérifier par exemple qu'il n'y a pas d'erreur de syntaxe). La construction intégrale d'un projet peut demander beaucoup de temps, en particulier pour les applications les plus grandes et les plus complexes. Par conséquent, vous serez probablement amené à faire beaucoup d'itérations édition/compilation pendant le développement d'un projet.</para>
   <para>Pour compiler un fichier, choisissez l'élément de menu <menuchoice><guisubmenu>Construire</guisubmenu><guimenuitem>Compiler</guimenuitem></menuchoice> ou pressez <keycap>F11</keycap>. Le fichier actif sera compilé.</para>
  </sect2>

  <sect2 id="build-build">
   <title>Construction d'un exécutable</title>
   <para><application>Anjuta</application> ne possède pas de commande d'édition de liens indépendante tout simplement parce qu'elle n'est pas nécessaire. Le processus de construction compile tous les fichiers sources et fait l'édition des liens avec les bibliothèques nécessaires. La commande de construction ne compile pas à nouveau les fichiers déjà à jour (cela s'appelle la <emphasis>vérification des dépendances</emphasis>). Si vous avez déjà construit le projet et qu'aucun fichier avec dépendance n'a été modifié, même l'étape d'édition des liens sera sautée.</para>
   <para>Comment la vérification des dépendances influence-t-elle le développement d'un projet ? Si vous avez modifié un fichier, tous les fichiers sources qui dépendent du fichier modifié sont compilés à nouveau. La dépendance de tous les fichiers (pas seulement les fichiers objets et les exécutables) du projet est vérifiée pendant le processus de construction. Si un fichier particulier dépend d'un autre fichier modifié, alors ce fichier est régénéré.</para>
   <para>Imaginez ce que serait votre vie (de programmeur) si la vérification des dépendances n'existait pas ? Si vous ne pouvez pas encore répondre maintenant, vous saurez le dire lorsque vous commencerez à développer des gros projets !</para>
   <para><menuchoice><guisubmenu>Construire</guisubmenu><guimenuitem>Construire</guimenuitem></menuchoice> construit tous les fichiers dans le répertoire du fichier actif courant.</para>
   <para><menuchoice><guisubmenu>Construire</guisubmenu><guimenuitem>Construire le projet</guimenuitem></menuchoice> construit l'ensemble du projet — tous les sous-répertoires sont construits récursivement.</para>
  </sect2>
 </sect1>


 <!-- Build: Other operations -->

 <sect1 id="build-other">
  <title>Autres opérations</title>
  <sect2 id="build-dist">
   <title>Création d'un paquet de distribution</title>
   <para>Pour construire l'archive tar de distribution du projet, choisissez <menuchoice><guisubmenu>Construire</guisubmenu><guimenuitem>Construire l'archive tarball</guimenuitem></menuchoice>. Une archive tar (<filename>*.tar.gz</filename>) sera créée et placée dans le répertoire de plus haut niveau du projet. Copiez le fichier dans un endroit sûr pour la distribution.</para>
  </sect2>
  <sect2 id="build-install">
   <title>Installation d'un projet</title>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Construire</guisubmenu><guimenuitem>Installer</guimenuitem></menuchoice> pour installer l'application générée sur votre système.</para>
   <note>
    <title>Installation dans le système</title>
    <para>Vous devez être connecté en tant que root pour réaliser une installation dans le système. Notez également que pour qu'une application GNOME utilise les fichiers pixmap du projet, elle doit être installée en tant qu'application système. Sinon, lorsque l'application est exécutée dans le projet, beaucoup d'erreurs « pixmap not found » seront signalées. Dans les préférences de construction, vous pouvez configurer Anjuta pour utiliser la commande <command>sudo</command> ou <command>su</command> avant d'installer le projet.</para>
   </note>
  </sect2>
  <sect2 id="build-clean">
   <title>Nettoyage</title>
   <para>Cela supprime tous les fichiers générés par le processus de construction, y compris les fichiers objets (fichiers <filename>*.o</filename>) et les exécutables. Cette fonctionnalité est appliquable à un répertoire ou à tout le projet.</para>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Construire</guisubmenu><guimenuitem>Nettoyer le projet</guimenuitem></menuchoice> pour nettoyer tous les répertoires du projet.</para>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Construire</guisubmenu><guimenuitem>Nettoyer</guimenuitem></menuchoice> pour nettoyer uniquement le répertoire du fichier actif actuel.</para>
  </sect2>

 </sect1>

</chapter>

 <!-- Debugging -->
 <!-- ============= Debugging ====================== -->
 <chapter id="debugging">
  <title>Débogage</title>
  <para>
   <emphasis>Déboguer est humain. Réparer l'anomalie est divin...</emphasis>
  </para>
  <para>Eh bien, ce paragraphe n'abordera que l'aspect <emphasis>humain</emphasis>. L'aspect <emphasis>divin</emphasis> est laissé à vos bons soins !</para>
  <para>Lorsqu'un programme ne se comporte pas de la manière prévue, on dit que le programme contient un <emphasis>bogue</emphasis>. Un bogue n'est pas une erreur de compilation — les erreurs de compilation sont relativement faciles à résoudre parce que le compilateur vous indique où se situe le problème. Au contraire, les bogues sont des erreurs qui surviennent pendant l'exécution d'un programme et ils peuvent être difficiles (parfois très difficiles !) à détecter.</para>
  <para>Tous les programmes que l'on pourrait penser sans bogue ne le sont jamais totalement. Le seul objectif que vous puissiez vous fixer est de diminuer le nombre de bogues qu'ils contiennent. Le processus de réparation de bogues s'appelle le <emphasis>débogage</emphasis> et l'outil utilisé pour déboguer s'appelle le <emphasis>débogueur</emphasis>. <application>Anjuta</application> fournit un environnement très convivial et puissant à la fois (en fait, une interface graphique du programme <application>gdb</application>, un puissant outil en ligne de commande standard sous Linux).</para>
  <para>Un débogueur suit à la trace et dépiste l'exécution du programme ; il permet d'inspecter les informations voulues pour étudier son exécution.</para>

 <!-- Debugger: Start and stop -->

 <sect1 id="debugger-session">
  <title>Mise en marche et arrêt</title>

  <para>Le débogueur est toujours démarré avec un programme chargé. Il y a deux manières de procéder : <itemizedlist>
    <listitem><para><emphasis>Lancer un exécutable</emphasis></para></listitem>
    <listitem><para><emphasis>S'attacher à un processus</emphasis></para></listitem>
   </itemizedlist><note>
    <para>La plupart des fonctionnalités de Anjuta sont apportées à l'aide de greffons. Si vous ne pouvez pas voir les menus décrits ici, c'est probablement parce que le greffon Déboguer n'est pas chargé. Allez dans <menuchoice><guisubmenu>Édition</guisubmenu><guimenuitem>Préférences</guimenuitem><guimenuitem>Général</guimenuitem><guimenuitem>Greffons installés</guimenuitem></menuchoice> et vérifiez que le greffon Déboguer est chargé. Il s'agit d'un greffon activable par l'utilisateur, donc à charger ou décharger à la demande.</para>
   </note></para>

  <sect2 id="debug-run">
   <title>Lancer un exécutable</title>
   <para>Le même menu permet de lancer un programme avec ou sans débogueur : choisissez <menuchoice><guisubmenu>Exécuter</guisubmenu><guimenuitem>Exécuter</guimenuitem></menuchoice> pour lancer un programme sans le débogueur et <menuchoice><guisubmenu>Exécuter</guisubmenu><guimenuitem>Déboguer le programme</guimenuitem></menuchoice> pour le lancer avec le débogueur.</para>
   <note>
    <para>Pour une utilisation optimale du débogueur, il est fortement recommandé de construire le programme avec les informations de débogage (-g pour gcc) et sans optimisation (-O0 pour gcc). À cet effet, sélectionnez la configuration débogage avant de construire le programme pour la première fois.</para>
   </note>
   <para>Pour choisir le programme à lancer et son environnement, servez-vous de <menuchoice><guisubmenu>Exécuter</guisubmenu><guimenuitem>Paramètres du programme…</guimenuitem></menuchoice>. Vous pourrez alors sélectionner : <itemizedlist>
     <listitem><para>le nom du programme que vous souhaitez déboguer,</para>
      <para>Le menu déroulant de la boîte combinée pour la cible est pré-remplie avec tous les exécutables du projet en cours. Mais vous pouvez aussi choisir un autre exécutable ne faisant pas partie du projet. Le débogueur accepte également les exécutables libtool qui sont des scripts, incorporant de vrais exécutables, générés par libtool.</para>
     </listitem>
     <listitem><para>les paramètres en ligne de commande,</para></listitem>
     <listitem><para>le répertoire de travail,</para></listitem>
     <listitem><para>les variables d'environnement,</para>
      <para>Les variables d'environnement affichées en gris clair sont les variables d'environnement actuelles. Vous pouvez ici ajouter, modifier ou supprimer des variables d'environnement.</para>
      <tip><para>Pour déboguer Anjuta en utilisant Anjuta, vous pouvez utiliser un thème différent pour modifier l'apparence de l'instance en cours de débogage. Par exemple, vous pouvez ajouter « GTK2_RC_FILES=/usr/share/themes/Crux/gtk-2.0/gtkrc ».</para></tip>
     </listitem>
     <listitem><para>si le programme doit être lancé dans un terminal ou non. Si oui, le greffon Terminal de Anjuta doit être activé.</para></listitem>
    </itemizedlist></para>
  </sect2>
	
  <sect2 id="debug-attach">
  <title>Attachement à un processus</title>
   <para>Il est également possible d'attacher un processus en cours d'exécution et de le déboguer en choisissant l'élément de menu <menuchoice><guisubmenu>Exécuter</guisubmenu><guimenuitem>Déboguer le processus…</guimenuitem></menuchoice>. Une liste de tous les processus en cours d'exécution dans le système apparaît.</para>
   <figure id="attach">
    <title>Boîte de dialogue « Attacher au processus »</title>
    <screenshot>
	<screeninfo>Boîte de dialogue « Attacher au processus »</screeninfo>
     <graphic fileref="figures/attach.png" format="PNG" srccredit="andyp"/>
    </screenshot>
   </figure>
   <para>Choisissez le processus à attacher et cliquez sur <guibutton>Valider</guibutton> pour lancer le débogueur. Il s'attachera au processus sélectionné et le stoppera.</para>
   <note>
    <para>Il n'est actuellement pas possible de charger l'information des symboles pour les processus attachés. Les symboles doivent être inclus dans le processus.</para>
   </note>
  </sect2>
  
  <sect2 id="debug-stop">
   <title>Arrêt du débogueur</title>
    <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Exécuter</guisubmenu><guimenuitem>Arrêter le débogueur</guimenuitem></menuchoice> pour arrêter le débogueur. Le programme en cours de débogage est tué. Si le débogueur a été attaché à un processus en cours d'exécution, le débogueur se détache de celui-ci sans le tuer. Une boîte de confirmation apparaît si un programme est actuellement attaché ou lancé.</para>
  </sect2>

  <sect2 id="debug-add-sources">
   <title>Ajout de répertoires source</title>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Ajouter des chemins de sources…</guimenuitem></menuchoice> pour afficher une boîte de dialogue permettant d'ajouter ou de supprimer des répertoires source.</para>
   <para>La plupart des exécutables incluent les chemins complets des fichiers, donc définir les répertoires contenant les fichiers sources n'est normalement pas nécessaire. Mais certains exécutables n'incluent que les noms des fichiers sans les chemins ; dans ce cas, le débogueur recherche les fichiers sources dans tous les répertoires définis. L'ordre des répertoires peut être important si plusieurs fichiers possèdent le même nom, il est donc possible de le modifier en utilisant les boutons <guibutton>Monter</guibutton> et <guibutton>Descendre</guibutton>. La liste des répertoires est envoyée au débogueur au moment où il démarre. Si vous modifiez la liste, vous devez redémarrer le débogueur pour qu'il utilise la nouvelle liste.</para>
  </sect2>

 </sect1>
 
 <!-- Debugger: Execution -->
 
 <sect1 id="debugger-exec">
  <title>Exécution</title>
  <para>Il est possible de contrôler très finement l'exécution d'un programme dans le débogueur. Le programme peut être exécuté pas à pas ou autorisé à continuer jusqu'à ce qu'il rencontre un point d'arrêt. Pouvoir exécuter de cette manière est essentiel pour le comportement du programme de dépistage. Tout comme lors d'une session d'édition de vidéo, le programme peut être exécuté au <emphasis>ralenti</emphasis> avec la possibilité d'avancer, pauser, s'arrêter, etc. Vous ne pouvez toutefois pas reculer.</para>
  <para>Les méthodes utilisables pour l'exécution d'un programme dans le débogueur sont décrites dans les paragraphes suivants. Ces commandes ne sont disponibles que lorsque le programme a déjà été lancé.</para>
  
  <sect2 id="dbg-step-in">
   <title>Pas à pas (en entrant)</title>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Pas en avant</guimenuitem></menuchoice> ou cliquez sur l'icône <guibutton>Pas en avant</guibutton> dans la <interface>barre d'outils du débogueur</interface> pour avancer d'un pas dans le programme.</para>
   <para>Le pas à pas exécute uniquement une instruction du programme (celle où le programme a été interrompu) puis rend le contrôle au débogueur. Si l'instruction qui est exécutée appelle une ou plusieurs fonctions, le débogueur essaie de poursuivre son pas à pas dans les fonctions (dans l'ordre où elles sont exécutées). Une fois l'instruction exécutée et la main rendue, vous pouvez étudier l'état de votre programme.</para>
   <para>Si la <interface>fenêtre Désassemblage</interface> possède le focus lorsque cette commande est sélectionnée, une seule instruction assembleur est exécutée.</para>
  </sect2>

  <sect2 id="dbg-step-over">
   <title>Pas à pas (en sautant)</title>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Avancer en sautant</guimenuitem></menuchoice> ou cliquez sur l'icône <guibutton>Avancer en sautant</guibutton> dans la <interface>barre d'outils du débogueur</interface> pour avancer en sautant des instructions dans le programme.</para>
   <para><emphasis>Avancer en sautant</emphasis> est similaire à <emphasis>Pas en avant</emphasis>, mis à part le fait que le débogueur ne chemine pas à l'intérieur des fonctions appelées par l'instruction en cours d'exécution. L'instruction est exécutée globalement d'une seule traite.</para>
   <para>Si la <interface>fenêtre désassemblage</interface> possède le focus lorsque cette commande est sélectionnée, une seule instruction assembleur est exécutée, mais, si cette instruction est un appel de sous-programme, aucun arrêt n'est effectué à l'intérieur de ce dernier.</para>
   <note>
    <para>Si une librairie dynamique est chargée lors du pas, le programme ne s'arrête pas une fois le pas effectué. Le programme continue de s'exécuter jusqu'à ce qu'il rencontre un point d'arrêt ou que vous l'interrompiez.</para>
   </note>
  </sect2>
  
  <sect2 id="dbg-step-out">
   <title>Pas à pas (en sortant)</title>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Avancer pour sortir</guimenuitem></menuchoice> ou cliquez sur l'icône <guibutton>Avancer pour sortir</guibutton> dans la <interface>barre d'outils du débogueur</interface> pour sortir de la fonction en cours du programme.</para>
   <para><emphasis>Avancer pour sortir</emphasis> exécute la fonction en cours jusqu'à son instruction de retour. Le programme s'arrête une fois sorti de la fonction. Avancer pour sortir n'est pas à proprement parler un pas à pas puisqu'il n'y a pas qu'une seule instruction qui soit exécutée — toutes les instructions de la fonction sont exécutées jusqu'au retour dans la fonction appelante.</para>
  </sect2>
  
  <sect2 id="dbg-run">
   <title>Exécution/Continuation</title>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Exécuter/Continuer</guimenuitem></menuchoice> ou cliquez sur l'icône <guibutton>Exécuter/Continuer</guibutton> dans la <interface>barre d'outils du débogueur</interface> pour poursuivre l'exécution du programme.</para>
   <para>Cette option continue l'exécution du programme jusqu'à ce qu'un point d'arrêt soit atteint ou que le programme se termine.</para>
  </sect2>

  <sect2 id="dbg-runto">
   <title>Exécution jusqu'à</title>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Exécuter jusqu'au curseur</guimenuitem></menuchoice> ou cliquez sur l'icône <guibutton>Exécuter jusqu'au curseur</guibutton> dans la <interface>barre d'outils du débogueur</interface> pour exécuter le programme jusqu'à atteindre la ligne contenant le curseur.</para>
   <para>Cette option continue l'exécution du programme jusqu'à ce que la ligne ou l'adresse (si la <interface>fenêtre Désassemblage</interface> a le focus) marquée par le curseur soit atteinte.</para>
  </sect2>
  
  <sect2 id="dbg-stop">
   <title>Arrêt du programme</title>
   <para>Lorsque le programme est en cours d'exécution et possède le contrôle, aucune tâche de débogage ne peut être réalisée. Pour obtenir le contrôle pendant que le programme tourne, choisissez l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Suspendre le programme</guimenuitem></menuchoice> ou cliquez sur l'icône <guibutton>Suspendre le programme</guibutton> dans la <interface>barre d'outils du débogueur</interface>. Le programme est interrompu et la main rendue au débogueur.</para>
  </sect2>
  
 </sect1>
 
<!-- ============= Debugging: Breakpoints ====================== -->
 
 <sect1 id="debugging-breaks">
  <title>Points d'arrêt</title>
  <para>Au cours du débogage d'un programme, il est utile d'avoir la possibilité d'en interrompre l'exécution à un point donné afin de pouvoir en examiner l'état à cet instant. Les points d'arrêt permettent la réalisation d'une telle opération. Vous les disposerez à l'aplomb de diverses instructions dans le fichier source avant de lancer le programme. Lorsqu'un point d'arrêt est rencontré, l'exécution du programme est suspendue, permettant l'évaluation d'expressions, l'inspection de variables, l'étude du traçage de la pile, etc.</para>

  <sect2 id="breaks-list">
   <title>Liste des points d'arrêt</title>
   <para>La fenêtre <interface>Liste des points d'arrêt</interface> s'ouvre en choisissant <menuchoice><guisubmenu>Affichage</guisubmenu><guimenuitem>Points d'arrêt</guimenuitem></menuchoice></para>
   <para>
    <figure>
      <title>Fenêtre de la liste des points d'arrêt</title>
      <screenshot>
       <screeninfo>Fenêtre de la liste des points d'arrêt</screeninfo>
       <graphic fileref="figures/brk_dlg.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
   <para>Cette fenêtre comporte les colonnes suivantes : <variablelist>
     <varlistentry>
      <term>Emplacement</term>
      <listitem>
       <para>C'est la position du point d'arrêt dans le fichier source. Lorsqu'il a été défini à l'aide du débogueur, vous obtiendrez des informations supplémentaires comme le nom de la fonction contenant le point d'arrêt.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Adresse</term>
      <listitem>
       <para>Ce champ indique l'adresse mémoire du point d'arrêt lorsqu'il a été défini à l'aide du débogueur.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Type</term>
      <listitem>
       <para>Cette zone affiche toujours « breakpoint ». Elle sera utilisée dans une version future pour la prise en charge de différentes sortes de points d'arrêt.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Condition</term>
      <listitem>
       <para>C'est la condition du point d'arrêt. Ce champ reste vide si aucune condition n'a été définie.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Nombre de passages</term>
      <listitem>
       <para>Lorsque le débogueur n'est pas en fonctionnement, cette colonne indique le nombre de passages sur le point d'arrêt ou zéro si ce nombre n'a pas été défini.</para>
       <para>Lorsque le débogueur est en fonctionnement, si le nombre de passages est défini égal à zéro dans les propriétés du point d'arrêt, cette colonne affichera le nombre de fois où ce point d'arrêt a été actif. Si le nombre de passages n'a pas été défini égal à zéro, les deux nombres sont affichés. Le nombre de passages est le deuxième nombre.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>État</term>
      <listitem>
       <para>C'est l'état du point d'arrêt. Il peut être :<itemizedlist>
         <listitem><para>Suspendu : le point d'arrêt n'est pas actif dans le programme.</para></listitem>
         <listitem><para>Permanent : le point d'arrêt est actif (son numéro d'identification est fourni entre parenthèses).</para></listitem>
         <listitem><para>Temporaire : le point d'arrêt est activé mais il sera supprimé après avoir été atteint.</para></listitem>
        </itemizedlist></para>
      </listitem>
     </varlistentry>
    </variablelist></para>
   <note>
    <para>Au cours d'une session Anjuta, tous les points d'arrêts sont conservés même s'ils correspondent à un emplacement non-existant. Dans ce cas, leur état est défini à « suspendu ». L'interface essaye de les définir chaque fois que le programme est démarré ou qu'une nouvelle bibliothèque dynamique est chargée.</para>
   </note>
  </sect2>  

  <sect2 id="breaks-set">
   <title>Ajout ou réglage de points d'arrêt</title>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Ajouter un point d'arrêt…</guimenuitem></menuchoice> ou <menuchoice><guimenuitem>Ajouter un point d'arrêt…</guimenuitem></menuchoice> dans le menu contextuel dans la liste des points d'arrêt pour ouvrir la boîte de dialogue <interface>Propriétés des points d'arrêt</interface>.</para>
   <para>
    <figure>
      <title>Boîte de dialogue « Propriétés des points d'arrêt »</title>
      <screenshot>
	   <screeninfo>Boîte de dialogue « Propriétés des points d'arrêt »</screeninfo>
       <graphic fileref="figures/brk_add.png" format="PNG" srccredit="mkv"/>
      </screenshot>
    </figure>
   </para>
   <para>Saisissez l'emplacement et, éventuellement, la condition d'arrêt et le nombre de passages, puis cliquez sur <guibutton>Valider</guibutton> pour définir le point d'arrêt. <variablelist>
     <varlistentry>
      <term>Emplacement</term>
      <listitem>
       <para>Saisissez l'emplacement où le point d'arrêt doit être placé. Vous utiliserez un des formats ci-après pour le préciser :</para>
       <para>
        <orderedlist>
         <listitem><para>Nom_du_fichier:Numéro_ligne</para></listitem>
         <listitem><para>Nom_de_la_fonction</para></listitem>
         <listitem><para>Fichier:Nom_de_la_fonction</para></listitem>
        </orderedlist>
       </para>
       <para>Le premier format est évident — l'emplacement se réfère au numéro de ligne <emphasis>Numéro_ligne</emphasis> du fichier source <emphasis>Nom_du_fichier</emphasis>. Le second format se réfère à la première ligne de la fonction <emphasis>Nom_de_la_fonction</emphasis>. Le troisième format est identique au second, mais vous devez utiliser cette notation s'il y a plus d'une fonction portant le nom <emphasis>Nom_de_la_fonction</emphasis> dans le programme. On les distingue en fournissant le <emphasis>Nom_du_fichier</emphasis>, ainsi la notation fait référence à la fonction <emphasis>Nom_de_la_fonction</emphasis> du fichier <emphasis>Fichier</emphasis>.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Condition</term>
      <listitem>
       <para>Le paramètre <emphasis>Condition</emphasis> affiche une expression associée qui doit renvoyer une valeur booléenne — l'évaluation de l'expression doit donner comme résultat TRUE (1) ou FALSE (0). Si le résultat de l'évaluation donne une valeur non booléenne, elle sera alors forcée en type booléen comme il se doit.</para>
       <para>Chaque fois qu'un point d'arrêt est rencontré pendant l'exécution du programme, la condition d'arrêt est évaluée. Le débogueur stoppe l'exécution seulement si le résultat de l'évaluation donne VRAI sinon il continue l'exécution comme s'il n'y avait pas de point d'arrêt.</para>
       <para>Si ce champ est vide, la valeur par défaut de <emphasis>Condition</emphasis> est VRAI. Le débogueur suspendra toujours l'exécution à l'emplacement du point d'arrêt.</para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Nombre de passages</term>
      <listitem>
       <para>Le <emphasis>nombre de passages</emphasis> est une valeur entière (non signée) qui indique au débogueur le nombre de fois où il doit ignorer le point d'arrêt avant de le prendre en considération. Le <emphasis>nombre de passages</emphasis> possède une priorité supérieure à la <emphasis>condition d'arrêt</emphasis>. Ce n'est qu'une fois le <emphasis>nombre de passages</emphasis> atteint que le débogueur évaluera la <emphasis>condition d'arrêt</emphasis> (si elle existe). S'il n'y en a pas, le débogueur interrompt l'exécution dès que le <emphasis>nombre de passages</emphasis> a été atteint.</para>
       <para>Si ce champ est vide, la valeur par défaut du <emphasis>nombre de passages</emphasis> est zéro. Le point d'arrêt sera pris en compte dès la première fois où il sera atteint.</para>
      </listitem>
     </varlistentry>
    </variablelist></para>
   <para>Un point d'arrêt peut également être défini en sélectionnant une ligne dans l'éditeur et en choisissant l'élément <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Basculer le point d'arrêt</guimenuitem></menuchoice> dans le menu contextuel de l'éditeur ou en cliquant sur l'icône <guibutton>Basculer le point d'arrêt</guibutton> dans la <interface>barre d'outils du débogueur</interface>.</para>
   <tip>
    <para>Des points d'arrêts peuvent être ajoutés même si le débogueur n'est pas lancé, de même que dans une bibliothèque dynamique non encore chargée. Mais ils ne peuvent pas être ajoutés pendant qu'un programme tourne sous le contrôle du débogueur.</para>
   </tip>
  </sect2>
  
  <sect2 id="breaks-edit">
   <title>Modification des points d'arrêt</title>
   <para>Vous pouvez modifier la condition et le nombre de passage en sélectionnant le point d'arrêt dans la liste et en cliquant sur <menuchoice><guimenuitem>Modifier le point d'arrêt</guimenuitem></menuchoice> dans le menu contextuel.</para>
   <para>Modifiez les entrées selon vos souhaits et cliquez sur <guibutton>Valider</guibutton> pour confirmer les modifications.</para>
  </sect2>

  <sect2 id="breaks-del">
   <title>Suppression des points d'arrêt</title>
   <para>Sélectionnez le point d'arrêt dans la fenêtre de la liste et cliquez sur <menuchoice><guimenuitem>Enlever le point d'arrêt</guimenuitem></menuchoice> pour le supprimer.</para>
   <para>Un point d'arrêt existant peut également être supprimé en sélectionnant la ligne dans l'éditeur et en choisissant l'élément <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Basculer le point d'arrêt</guimenuitem></menuchoice> dans le menu principal, l'élément <menuchoice><guimenuitem>Basculer le point d'arrêt</guimenuitem></menuchoice> dans le menu contextuel de l'éditeur ou en cliquant sur l'icône <guibutton>Basculer le point d'arrêt</guibutton> dans la <interface>barre d'outils du débogueur</interface>.</para>
   <para>Vous pouvez supprimer tous les points d'arrêt en cliquant sur <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Enlever tous les points d'arrêt</guimenuitem></menuchoice> ou sur <menuchoice><guimenuitem>Enlever tous les points d'arrêt</guimenuitem></menuchoice> dans le menu contextuel de la liste des points d'arrêt.</para>
  </sect2>

  <sect2 id="breaks-enbdis">
   <title>Activation ou désactivation des points d'arrêt</title>
   <para>Cliquez sur la case à cocher de la colonne « Activé » de la fenêtre <interface>Points d'arrêt</interface> ou sur l'élément <menuchoice><guimenuitem>Activer le point d'arrêt</guimenuitem></menuchoice> du menu contextuel pour activer ou désactiver le point d'arrêt sélectionné. Le point d'arrêt basculera entre activé ou désactivé selon son état actuel.</para>
   <para>Pour désactiver tous les points d'arrêt, cliquez, soit sur <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Désactiver tous les points d'arrêt</guimenuitem></menuchoice>, soit sur <menuchoice><guimenuitem>Désactiver tous les points d'arrêt</guimenuitem></menuchoice> dans le menu contextuel de leur liste.</para>
  </sect2>
 </sect1>

<!-- ============= Debugging: Expressions ====================== -->
 <sect1 id="debugging-expr">
  <title>Expressions</title>

  <sect2 id="var-local">
   <title>Liste des variables locales</title>
   <para>Lorsqu'un programme tourne sous le contrôle du débogueur, vous ouvrez la fenêtre des variables <interface>Locales</interface> en cochant <menuchoice><guisubmenu>Affichage</guisubmenu><guimenuitem>Variables locales</guimenuitem></menuchoice> dans le menu.</para>
   <para>Les variables locales du cadre courant (i.e. la fonction actuellement sous contrôle du programme) sont affichées dans la fenêtre <interface>Locales</interface>. Pendant l'exécution du programme (par ex. pendant un pas à pas) les variables locales seront mises à jour. Si la valeur d'une des variables a changé depuis le précédent pas de débogage, sa valeur est mise en surbrillance en rouge. Les variables sont affichées sous forme arborescente pour une meilleure présentation. <figure>
      <title>Variables locales</title>
      <screenshot>
	  <screeninfo>Variables locales</screeninfo>
       <graphic fileref="figures/local_variables.png" format="PNG" srccredit="naba"/>
      </screenshot>
    </figure></para>
   <para>La valeur d'une variable locale peut être modifiée en la sélectionnant et en cliquant dans la colonne <guilabel>Valeur</guilabel>.</para>
   <note>
    <para><application>gdb</application> est de plus en plus souvent utilisé comme moteur de l'interface graphique. Il a récemment été amélioré dans ce domaine. Il est recommandé d'utiliser la dernière version (6.6) de gdb. Avec les versions antérieures, gdb peut s'arrêter brutalement lorsque l'interface interroge un pointeur de valeur incorrecte (mais inutilisée).</para>
   </note>
  </sect2>

  <sect2 id="var-watch">
   <title>Liste des expressions inspectées</title>
   <para>L'inspection ou l'évaluation d'une expression ne donne le résultat qu'une seule fois. Pour contrôler de manière continue des variables ou des expressions, utilisez <emphasis>Variables inspectées</emphasis>.</para>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Affichage</guisubmenu><guimenuitem>Variables inspectées</guimenuitem></menuchoice> pour afficher la fenêtre <interface>Variables inspectées</interface>.</para>
  </sect2>

  <sect2 id="watch-add">
   <title>Ajout d'une expression à inspecter</title>
   <para>Faites un clic droit sur la fenêtre <interface>Variables inspectées</interface> pour ouvrir le menu contextuel. Choisissez l'élément <guimenuitem>Ajouter à l'inspecteur…</guimenuitem>. Vous avez aussi l'alternative d'utiliser l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Ajouter à l'inspecteur…</guimenuitem></menuchoice>. Une boîte de dialogue vous invitant à saisir l'expression apparaît. L'opération effectuée, cliquez sur <guibutton>Ajouter</guibutton>.</para>
   <para>Par défaut, les expressions inspectées sont mises à jour automatiquement chaque fois que le programme s'arrête. Ce comportement peut être modifié dans la boîte de dialogue « Ajouter à l'inspecteur » ou bien ultérieurement en décochant <guimenuitem>Mise à jour automatique</guimenuitem> dans la fenêtre <interface>Variables inspectées</interface> ouverte avec le menu contextuel. Une expression inspectée peut être mise à jour à la demande en choisissant <guimenuitem>Mettre à jour l'inspecteur</guimenuitem> ou <guimenuitem>Tout mettre à jour</guimenuitem> dans le menu contextuel.</para>
   <para>Il n'est pas nécessaire que le débogueur soit lancé pour ajouter une nouvelle expression à inspecter. Si le débogueur n'est pas lancé ou si l'expression correspondante ne peut pas être trouvée, l'interface essayera de créer l'expression à inspecter chaque fois que le programme est stoppé.</para>
  </sect2>

  <sect2 id="watch-remove">
   <title>Suppression d'une expression à inspecter</title>
   <para>Faites un clic droit sur l'expression inspectée que vous souhaitez supprimer dans la fenêtre <interface>Variables inspectées</interface>, puis choisissez l'élément <guimenuitem>Supprimer</guimenuitem> dans le menu contextuel.</para>
   <para>L'ensemble des variables inspectées peut être supprimé d'un coup en choisissant <guimenuitem>Tout supprimer</guimenuitem> dans le menu contextuel de la fenêtre <interface>Variables inspectées</interface>.</para>
  </sect2>

  <sect2 id="expr-eval">
   <title>Évaluation des expressions</title>
   <para>Lorsque le contrôle est rendu par le programme — peut-être sur un point d'arrêt — il est possible d'évaluer les expressions ou d'inspecter les valeurs des variables du programme. Choisissez, soit l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guimenuitem>Inspecter/Évaluer…</guimenuitem></menuchoice>, soit <menuchoice><guimenuitem>Inspecter/Évaluer…</guimenuitem></menuchoice> dans le menu contextuel de l'éditeur,soit encore cliquez sur le bouton <guibutton>Inspecter</guibutton> dans la <interface>barre d'outils du débogueur</interface>.</para>
   <para>Une fenêtre apparaît affichant l'évaluation de l'expression en évidence dans l'éditeur. Vous pouvez évaluer une nouvelle expression en cliquant sur la colonne <guilabel>Variable</guilabel> et en y saisissant l'expression.</para>
   <para>Vous pouvez ajouter directement cette expression à la liste des expressions inspectées en cliquant sur le bouton <guibutton>Ajouter</guibutton>.</para>
  </sect2>

  <sect2 id="expr-hiver">
   <title>Inspection d'expressions dans la fenêtre de l'éditeur</title>
   <para>Lorsque le débogueur est actif et le programme stoppé, vous pouvez obtenir la valeur d'une expression simplement en plaçant le pointeur de souris à son aplomb et en restant immobile un court instant. Si l'expression est déjà présente dans la fenêtre <interface>Locales</interface> ou <interface>Variables inspectées</interface>, sa valeur est affichée dans une infobulle.</para>
   <para>Cette possibilité ne fonctionne actuellement que pour les variables simples, pas pour les structures ou les tableaux.</para>
  </sect2>

 </sect1>

<!-- ============= Debugging: Program Stack ====================== -->
 <sect1 id="debugging-stack">
  <title>Trace de la pile</title>

  <sect2 id="stack-win">
   <title>Fenêtre de la pile</title>
   <para>La fenêtre <interface>Pile</interface> affiche le contenu de la pile du programme. Elle donne la liste de toutes les fonctions et leurs paramètres dans l'ordre d'appel. Chaque appel est également représenté par un nombre appelé <emphasis>cadre</emphasis>. Chaque appel dans la trace est situé dans un cadre différent. La numérotation commence par le cadre 0 (la dernière fonction appelée) et croît au fur et à mesure que l'imbrication des appels de fonctions devient profond.</para>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Affichage</guisubmenu><guimenuitem>Pile</guimenuitem></menuchoice> pour ouvrir la trace de la pile du programme en cours de débogage.</para>
   <para>
    <figure>
      <title>Fenêtre « Pile »</title>
      <screenshot>
	   <screeninfo>Fenêtre « Pile »</screeninfo>
       <graphic fileref="figures/stack.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
   <para>Un petite flèche pointe vers le cadre actuellement sélectionné dans la trace de la pile. Par défaut, c'est le cadre 0, la dernière fonction appelée. Toutes les évaluations et inspections d'expressions ou de variables se font en référence au cadre sélectionné. La portée des variables ou expressions en cours d'évaluation est limitée à ce seul cadre sélectionné. Il en est de même uniquement pour les nouvelles expressions dans l'inspecteur.</para>
  </sect2>
  
  <sect2 id="stack-frame">
   <title>Définition du cadre actuel</title>
   <para>Un double-clic sur un cadre dans la trace de la pile le définit comme étant actuellement sélectionné. La flèche pointera vers ce dernier, indiquant qu'il a été sélectionné en tant que cadre courant. Vous pouvez opérer autrement : ouvrez le menu contextuel par un clic droit dans la fenêtre <interface>Pile</interface> et choisissez l'élément de menu <guimenuitem>Définir le cadre actuel</guimenuitem> pour le définir.</para>
   <para>Changer le cadre de la pile entraîne un changement du contenu de la fenêtre <interface>Locales</interface>, mais pas de la fenêtre <interface>Variables inspectées</interface>, car chaque expression est évaluée dans le cadre utilisé au moment de sa définition.</para>
  </sect2>
 </sect1>

<!-- ============= Debugging: Program Thread ====================== -->
 <sect1 id="debugging-thread">
  <title>Thread</title>

  <sect2 id="thread-win">
   <title>Fenêtre des thread</title>
   <para>La fenêtre <interface>Thread</interface> affiche tous les threads utilisés par le programme et indique le thread actuel. Choisissez l'élément de menu <menuchoice><guisubmenu>Affichage</guisubmenu><guimenuitem>Thread</guimenuitem></menuchoice> pour ouvrir cette fenêtre.</para>
   <para>Un petite flèche pointe vers le thread en cours. Lorsque le programme est stoppé, le thread pointé est le thread dont l'exécution est interrompue. Chaque thread possède son propre cadre de pile, donc changer le thread en cours changera également le cadre de pile actuel.</para>
  </sect2>

  <sect2 id="set-thread">
   <title>Paramétrage du thread en cours</title>
   <para>Un double-clic sur un thread dans la liste des threads le définit comme étant actuellement sélectionné. La flèche pointera vers ce dernier, indiquant qu'il a été sélectionné en tant que thread courant. Vous pouvez opérer autrement : ouvrez le menu contextuel par un clic droit dans la fenêtre <interface>Thread</interface> et choisissez l'élément de menu <guimenuitem>Définir le thread actuel</guimenuitem> pour le définir.</para>
   <para>Changer de thread entraîne un changement des valeurs dans les registres CPU ainsi que celui du cadre de pile courant, donc la fenêtre <interface>Locales</interface> sera également modifiée.</para>
  </sect2>
 </sect1>

<!-- ============= Debugging: CPU ====================== -->
 <sect1 id="debugging-cpu">
  <title>Processeur</title>

  <sect2 id="cpu-regs">
   <title>Fenêtre des registres</title>
   <para>Il est possible d'examiner le contenu des registres internes du CPU (microprocesseur). Choisissez l'élément de menu <menuchoice><guisubmenu>Affichage</guisubmenu><guimenuitem>Registres</guimenuitem></menuchoice>. Une fenêtre apparaît, affichant la liste de tous les registres disponibles du microprocesseur avec leur contenu respectif.</para>
   <para>Si une valeur de registre a été modifiée depuis le précédent pas de débogage, sa valeur est mise en surbrillance en rouge. Il est possible de modifier une valeur de registre en le sélectionnant et en cliquant dans la colonne <guilabel>Valeur</guilabel>.</para>
  </sect2>

  <sect2 id="cpu-memory">
   <title>Fenêtre mémoire</title>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Affichage</guisubmenu><guimenuitem>Mémoire</guimenuitem></menuchoice> pour ouvrir la fenêtre <interface>Mémoire</interface> du programme en cours de débogage. Cette fenêtre affiche le contenu de toute la mémoire.</para>
   <para>La première colonne affiche les adresses mémoires en hexadécimal, la seconde octet par octet le contenu de la mémoire en hexadécimal et la dernière le même contenu en ASCII.</para>
   <para>L'espace d'adressage d'un simple microprocesseur 32-bits est déjà assez grand (4 gigaoctets), il vous sera donc très difficile de vous rendre à une adresse précise à l'aide de la barre de défilement. Mais, si vous cliquez avec le bouton droit de la souris pour afficher un menu contextuel et choisissez <menuchoice><guimenuitem>Aller à l'adresse</guimenuitem></menuchoice>, vous accédez à un petit contrôle d'édition dans lequel il vous est possible de saisir une adresse en notation hexadécimale.</para>
  </sect2>

  <sect2 id="cpu-disassembly">
   <title>Fenêtre « Désassemblage »</title>
   <para>Choisissez l'élément de menu <menuchoice><guisubmenu>Affichage</guisubmenu><guimenuitem>Désassemblage</guimenuitem></menuchoice> pour ouvrir la fenêtre <interface>Désassemblage</interface> du programme en cours de débogage.</para>
   <para>La première colonne affiche les adresses en hexadécimal. Dans la seconde colonne, vous avez, soit une étiquette affichée dès le début de la ligne et terminée par deux points, soit une instruction en langage d'assemblage indentée de 4 espaces.</para>
   <para>À nouveau, comme l'espace d'adressage est très grand, la barre de défilement est inutilisable. Cliquez avec le bouton droit de la souris pour afficher un menu contextuel et choisissez <menuchoice><guimenuitem>Aller à l'adresse</guimenuitem></menuchoice>. Vous obtenez un petit contrôle d'édition dans lequel il vous est possible de saisir une adresse en notation hexadécimale. Lorsque le programme s'arrête, l'index dans la fenêtre de désassemblage se déplace pour pointer sur la position du compteur du programme.</para>
  </sect2>
 </sect1>

<!-- Debugger: Others-->
 <sect1 id="debugger-others">
  <title>Autres</title>

  <para>Il existe quelques autres fonctionnalités de débogage, moins fréquemment utilisées et pas très bien intégrées dans l'interface, mais qui fonctionnent néanmoins.</para>

  <sect2 id="dbg-dyna-libs">
   <title>Bibliothèques chargées de manière dynamique</title>
   <para>Pour obtenir une liste des bibliothèques dynamiques utilisées par un programme, choisissez l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guisubmenu>Informations</guisubmenu><guimenuitem>Bibliothèques partagées</guimenuitem></menuchoice>. Une fenêtre affiche alors la liste de toutes les bibliothèques partagées que le programme a chargées ainsi que leur emplacement dans la mémoire. Elle indique également si la table des symboles de la bibliothèque a été chargée ou pas (Oui/Non).</para>
   <para>
    <figure>
      <title>Fenêtre « Bibliothèques partagées »</title>
      <screenshot>
	   <screeninfo>Fenêtre « Bibliothèques partagées »</screeninfo>
       <graphic fileref="figures/sharedlibs.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
  </sect2>

  <sect2 id="dbg-signal">
   <title>Signaux du noyau</title>
   <para>Les signaux du noyau sont un moyen d'échanger des informations entre processus sous Linux. La liste des signaux disponibles pour un programme s'affiche en choisissant l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guisubmenu>Informations</guisubmenu><guimenuitem>Signaux du noyau</guimenuitem></menuchoice>. Une fenêtre apparaît contenant la liste de tous les signaux disponibles dans le système accompagnés d'une courte description pour chacun.</para>
   <para>
    <figure>
      <title>Fenêtre « Signaux du noyau »</title>
      <screenshot>
	   <screeninfo>Fenêtre « Signaux du noyau »</screeninfo>
       <graphic fileref="figures/signals.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
   <para>Il y a trois colonnes qui indiquent quoi faire lorsqu'un signal est reçu :</para>
   
   <orderedlist>
    <listitem>
     <para><emphasis>Arrête</emphasis> — qui indique au débogueur d'arrêter l'exécution du programme (et de rendre le contrôle) lorsque le programme reçoit ce signal.</para>
    </listitem>
    <listitem>
     <para><emphasis>Affiche</emphasis> — qui indique au débogueur d'afficher le signal reçu.</para>
    </listitem>
    <listitem>
     <para><emphasis>Transmet</emphasis> — qui indique au débogueur de transmettre le signal au programme.</para>
    </listitem>
   </orderedlist>
   <note>
    <para>Le menu contextuel affiché lorsque vous cliquez avec le bouton droit de la souris n'a que des éléments inactifs car les fonctions correspondantes ne sont pas encore implémentées.</para>
   </note>
  </sect2>

  <sect2 id="dbg-files">
   <title>Informations sur les fichiers utilisés</title>
   <para>Vous pouvez obtenir de l'information sur les fichiers utilisés par le programme en cours de débogage en choisissant l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guisubmenu>Informations</guisubmenu><guimenuitem>Fichiers cibles</guimenuitem></menuchoice>. Une fenêtre s'ouvre pour afficher ces informations.</para>
  </sect2>

  <sect2 id="dbg-program">
   <title>Informations sur le programme débogué</title>
   <para>Vous pouvez obtenir de l'information sur le programme en cours de débogage en choisissant l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guisubmenu>Informations</guisubmenu><guimenuitem>Programme</guimenuitem></menuchoice>. Une fenêtre s'ouvre pour afficher ces informations.</para>
  </sect2>
 
  <sect2 id="dbg-kernel">
   <title>Informations sur la structure du noyau</title>
   <para>Vous pouvez obtenir de l'information sur les données noyau pour le processus en cours en choisissant l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guisubmenu>Informations</guisubmenu><guimenuitem>Informations sur la « structure utilisateur » du noyau</guimenuitem></menuchoice>. Une fenêtre s'ouvre pour afficher ces informations.</para>
  </sect2>

  <sect2 id="var-global">
   <title>Informations sur les variables globales</title>
   <para>Vous pouvez obtenir la liste de toutes les variables globales en choisissant l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guisubmenu>Informations</guisubmenu><guimenuitem>Informations sur les variables globales</guimenuitem></menuchoice>. Une fenêtre s'ouvre pour afficher ces informations.</para>
  </sect2>

  <sect2 id="stack-frame-info">
   <title>Informations sur le cadre actuel</title>
   <para>Vous pouvez obtenir des informations sur le cadre actuellement sélectionné en choisissant l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guisubmenu>Informations</guisubmenu><guimenuitem>Informations sur le cadre actuel</guimenuitem></menuchoice>. Une fenêtre s'ouvre pour afficher ces informations.</para>
  </sect2>

  <sect2 id="stack-arg-info">
   <title>Informations sur les paramètres de la fonction actuelle</title>
   <para>Vous pouvez obtenir des informations sur les paramètres de la fonction actuelle en choisissant l'élément de menu <menuchoice><guisubmenu>Déboguer</guisubmenu><guisubmenu>Informations</guisubmenu><guimenuitem>Informations sur les paramètres de la fonction</guimenuitem></menuchoice>. Une fenêtre s'ouvre pour afficher ces informations.</para>
  </sect2>
  
  <sect2 id="dbg-command">
   <title>Commande utilisateur</title>
   <para>Pour envoyer une commande directement au moteur de débogage, choisissez l'élément de menu <menuchoice><guimenu>Déboguer</guimenu><guimenuitem>Commande du débogueur</guimenuitem></menuchoice>. Une petite boîte de dialogue apparaît dans laquelle vous pouvez saisir des commandes qui sont envoyées au débogueur lorsque vous pressez <keycap>Entrée</keycap>.</para>
   <note>
    <para>L'interface envoie cette commande directement au moteur sans effectuer aucun contrôle. Par exemple, si vous définissez un point d'arrêt de cette façon, il n'apparaît pas dans la fenêtre <interface>Points d'arrêt</interface>. Il vaut mieux éviter d'utiliser cette commande à moins que vous ne sachiez exactement ce que vous faites.</para>
   </note>
  </sect2>
 </sect1> 

 </chapter>

 <!-- Glade Interface Designer -->
 <chapter id="glade">
	<title>Concepteur d'interface Glade</title>

	<sect1>
		<title>Démarrage rapide</title>
		<para>Si vous ne voulez pas lire tout cet ennuyeux manuel, voici quelques étapes pour être totalement prêts à utiliser Glade : <orderedlist>
				<listitem><para>Le projet doit contenir des fichiers Glade ouverts.</para></listitem>
				<listitem><para>Contrairement au concepteur d'interface original Glade, le greffon Anjuta utilise le double-clic pour créer les gestionnaires du signal par défaut. Vous pouvez cliquer sur les composants graphiques (par ex. changer l'onglet actuel dans un GtkNotebook) en gardant pressée la touche « Windows » ou « Super ».</para></listitem>
				<listitem><para>Ouvrez <menuchoice><guimenuitem>Préférences</guimenuitem><guimenuitem>Concepteur de GUI Glade</guimenuitem></menuchoice> et cochez les trois options du haut <guilabel>Insérer un gestionnaire à l'édition</guilabel>, <guilabel>Agencement de conception séparé</guilabel> et <guilabel>Ajouter automatiquement les ressources</guilabel>.</para></listitem>
				<listitem><para>Cochez <menuchoice><guimenuitem>Affichage</guimenuitem><guimenuitem>Concepteur</guimenuitem></menuchoice> et mettez cette fenêtre à un meilleur emplacement.</para></listitem>
				<listitem><para>Activez le fichier Glade dans la zone de conception et le fichier du code source devant contenir les signaux d'appel du fichier Glade, puis faites <menuchoice><guimenuitem>Glade</guimenuitem><guimenuitem>Associer le dernier concepteur et le dernier éditeur</guimenuitem></menuchoice>.</para></listitem>
				<listitem><para>Éventuellement, choisissez une cible pour les images ou autres ressources dans le gestionnaire de projet et sélectionnez <guilabel>Définir comme cible de ressource par défaut</guilabel> dans le menu contextuel.</para></listitem>
			</orderedlist></para>
	</sect1>
	
	<sect1>
		<title>Généralités sur l'utilisation de Glade</title>
		<para>Le greffon Glade retranscrit presque totalement les fonctionnalités du concepteur d'interface Glade autonome, mais il y a quelques particularités. Les quatre fenêtres du concepteur Glade sont la zone de conception, la palette, l'inspecteur des composants graphiques et l'éditeur de propriétés. Ils ont la même fonction que dans le concepteur Glade autonome : veuillez donc consulter le <ulink type="help" url="ghelp:glade">Manuel du concepteur d'interface Glade</ulink> pour leur description. Une fonctionnalité supplémentaire permettant d'utiliser plus efficacement l'infrastructure de Anjuta est décrite ici.</para>
	</sect1>

	<sect1>
		<title>Association éditeur et concepteur</title>
		<para>Vous pouvez associer l'éditeur de texte et le concepteur Glade : l'association permet d'aller alternativement de l'un à l'autre et d'insérer automatiquement des ébauches pour les nouveaux gestionnaires ajoutés. Il est possible d'associer plus d'un éditeur à un même concepteur. Sera utilisé le dernier éditeur activé ou celui associé au composant graphique actuellement au plus haut niveau. Il y a deux manières d'associer éditeur et concepteur. La première consiste à utiliser la « Boîte de dialogue des associations » ; la seconde à choisir le concepteur et le document de l'éditeur dans n'importe quel ordre, puis de sélectionner l'élément de menu <menuchoice><guimenuitem>Glade</guimenuitem><guimenuitem>Associer le dernier concepteur et le dernier éditeur</guimenuitem></menuchoice>.</para>
	</sect1>

	<sect1>
		<title>Boîte de dialogue des associations</title>
		<para>Elle vous permet de créer et de gérer les associations. Pour créer une association, choisissez un concepteur et un éditeur dans les boîtes combinées et cliquez sur <guibutton>Associer</guibutton>. Vous pouvez également sélectionner le document en l'activant dans le gestionnaire de documents ou dans la liste des fenêtres du menu principal. La liste au centre de la boîte de dialogue affiche les associations existantes. En dessous, des contrôles servent à modifier les propriétés de l'association. Voici leur description : <variablelist>
				<varlistentry>
					<term><guilabel>Expression régulière spéciale</guilabel></term>
					<listitem><para>Elle s'utilise pour définir une position personnalisée pour l'insertion des ébauches.</para></listitem>
				</varlistentry>
				<varlistentry>
					<term><guilabel>Nom du composant graphique</guilabel></term>
					<listitem><para>Il indique le nom du composant graphique de plus haut niveau auquel se rapporte cette association.</para></listitem>
				</varlistentry>
				<varlistentry id="glade-position-type">
					<term><guilabel>Type de position</guilabel></term>
					<listitem><para>Il décrit l'emplacement où l'ébauche de gestionnaire sera insérée. <guilabel>Après le « begin »</guilabel> signifie après la marque spéciale (qui peut être saisie dans le champ <guilabel>Expression régulière spéciale</guilabel>) et <guilabel>Avant le « end »</guilabel> qui signifie avant la marque de fin spéciale. La marque de début par défaut est /* nom_fenetre callbacks */ et la marque de fin par défaut est /* end of nom_fenetre callbacks */. Il est possible d'omettre nom_fenetre.</para></listitem>
				</varlistentry>
			</variablelist></para>
	</sect1>
	
	<sect1 id="glade-default-signal">
		<title>Signal par défaut</title>
		<para>Un double-clic sur un composant graphique dans la zone de conception crée un nouveau gestionnaire pour le signal par défaut en utilisant un modèle prédéfini pour sa dénomination. Par exemple, le signal par défaut est « clicked » pour un bouton, « toggled » pour une case à cocher, etc. Si l'option <guilabel>Insérer un gestionnaire à l'édition</guilabel> est activée alors la nouvelle ébauche de gestionnaire sera insérée à une position qui dépend du réglage de <guilabel>Type de position</guilabel>.</para>
	</sect1>
	
	<sect1>
		<title>Insertion d'une ébauche</title>
		<para>L'un des résultats les plus remarquables de l'intégration de <application>Anjuta</application> et de <application>Glade</application> est la création automatique d'ébauches de gestionnaire ; cette création vous épargne beaucoup de travail de routine étant donné qu'elle se fait automatiquement.</para>
		<para>Il y a plusieurs façons de créer une ébauche : <itemizedlist>
				<listitem><para>automatiquement, si l'option <guilabel>Insérer un gestionnaire à l'édition</guilabel> est activée,</para></listitem>
				<listitem><para>en utilisant l'élément <menuchoice><guimenuitem>Glade</guimenuitem><guimenuitem>Insérer une ébauche de gestionnaire (position auto)</guimenuitem></menuchoice> du menu principal,</para></listitem>
				<listitem><para>en utilisant l'élément <guilabel>Insérer une ébauche de gestionnaire</guilabel> du menu contextuel des documents texte.</para></listitem>
			</itemizedlist></para>
	</sect1>

	<sect1>
		<title>Préférences</title>
		<variablelist>
			<varlistentry>
				<term><guilabel>Insérer un gestionnaire à l'édition</guilabel></term>
				<listitem><para>Active l'insertion d'une ébauche de gestionnaire dans l'éditeur associé après avoir saisi un nouveau gestionnaire dans l'éditeur de signaux ou créé un <link linkend="glade-default-signal">gestionnaire de signal par défaut</link>.</para></listitem>
			</varlistentry>
			<varlistentry>
				<term><guilabel>Agencement de conception séparé</guilabel></term>
				<listitem><para>Détache la fenêtre de conception de l'interface hors du gestionnaire de document afin de pouvoir la disposer séparément de l'éditeur de texte. </para></listitem>
			</varlistentry>
			<varlistentry>
				<term><guilabel>Ajouter automatiquement les ressources</guilabel></term>
				<listitem><para>Si la case est cochée, toutes les ressources (par ex. les images) sont ajoutées à la cible dans le projet actuel. Vous pouvez choisir la cible en utilisant le menu contextuel du gestionnaire de projet ou en saisissant l'identifiant de la cible dans le champ sous la case à cocher.</para></listitem>
			</varlistentry>
			<varlistentry>
				<term><guilabel>Modèle de gestionnaire</guilabel></term>
				<listitem><para>Vous pouvez choisir là un des deux formats de dénomination automatique des gestionnaires de signaux.</para></listitem>
			</varlistentry>
		</variablelist>
	</sect1>

</chapter>

 <!-- Preferences -->
 <!-- Preferences -->
 <chapter id="preferences">
  <title>Préférences</title>
  <para>Les préférences vous permettent de configurer <application>Anjuta</application> selon vos goûts. Choisissez <menuchoice><guimenu>Édition</guimenu><guimenuitem>Préférences</guimenuitem></menuchoice> pour faire apparaître la boîte de dialogue des préférences. Quelques préférences sont explicités ci-après.</para>
  <sect1 id="prefs-general"><title>Général</title>
    <orderedlist>
     <listitem><para>Le <emphasis>répertoire du projet</emphasis> est le chemin qui mène là où vous avez l'intention d'enregistrer tous vos projets. L'assistant Application créera les nouveaux projets uniquement dans ce répertoire. Le répertoire par défaut est ~/Projets, ce qui convient à la plupart des utilisateurs.</para>
     </listitem>
      <listitem><para><emphasis>Informations utilisateur :</emphasis> indique votre nom et votre adresse électronique. Ces informations ne seront pas utilisées pour signer des dépôts de logiciels, mais plutôt pour créer les entrées du « ChangeLog » et autres insertions de texte.</para>
      </listitem>
     </orderedlist>
    </sect1>
    <sect1 id="prefs-files"><title>Gestionnaire de fichiers</title>
    <orderedlist>
     <listitem><para>Le <emphasis>Répertoire racine si aucun projet n'est ouvert</emphasis> indique le chemin vers lequel la racine du gestionnaire de fichiers pointe si aucun projet n'est en cours.</para>
     </listitem>
      <listitem><para><emphasis>Filtre de fichiers :</emphasis> vous pouvez filtrer certains fichiers dans l'arborescence, par exemple, les fichiers cachés ou bien les fichiers ignorés par le système de contrôle de version étant donné qu'ils sont générés au moment de la construction et ne doivent pas être modifiés.</para>
      </listitem>
     </orderedlist>
    </sect1>
 </chapter>

 <!-- Tools -->
 <!-- new chapter -->
 <chapter id="tools">
  <title>Outils définis par l'utilisateur</title>

  <sect1 id="tools-intro">
  <title>Introduction</title>
  <para>Parfois vous trouverez que les fonctionnalités intégrées fournies par Anjuta sont insuffisantes. Dans ce cas, vous pourrez alors être tenté, soit d'ajouter la fonctionnalité vous-même dans le code de Anjuta, soit de déposer une requête pour que la fonctionnalité soit implémentée. Toutefois, l'une ou l'autre de ces approches sera, selon toute probabilité, lente et problématique, surtout si votre outil est spécialisé. En de telles circonstances, il est préférable d'utiliser à la place la structure des outils Anjuta.</para>

  <para>Anjuta fournit, pour étendre ses fonctionnalités, une structure puissante de définition d'outils personnalisés. Les outils ont accès à presque toutes les fonctionnalités de l'EDI via l'utilisation des variables. Vous pouvez ajouter des outils à n'importe quel élément de menu, définir l'entrée, la sortie et la redirection des erreurs dans la structure GUI ainsi que fournir des paramètres en ligne de commande à l'outil.</para>
	<note>
	<para>Le greffon Outils doit être activé pour utiliser cette fonctionnalité !</para>
	</note>
  </sect1>

  <sect1 id="tools-example">
  <title>Exemples d'outils</title>
  <para>Voici un exemple simple sur la façon d'utiliser le greffon Outils pour intégrer le script de génération du « ChangeLog » de GNOME.</para>

  <figure id="tool-list">
    <title>L'éditeur d'outils</title>
    <screenshot>
	<screeninfo>L'éditeur d'outils</screeninfo>
     <graphic fileref="figures/tool-editor.png" format="PNG" srccredit="jhs"/>
    </screenshot>
   </figure>

  </sect1>

</chapter>

 <!-- Authors -->
  <chapter id="authors">
  <title>Auteurs</title>
   <para>Le projet <application>Anjuta</application> a été créé par Naba Kumar. <ulink type="http" url="http://anjuta.org/team.html">Cette page</ulink> affiche tous les contributeurs à Anjuta.</para>

   <para>Pour plus d'informations sur <application>Anjuta</application>, veuillez visiter le site Web du projet <ulink type="http" url="http://anjuta.org/">http://anjuta.org </ulink>. Les rapports d'anomalies doivent être effectués en utilisant Bug Tracker vers le site de développement du projet <ulink type="http" url="http://www.sourceforge.net/projects/anjuta"> http://www.sourceforge.net/projects/anjuta </ulink>.</para>
   
   <para>Ce manuel a été écrit par Naba Kumar, Andy Piper, Biswapesh Chattopadhyay et Johannes Schmid. Veuillez envoyer tous vos commentaires ou suggestions concernant ce manuel à la liste de discussion Anjuta Devel <email>anjuta-devel-list@gnome.org</email>. Les commentaires peuvent également être envoyés via « project trackers » sur SourceForge.</para> 
</chapter>


 <!-- License -->
 <chapter id="license">
  <title>Licence</title>
   <para>Ce programme est un logiciel libre ; vous pouvez le redistribuer et/ou le modifier selon les termes de la <ulink type="ghelp" url="gnome-help:gpl"> Licence Publique Générale GNU </ulink> publiée par la Free Software Foundation ; soit la version 2 ou (à votre discrétion) toute autre version ultérieure.</para>
   <para>Ce programme est distribué dans l'espoir qu'il sera utile, mais SANS AUCUNE GARANTIE ; sans même une garantie implicite de QUALITÉ LOYALE ET MARCHANDE ou DE CONFORMITÉ À UNE UTILISATION PARTICULIÈRE. Voir la <citetitle>Licence Publique Générale GNU</citetitle> pour plus de détails.</para>
   <para>Une copie de la licence <citetitle>GNU General Public License</citetitle> est annexée au <citetitle>Guide des utilisateurs de GNOME</citetitle>. Vous pouvez obtenir une copie de la licence <citetitle>GNU General Public License</citetitle> de la Free Software Foundation en visitant leur <ulink type="http" url="http://www.fsf.org">site Web</ulink> ou en écrivant à <address> Free Software Foundation, Inc. <street>51 Franklin Street</street> Fifth Floor <city>Boston</city>, <state>MA</state><postcode>02110-1301</postcode><country>USA</country></address></para>
</chapter>

</book>
