
<!--
Please keep the formatting simple.
Do not indent XML constructs.
Keep lines at 80 characters length maximum.
-->

<chapter id="getting-started">

<chapterinfo>
<authorgroup>
<author
><firstname
>Bernd</firstname
><surname
>Pol</surname
></author>
<othercredit role="translator"
><firstname
>Joëlle</firstname
><surname
>Cornavin</surname
><affiliation
><address
><email
>jcornavi@club-internet.fr</email
></address
></affiliation
><contrib
>Traduction française </contrib
></othercredit
> <othercredit role="translator"
><firstname
>Ludovic</firstname
><surname
>Grossard</surname
><affiliation
><address
><email
>grossard@kde.org</email
></address
></affiliation
><contrib
>Traduction française </contrib
></othercredit
> 
</authorgroup>
</chapterinfo>

<title
>Premiers pas avec &kdevelop; &mdash; visite guidée</title>

<para
>Maintenant que vous avez installé votre &EDI; &kdevelop;, comment allez-vous en faire bon usage ? Comme c'est une application complexe, la courbe d'apprentissage risque d'être quelque peu abrupte, en particulier si vous n'êtes pas déjà habitué à ce type d'&EDI; (environnement de développement intégré).</para>

<para
>Nous essaierons d'adoucir un peu cette courbe en étudiant pas à pas les constituants essentiels d'une application KDE simple en C++. Ainsi, nous jetterons un coup d'œil (superficiel) aux aspects suivants :</para>

<simplelist>
<member
><link linkend="gettingstarted-overview"
>Un premier aperçu &mdash; les éléments de l'interface utilisateur de l'&EDI; &kdevelop;.</link
></member>
<member
><link linkend="gettingstarted-configure"
>Un peu de configuration initiale.</link
></member>
<member
><link linkend="gettingstarted-new"
>Comment créer un nouveau projet.</link>
</member>
<member
><link linkend="gettingstarted-edit"
>Quelques astuces sur la manipulation des documents.</link
></member>
<member
><link linkend="gettingstarted-compile"
>Comment compiler l'application dans ce projet.</link
></member>
<member
><link linkend="gettingstarted-extend"
>Comment ajouter des classes et d'autres détails à votre projet.</link
></member>
<member
><link linkend="gettingstarted-debug"
>Que faire pour déboguer l'application.</link
></member>
<member
><link linkend="gettingstarted-doc"
>Quelques outils de base pour construire un programme ou une documentation utilisateur.</link
></member>
<member
><link linkend="gettingstarted-keys"
>Et pour finir, les raccourcis clavier</link
></member>
</simplelist>

<para
>Avant de commencer, une notion importante devra être éclaircie.</para>

<formalpara>
<title
>Qu'espérer ?</title>
<para
>Comme indiqué, &kdevelop; est un <emphasis
>environnement de développement intégré</emphasis
>. Cela signifie en substance que &kdevelop; n'est pas un outil de développement en soi, mais plutôt une interface graphique permettant d'accéder aisément à une vaste palette d'outils de développement, dont une grande partie nécessiterait réellement l'exécution de commandes clavier complexes à partir d'un terminal en mode texte.</para>
</formalpara>

<para
>Bien que &kdevelop; facilite beaucoup de ces tâches de programmation, une grande partie de la complexité de cet ensemble d'outils demeure cependant, ce qui signifie qu'afin d'appréhender complètement l'&EDI; &kdevelop;, il vous faudra encore une bonne compréhension de ces outils fonctionnant en réalité en arrière-plan.</para>

<para
>Par conséquent, nous ne pouvons pas vous apprendre comment construire des logiciels, mais plutôt vous présenter un peu la manière dont &kdevelop; a été conçu pour faciliter un tel processus de construction. Si vous souhaitez en savoir plus sur la finalité d'un environnement de développement intégré, jetez un coup d'œil à la vue d'ensemble historique <link linkend="unixdev"
>Développement sous &UNIX;</link
> et dedans, tout particulièrement au chapitre <link linkend="unixdev-ide"
>Intégrer des concepts et des outils</link
>.</para>

<note>
<para
>Les exposés suivants s'appliquent au cas par défaut, où &kdevelop; démarre en <guilabel
>mode fenêtre IDEAl simplifié</guilabel
>. Si vous êtes déjà passé à un autre mode d'interface utilisateur, il se peut qu'il n'y ait pas certains éléments comme décrit ou qu'ils se comportent de manière légèrement différente. Si vous n'êtes pas sûr du mode d'interface utilisateur qu'utilise votre &kdevelop; actuellement, vérifiez avec la boîte de dialogue <menuchoice
><guimenu
>Configuration</guimenu
> <guimenuitem
>Configurer KDevelop...</guimenuitem
> <guimenuitem
>Interface utilisateur</guimenuitem
></menuchoice
>.</para>
</note>

<sect1 id="gettingstarted-overview">
<title
>Un tout premier coup d'œil à &kdevelop;</title>

<para
>Voici en gros ce que vous verrez lorsque vous aurez démarré &kdevelop; pour la première fois. Vous trouverez des informations préliminaires sur :</para>

<simplelist>
<member
><link linkend="gettingstarted-overview-basic"
>Qu'y a-t-il en surface ?</link
></member>
<member
><link linkend="gettingstarted-overview-help"
>Comment obtenir de l'aide.</link
></member>
<member
><link linkend="gettingstarted-overview-menu"
>Qu'y a-t-il dans les menus ?</link
></member>
<member
><link linkend="gettingstarted-overview-tools"
>À quoi servent ces vues des outils ?</link
></member>
</simplelist>

<sect2 id="gettingstarted-overview-basic">
<title
>En surface</title>

<para
>Quand vous démarrez &kdevelop; pour la première fois, vous obtenez un affichage similaire à celui-ci :</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="empty-ide.png" format="PNG"/>
</imageobject>
<caption>
<para
>La disposition initiale de &kdevelop;</para>
<para
>(En fait, la fenêtre initiale de &kdevelop; sera plus grande mais les éléments que vous voyez sont les mêmes.)</para>
</caption>
</mediaobject>
</screenshot>

<formalpara>
<title
>Zone d'espace de travail et onglets des vues des outils</title>
<para
>Dans ce cas initial, &kdevelop; utilise ce qu'on appelle le <link linkend="uimodes-survey"
>mode d'interface utilisateur IDEAl</link
>. Une zone d'espace de travail d'une taille maximale possible est entourée à gauche, en bas et à droite par une série de boutons qui agissent de la même manière que des onglets sur un affichage à onglets. Si vous cliquez sur un de ces onglets, une <emphasis
>fenêtre des vues des outils</emphasis
> s'ouvre, qui vous permet de travailler sur une tâche précise.</para>
</formalpara>

<formalpara>
<title
>Barres de menus et barres d'outils</title>
<para
>Dans la partie supérieure, se trouve l'habituelle barre de menus, suivie de plusieurs lignes de barres d'outils, dont certaines sont au départ vides. Elles se peupleront dès l'instant où il y aura un projet ouvert pour un travail réel.</para>
</formalpara>

<formalpara>
<title
>Barre d'état</title>
<para
>Enfin, il y a une barre d'état au bas de la fenêtre, affichant de courtes informations sur plusieurs tâches.</para>
</formalpara>
</sect2>

<sect2 id="gettingstarted-overview-help">
<title
>Comment obtenir de l'aide</title>

<para
>Outre le menu <guimenu
>Aide</guimenu
> qui offre des réponses à des questions données, la barre d'état et deux sortes d'infobulles fournissent quelques brèves informations.</para>

<formalpara>
<title
>Que fait exactement cet élément de menu ?</title>
<para
>Lorsque vous placez le curseur de la souris sur un élément de menu, vous voyez habituellement de courtes informations s'afficher dans la barre d'état. Même si le plus souvent celles-ci répètent juste le nom de la sélection, elles fourniront dans certains cas des informations complémentaires sur l'objectif de la commande du menu.</para>
</formalpara>

<formalpara>
<title
>Quel est le nom de cet élément ?</title>
<para
>Sur de nombreux éléments, une infobulle contenant le nom abrégé de la fonction apparaît lorsque vous placez le curseur dessus pendant quelques secondes. Cette fonction est très utile pour s'orienter rapidement sur les onglets de barres d'outils ou les vues des outils dans le mode IDEAl, lorsque l'&EDI; a été configuré pour afficher des icônes uniquement sur ces boutons.</para>
</formalpara>

<formalpara>
<title
>Que fait exactement cet élément ?</title>
<para
>D'autres informations sont disponibles grâce à l'aide étendue sous forme d'infobulles pour de nombreux éléments de l'&EDI;. Sélectionnez <menuchoice
><guimenu
>Aide</guimenu
> <guimenuitem
>Qu'est-ce que c'est ?</guimenuitem
></menuchoice
> ou appuyez sur <keycombo
><keycap
>&Maj;</keycap
><keycap
>F1</keycap
></keycombo
> puis, avec le curseur du point d'interrogation, sélectionnez l'élément sur lequel vous voulez en savoir plus. Vous pouvez également ouvrir n'importe quel menu de cette manière et cliquer sur un élément de menu particulier (actif ainsi que ceux qui sont grisés car désactivés) pour voir s'il y a d'autres informations disponibles.</para>
</formalpara>
</sect2>

<sect2 id="gettingstarted-overview-menu">
<title
>Qu'y a-t-il dans les menus ?</title>

<para
>Il y a dix menus qu'il est possible de sélectionner sur la barre de menus. La plupart d'entre eux se peuplent entièrement dès lors qu'un projet est ouvert pour le travail réel, tandis que d'autres nécessitent au moins qu'un document soit ouvert dans une fenêtre d'édition. En bref, ils permettent les types d'actions suivants.</para>

<note>
<para
>Ce n'est qu'une vue d'ensemble préliminaire. Pour obtenir une description détaillée, reportez-vous à la <link linkend="commands"
>référence des commandes</link
>.</para>
</note>

<variablelist>
<varlistentry>
<term
><guimenu
>Fichier</guimenu
></term>
<listitem>
<formalpara>
<title
>Actions habituelles</title>
<para
>Il est parfaitement standard :il permet de créer, ouvrir, enregistrer, imprimer et fermer des fichiers de documents, ainsi que de quitter l'application &kdevelop; comme d'habitude.</para>
</formalpara>

<formalpara>
<title
>Tout annuler</title>
<para
>Cet élément permet d'annuler tous les changements récents encore non enregistrés en rechargeant le fichier depuis le disque. Il fonctionne sur tout fichier que vous modifiez, mais non sur ceux qui font partie d'un projet.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Édition</guimenu
></term>
<listitem>
<para
>Ce menu n'est utile que si un document est ouvert.</para>

<formalpara>
<title
>Actions habituelles</title>
<para
>Il prévoit les actions habituelles annuler/refaire et copier/coller. De plus, il permet de sélectionner des blocs de texte de diverses manières.</para>
</formalpara>

<formalpara>
<title
>Recherche et remplacement</title>
<para
>Il y a deux fonctions de recherche très puissantes disponibles, <menuchoice
><guimenu
>Édition</guimenu
> <guimenuitem
>Chercher dans les fichiers...</guimenuitem
></menuchoice
> et <menuchoice
><guimenu
>Édition</guimenu
> <guimenuitem
>Chercher / Sélectionner / Remplacer...</guimenuitem
></menuchoice
>. Celles-ci permettent, en plus des actions de recherche et remplacement habituelles limitées au document en cours, de mener des actions de recherche ou de recherche et remplacement globales en une fois.</para>
</formalpara>

<formalpara>
<title
>Édition de texte avancée</title>
<para
>Il y a des ressources pour reformater le document en cours et compléter automatiquement les textes saisis partiellement de différentes manières.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Affichage</guimenu
></term>
<listitem>
<para
>Comme le menu <guimenu
>Édition</guimenu
>, ce menu n'est utile que s'il y a un projet ouvert. Dans ce cas, les actions suivantes seront disponibles (entre autres) :</para>

<formalpara>
<title
>Historique de navigation</title>
<para
>Avancez et reculez dans les documents, &etc; que vous avez visités.</para>
</formalpara>

<formalpara>
<title
>Suivi des erreurs</title>
<para
>Naviguez jusqu'aux lignes de source des erreurs rencontrées dans le processus de compilation / construction le plus récent.</para>
</formalpara>

<formalpara>
<title
>Actions liées à l'éditeur</title>
<para
>Certains éléments du menu <guimenu
>Affichage</guimenu
> contrôlent l'apparence et l'affichage de l'éditeur que vous utilisez. Dans le cas du composant &kate; (éditeur de texte avancé intégré), les contrôles suivants seront disponibles :</para>
</formalpara>

<itemizedlist>
<listitem>
<para
>Contrôle le comportement du retour à la ligne dans la fenêtre du document.</para>
</listitem>
<listitem>
<para
>Affiche ou masque plusieurs affichages de bordure dans les fenêtres des documents : numéros de ligne, icônes et, en outre, des marques de signets dans la barre de défilement.</para>
</listitem>
<listitem>
<para
>Contrôle de l'affichage des sections repliées (cachées temporairement) dans un texte source.</para>
</listitem>
</itemizedlist>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Projet</guimenu
></term>
<listitem>
<para
>Tout le fonctionnement de &kdevelop; est basé sur des <emphasis
>projets</emphasis
>, dont la mission essentielle est de collecter des fichiers source, construire des fichiers de gestion et d'autres informations dans un seul dossier de projet. Dans ce menu, vous décidez quel est le projet à utiliser, quelles sont ses propriétés et toute autre action de gestion. En particulier :</para>

<formalpara>
<title
>Ouverture d'un projet</title>
<para
>Permet de créer de nouveaux projets, d'ouvrir des projets existants et d'en importer d'autres environnements.</para>
</formalpara>

<formalpara>
<title
>Options d'un projet</title>
<para
>Permet de définir un ensemble complet des différentes propriétés d'un projet.</para>
</formalpara>

<formalpara>
<title
>Gestion des classes</title>
<para
>Ajoute de nouvelles au projet et traverse l'arbre d'héritage d'une classe.</para>
</formalpara>

<formalpara>
<title
>Distribution du projet</title>
<para
>Aide à construire les paquetages de distribution du projet.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Construire</guimenu
></term>
<listitem>
<para
>Ce menu a trait à tout ce qui concerne la compilation et la documentation du projet. Donc, il n'est utile que quand un projet est réellement ouvert. Dans ce cas, il prévoit les actions suivantes :</para>

<formalpara>
<title
>Compiler, lier, exécuter</title>
<para
>Permet de compiler et de lier le projet entier ou des parties de ce dernier, ainsi que de lancer l'application depuis l'&EDI;.</para>
</formalpara>

<formalpara>
<title
>Préparer les opérations de construction</title>
<para
>Ceci dépend en fait du système « make » que vous employez pour ce projet. Dans le cas de projets avec « automake », il permet de lancer les commandes <filename
>Makefile.cvs</filename
> et <filename
>configure</filename
> propres. Il y a aussi des dispositions pour supprimer les fichiers traduits du projets à diverses stades d'intensité.</para>
</formalpara>

<formalpara>
<title
>Installer l'application</title>
<para
>Permet d'installer l'application à la fois dans les dossiers locaux et dans les dossiers système accessibles uniquement à l'utilisateur « root ».</para>
</formalpara>

<formalpara>
<title
>Documentation de l'API</title>
<para
>Construit ou supprime une documentation d'API basée sur « doxygen », comme défini dans les options du projet.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Déboguer</guimenu
></term>
<listitem>
<para
>Bien que ce menu soit rempli une fois qu'un projet est actif, il n'est bien sûr utile que si le projet réel a été compilé au préalable avec des informations de débgogage (ce comportement est essentiellement configuré dans <menuchoice
><guimenu
>Projet</guimenu
> <guimenuitem
>Options du projet</guimenuitem
></menuchoice
>). Les actions suivantes sont disponibles dans ce cas :</para>

<formalpara>
<title
>Actions habituelles du débogueur</title>
<para
>La première section dans le menu <guimenu
>Déboguer</guimenu
> fournit une interface graphique au débogueur symbolique GDB de &GNU;. Elle permet de démarrer et arrêter votre application dans le débogueur et de le parcourir de diverses manières.</para>
</formalpara>

<formalpara>
<title
>Points d'arrêt</title>
<para
>&kdevelop; fournit plusieurs moyens pour définir des points d'arrêt dans les sources de votre application. L'un passe par l'emploi de l'élément de menu<guimenuitem
>Basculer le point d'arrêt</guimenuitem
>.</para>
</formalpara>

<formalpara>
<title
>Débogage avancé</title>
<para
>D'autres éléments du menu <guimenu
>Déboguer</guimenu
> permettent une analyse plus sophistiquée du programme. Appuyez sur <keycombo
><keycap
>&Maj;</keycap
><keycap
>F1</keycap
></keycombo
> pour obtenir plus d'informations sur leur objectif.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Scripts</guimenu
></term>
<listitem>
<para
>Vous pouvez appeler divers scripts à partir de ce menu pour effectuer aisément des actions fastidieuses sur le texte dans la fenêtre d'éditeur actuellement sélectionnée. Les actions disponibles reposent sur le script sélectionné, toutefois. </para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Fenêtre</guimenu
></term>
<listitem>
<para
>Ce menu est tout à fait standard. Vous pouvez non seulement sélectionner n'importe quelle fenêtre de document ouvert, mais aussi fermer un ou plusieurs documents ici. Vous pouvez même sélectionner un ensemble de fenêtres de documents à fermer en une seule fois.</para>

<para
>Selon le module externe d'éditeur que vous utilisez, il peut y avoir d'autres éléments de menu également. ainsi; le module externe de l'éditeur Kate permet de plus de diviser la fenêtre de l'éditeur horizontalement aussi bien que verticalement.</para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Outils</guimenu
></term>
<listitem>
<para
>&kdevelop; est extrêmement personnalisable. Vous pouvez choisir votre éditeur favori pour vos documents aussi bien que prévoir des modules externes et enfichés pour étendre les fonctions de base de l'&EDI;. Le menu <guimenu
>Outils</guimenu
> reflète la majeure partie de cette configuration.</para>

<formalpara>
<title
>Édition avancée</title>
<para
>La partie supérieure des éléments du menu <guimenu
>Outils</guimenu
> sera fournie par le module externe de l'éditeur en service. Vous pouvez choisir votre éditeur de texte favori via <menuchoice
><guimenu
>Configuration</guimenu
> <guimenuitem
>Configurer KDevelop...</guimenuitem
> <guilabel
>Éditeur</guilabel
></menuchoice
>. Une fois qu'un fichier de document modifiable est sélectionné, la partie supérieure du menu <guimenu
>Outils</guimenu
> fournira les commandes d'édition avancée propres au composant d'édition en service.</para>
</formalpara>

<formalpara>
<title
>Gestion côté web</title>
<para
>Dans le cas où la fenêtre de document active contient une page HTML (&pex; affichée à partir d'une sélection <guilabel
>Documentation</guilabel
>), le menu <guimenu
>Outils</guimenu
> affichera des éléments de menu additionnels qui offrent divers moyens de gérer les pages web. </para>
</formalpara>

<formalpara>
<title
>Autres outils</title>
<para
>D'habitude il existe un groupe d'autres éléments, selon les outils disponibles actuellement. Appuyez sur <keycombo
><keycap
>&Maj;</keycap
> <keycap
>F1</keycap
></keycombo
> pour obtenir plus d'informations sur leurs objectifs.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Configuration</guimenu
></term>
<listitem>
<para
>Ce menu permet d'afficher et de cacher les barres de menus, les barres d'outils et la barre d'état. De plus, vous pouvez configurer des raccourcis, des barres d'outils, desnotifications, l'éditeur et le comportement général de &kdevelop;.</para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenu
>Aide</guimenu
></term>
<listitem>
<para
>Ici vous pouvez ouvrir ce manuel KDevelop, effectuer des consultations par termes dans divers fichiers de documentation, ouvrir des pages de man (le format du manuel UNIX traditionnel) et les pages info (le format du manuel GNU). En outre, vous pouvez signaler des bogues ici ou avoir quelques notions sur votre version actuelle de KDevelop et ses auteurs.</para>
</listitem>
</varlistentry>
</variablelist>
</sect2>

<sect2 id="gettingstarted-overview-tools">
<title
>À quoi servent ces outils ?</title>

<para
>Dans le mode d'interface utilisateur IDEAl, l'espace de travail sera entourée de trois zones de boutons, ce qu'on appelle les <emphasis
>onglets des vues d'outils</emphasis
>. Ils fournissent l'accès aux <emphasis
>fenêtres de vues d'outils</emphasis
> qui accomplissent les tâches principales pendant le développement de logiciel. Chacune de ces trois zones des vues d'outils sert un but différent.</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Côté gauche</title>
<para
>Fournit un accès aux outils de navigation et de sélection.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Bas</title>
<para
>Ces vues affichent les messages produits par divers outils.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Côté droit</title>
<para
>Fournit un accès à la documentation et aux outils de gestion des sources.</para>
</formalpara>
</listitem>
</itemizedlist>

<para
>Le nombre des onglets de vues d'outils affichés change dès lors qu'un projet est ouvert pour un travail réel. D'autres outils permettant de travailler sur ce projet seront disponibles ensuite. Le nombre réel des vues d'outils repose sur les <link linkend="plugin-tools"
>outils modules externes</link
> actuellement disponibles pour &kdevelop;. Vous en saurez plus sur ce sujet dans le chapitre <link linkend="setup"
>Configuring KDevelop</link
>.</para>

<para
>Actuellement, puisqu'il n'y a aucun projet ouvert et le nombre par défaut d'outils de modules externes chargés, vous trouverez les vues des outils suivants. Cliquer sur un onglet ouvrira et fermera respectivement sa fenêtre de vues d'outils.</para>

<variablelist>
<varlistentry>
<term
>Navigation et sélection</term>
<listitem>
<formalpara>
<title
>Sélecteur de fichiers</title>
<para
>Fournit un panneau permettant de naviguer dans l'arborescence des répertoires et de sélectionner des fichiers pour travailler tout comme dans &konqueror;. Un clic sur un fichier l'ouvre dans une fenêtre d'édition appropriée dans l'espace de travail. Un clic droit dans la zone du sélecteur de fichiers fera s'ouvrir un menu de navigation et de manipulation de fichiers.</para>
</formalpara>

<formalpara>
<title
>Liste des fichiers</title>
<para
>Liste les fichiers actuellement ouverts. Un clic sur un fichier sélectionne habituellement sa fenêtre d'édition dans l'espace de la zone de travail. Utilisez cette fonction pour naviguer rapidement dans un grand nombre de fichiers ouverts. De plus cette vue offre un moyen d'organiser les fichiers ouverts dans différentes <emphasis
>sessions</emphasis
>. Ceci est particulièrement utile dans des projets très gros et complexes pour aider le développeur à se concentrer sur différentes tâches. Un clic droit sur un fichier fera s'ouvrir un menu de manipulation de fichiers.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
>Affichages des messages</term>
<listitem>
<formalpara>
<title
>Application</title>
<para
>Affiche la sortie d'une application démarrée depuis &kdevelop;.</para>
</formalpara>

<formalpara>
<title
>Diff</title>
<para
>Utilisé pour afficher le contenu des fichiers correctifs. Affiche la sortie à partir de l'outil d'affichage de différences démarré depuis le menu <menuchoice
><guimenu
>Outils</guimenu
> <guimenuitem
>Afficheur de différences...</guimenuitem
></menuchoice
>.</para>
</formalpara>

<formalpara>
<title
>Messages</title>
<para
>Affiche les messages produits oar les outils construits depuis &kdevelop;, habituellement à partir du menu <guimenu
>Construire</guimenu
>.</para>
</formalpara>

<formalpara>
<title
>Chercher dans les fichiers</title>
<para
>Affiche la liste des éléments trouvés par l'opération de recherche globale démarrée à partir du menu <menuchoice
><guimenu
>Édition</guimenu
> <guimenuitem
>Chercher dans les fichiers...</guimenuitem
></menuchoice
>. Un clic sur une ligne ici ouvrira automatiquement ce fichier à la position spécifiée dans une fenêtre d'édition.</para>
</formalpara>

<formalpara>
<title
>Remplacer</title>
<para
>Liste les résultats de l'opération de rechercher-et-remplacer globale émis à partir du menu <menuchoice
><guimenu
>Édition</guimenu
> <guimenuitem
>Rechercher / Sélectionner / Remplacer...</guimenuitem
></menuchoice
>. Dans cette vue, vous pouvez décider sur chaque élément trouvé si vous souhaitez réellement qu'il soit remplacé ou non.</para>
</formalpara>
<note>
<para
>Cette fonction de recherche-et-remplacer n'est réellement disponible qu'une fois qu'un projet a été chargé dans &kdevelop;. Sinon, l'outil de remplacement global dans le menu <menuchoice
><guimenu
>Édition</guimenu
> <guimenuitem
>Chercher / Sélectionner / Remplacer...</guimenuitem
> </menuchoice
> sera en fait désactivé.</para>
</note>

<formalpara>
<title
>Konsole</title>
<para
>Ouvre une <application
>Konsole</application
> &kde; comme une fenêtre d'émulateur de terminal dans laquelle vous pouvez utiliser les commandes clavier dans une interface en lgne de commande &UNIX; traditionnelle.</para>
</formalpara>
</listitem>
</varlistentry>

<varlistentry>
<term
>Documentation et manipulation des sources</term>
<listitem>
<formalpara>
<title
>Documentation</title>
<para
>&kdevelop; offre l'accès à un ensemble complet de documentation via cet outil. Vous pouvez ici accéder aux fichiers des documents, habituellement en ligne à partir d'emplacements distants, d'une manière structurée. Et il y a plusieurs moyens possibles d'accéder directement à des informations très intéressantes à partir des manuels &kde; ou &Qt;.</para>
</formalpara>

<para
>Consultez les chapitres <link linkend="documentation"
>Documentation</link
> et <link linkend="setup-docu"
>Configurer la documentation</link
> pour plus de détails.</para>

<formalpara>
<title
>Fragments de code</title>
<para
>Cet outil permet de mémoriser de façon permanente des textes sélectionnés pour un usage ultérieur dans d'autres cycles dédition. C'est un outil très flexible, puisque tout fragment de texte mémorisé ici peut contenir un ensemble de variables qui obtiennent leurs valeurs réelles à l'instant où vous insérez un fragment de ce type dans un autre fragment de texte.</para>
</formalpara>
<para
>D'autres informations à ce sujet sont disponibles dans les chapitres <link linkend="editing-snippets"
>Fragments de code</link
> et <link linkend="setup-snippets"
>Configuration de l'outil « Fragments de code »</link
>.</para>
</listitem>
</varlistentry>
</variablelist>
</sect2>
</sect1>

<sect1 id="gettingstarted-configure">
<title
>Un peu de configuration</title>

<para
>Avoir de pouvoir réellement démarrer un premier exemple de projet, nous devrions adapter le comportement de &kdevelop; à nos besoins. Bien que la plupart des réglages par défaut soient appropriés pour l'instant, il y a quelques aspects qui devront être ajustés.</para>

<note>
<para
>Si vous voulez en savoir plus sur la configuration de &kdevelop;, jetez un coup d'œil au chapitre <link linkend="setup"
>Configuration de KDevelop</link
>.</para>
</note>

<sect2 id="gettingstarted-configure-general">
<title
>Quelques réglages généraux</title>

<para
>Pour configurer &kdevelop;, cliquez sur le menu <menuchoice
><guimenu
>Configuration</guimenu
></menuchoice
> et sélectionnez <menuchoice
><guimenuitem
>Configurer KDevelop...</guimenuitem
></menuchoice
>. S'ouvre la boîte de dialogue <guilabel
>Configurer KDevelop</guilabel
>, affichant la page <guilabel
>Général</guilabel
> suivante sur la droite.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-general.png" format="PNG"/>
</imageobject>
<caption>
<para
>La boîte de dialogue de configuration générale de &kdevelop;</para>
</caption>
</mediaobject>
</screenshot>

<para
>La plupart des réglages par défaut conviendront. Mais vous serez probablement amené à en changer deux ou trois.</para>

<formalpara>
<title
>Dossier par défaut des projets</title>
<para
>Au premier démarrage de &kdevelop; il sera très probablement prédéfini dans votre répertoire personnel. La plupart des utilisateurs préfère un dossier de projets consacré au développement de logiciels. Saisissez dans la zone de texte votre répertoire de développement parent préféré. Vous pouvez le choisir à partir de l'arborescence des répertoires si vous cliquez sur le bouton <guilabel
>Ouvrir le sélecteur de fichiers</guilabel
> portant une icône de dossier à sa droite.</para>
</formalpara>

<para
>Dans nos exemples, nous supposerons (quelque peu artificiel) un utilisateur appelé <filename class="directory"
>devel</filename
>. Ainsi, remplacez ce « devel » par votre nom d'utilisateur. Notre utilisateur « devel » utilisera le dossier parent <filename class="directory"
>/home/devel/projects</filename
> pour le développement proprement dit. Là encore, remplacez <filename class="directory"
>projects</filename
> par le nom de votre dossier de développement. </para>

<para
>&kdevelop; installera par défaut un sous-dossier distinct sous son parent pour chaque nouveau projet que vous créez. Ainsi &pex;, tous les fichiers d'un projet nommé « Bonjour » dans notre cas, seront placés dans le dossier <filename class="directory"
>/home/devel/projects/bonjour</filename
>.</para>

<para
>Vous pouvez naturellement annuler les réglages de ce dossier si nécessaire. Consultez le chapitre <link linkend="applicationwizard"
>&appwizard;</link
> pour plus d'informations à ce sujet.</para>

<formalpara>
<title
>Sortie du compilateur</title>
<para
>Chaque fois que &kdevelop; compile un source quelconque, il affiche les messages des outils de construction <application
>make</application
>, etc, dans la fenêtre <guilabel
>Messages</guilabel
> dans la partie inférieure de la zone d'espace de travail. Habituellement, ces messages seront extrêmement délayés. Pour garder une meilleure vue d'ensemble de ce qui se produit, &kdevelop; a quelque moyen de raccourcir ces messages intégrés.</para>
</formalpara>

<para
>Selon la version de &kdevelop; que vous utilisez, la sélection <guilabel
>Sortie du compilateurt</guilabel
> peut être présélectionnée sur « Longue », ce qui provoquera l'affichage de tout le contenu des messages. Vous serez probablement amené à changer ce réglage pour l'option beaucoup plus pratique « Très courte ». Choisissez simplement ce réglage à partir de la zone de liste déroulante.</para>

<caution>
<para
>Soyez conscient que seules les informations <emphasis
>les plus élémentaires</emphasis
> seront affichées dans la fenêtre <guilabel
>Messages</guilabel
> de cette manière. En cas d'erreurs pendant l'exécution d'une construction par exemple, vous serez probablement amené à consulter plus, si ce n'est la totalité, des messages de texte. Ils ne sont pas perdus, cependant. Cliquez simplement sur la fenêtre <guilabel
>Messages</guilabel
> et sélectionnez par exemple « Sortie du compilateur longue » à partir du menu qui apparaît.</para>
</caution>
</sect2>

<sect2 id="gettingstarted-configure-search">
<title
>Initialisation des index de recherche de documentation</title>

<para
>Il existe un autre élément, pas si évident, qui devra de préférence être initialisé avant de commencer le travail de développement proprement dit. Ceci est dû parce que vous serez amené amené à exécuter une recherche de documentation régulièrement pendant le développement. &kdevelop; exige que certains index de recherche soient créés avant de pouvoir effectuer de telles opérations de recherche. Ainsi, initialisons-les avant de tenter nos premières étapes vers le fonctionnement réel de &kdevelop;.</para>

<para
>Ouvrez la vue des outils <guilabel
>Documentation</guilabel
> du côté droit de la fenêtre principale de &kdevelop;. Ouvrez la page de dialogue <guilabel
>Recherche</guilabel
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="documents-search.png" format="PNG"/>
</imageobject>
<caption
><para
>Où générer les index de recherche.</para
></caption>
</mediaobject>
</screenshot>

<para
>Cliquez maintenant sur le bouton <guibutton
>Mettre à jour la configuration</guibutton
> pour vous assurer que les outils de recherche sont correctement installés. Une boîte de dialogue devra apparaître, indiquant « Fichier de configuration mis à jour ». Cliquez sur <guibutton
>OK</guibutton
> pour la faire disparaître.</para>

<para
>Ensuite, &kdevelop; sera prêt à analyser la documentation dont il a connaissance et à construire quelques index de recherche utiles à partir de celle-ci. Cliquez sur le bouton <guibutton
>Mettre à jour l'index</guibutton
> à droite. Maintenant, la boîte de dialogue <guilabel
>Générer l'index de recherche</guilabel
> s'ouvre, affichant la progression des opérations de construction de l'index.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-docu-indexgen.png" format="PNG"/>
</imageobject>
<caption
><para
>&kdevelop; génère les index de recherche de documentation.</para
></caption>
</mediaobject>
</screenshot>

<para
>L'opération prendra un peu de temps, selon la taille de la documentation et la puissance de votre machine. Finalement, le bouton <guibutton
>Annuler</guibutton
> laissera la place à <guibutton
>OK</guibutton
>. Cliquez simplement sur ce bouton pour continuer.</para>

<note>
<itemizedlist>
<listitem>
<para
>Cela fermera en principe la boîte de dialogue. Dans certains cas, il se peut que l'application <application
>htdig</application
> que &kdevelop; utilise pour effectuer ses recherches de texte ne soit pas correctement installée. Consultez le chapitre <link linkend="setup-docu-textsearch"
>Configuration des recherches de texte</link
> pour obtenir de l'aide dans ce cas.</para>
</listitem>
<listitem>
<para
>Pour être en mesure de consulter la documentation de l'API propre à &kde; et à &Qt;, il est obligatoire que les  <emphasis
>KDELibs Apidocs</emphasis
> soient présentes lorsque est installé. Si vous rencontrez des problèmes en construisant les indexe ou que vous exécutez les <link linkend="gettingstarted-edit-defs"
>exemples de consultation par identifiants</link
> plus loin dans ce chapitre, assurez-vous que cette documentation existe et est accessible à &kdevelop;. Reportez-vous à <link linkend="kdevelop-install"
>Installation de KDevelop</link
> pour plus de détails.</para>
</listitem>
</itemizedlist>
</note>
</sect2>
</sect1>


<sect1 id="gettingstarted-new">
<title
>Démarrer un nouveau projet</title>

<para
>Presque toutes les applications se composent de douzaines, de centaines, voire de milliers de fichiers qui doivent être structurés et maintenables. Pour y parvenir, &kdevelop; organise les tâches de développement de logiciels dans des  <emphasis
>projets</emphasis
>. Ainsi, la première étape pratique pour développer des logiciels dans &kdevelop; consiste habituellement à créer un nouveau projet.</para>

<para
>Heureusement, cela ne pose pas de problème. &kdevelop; fournit ce qu'on appelle l'outil &appwizard; pour ce faire. (consultez le chapitre <link linkend="applicationwizard"
>Premiers pas &mdash; l'&appwizard;</link
> pour en savoir plus.)</para>

<para
>Nous allons à présent démarrer un projet d'application &kde; simple pour illustrer la facilité de l'opération et montrer quels sont les fichiers et outils que &kdevelop; aura mis à disposition. De ce fait, noue jetterons un coup d'œil aux points suivants :</para>

<simplelist>
<member
><link linkend="gettingstarted-new-setup"
>Comment créer un nouveau projet avec l'aide de l'&appwizard;.</link
></member>
<member
><link linkend="gettingstarted-new-files"
>Quels sont les fichiers que l'&appwizard; a configuré initialement.</link
></member>
<member
><link linkend="gettingstarted-new-toolviews"
>Qu'en est-il de la vue des outils additionnels affichés avec le projet ?</link
></member>
</simplelist>

<sect2 id="gettingstarted-new-setup">
<title
>Comment créer un nouveau projet</title>

<para
>Créons un projet &kde; « Bonjour monde » plutôt simple. Il suffit de suivre ces étapes.</para>

<procedure>
<step>
<para
>Pour démarrer l'&appwizard; cliquez sur le menu <menuchoice
><guimenu
>Projet</guimenu
> <guimenuitem
>Nouveau projet...</guimenuitem
></menuchoice
>.</para>
</step>

<step>
<para
>La boîte de dialogue <guilabel
>Créer un nouveau projet</guilabel
> apparaît. Dans la fenêtre supérieure gauche <guilabel
>Tous les projets</guilabel
> sont listés un certain nombre de langages de programmation.</para>

<substeps>
<step>
<para
>Nous voulons construire un application &kde; en C++ comme d'habitude, donc cliquez sur l'étiquette <guilabel
>+</guilabel
> à gauche de l'étiquette <guilabel
>C++</guilabel
> pour ouvrir cette branche.</para>
</step>

<step>
<para
>Une série de cibles d'applications possibles s'affiche. Nous allons construire une application &kde;. Ouvrez donc la sous-branche suivante via l'étiquette <guilabel
>+</guilabel
> à côté de <guilabel
>KDE</guilabel
>.</para>
</step>

<step>
<para
>S'affiche alors à une série de <emphasis
>modèles de projets</emphasis
>. Naviguez jusqu'à la fin de cette branche et cliquez sur <guilabel
>Application KDE simple</guilabel
>.</para>

<para
>Un aperçu et une courte description de l'applicatopn que ce modèle de projet produira apparaît dans les deux fenêtres à droite.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="tutorial-new-project.png" format="PNG"/>
</imageobject>
<caption>
<para
>Sélection d'un modèle de projet « Hello World »</para>
</caption>
</mediaobject
></screenshot>
</step>

<step>
<para
>Notre application nécessitera un nom. Cherchez la zone <guilabel
>Propriétés</guilabel
> au bas de la boîte de dialogue et saisissez un nom approprié dans le champ d'entrée <guilabel
>Nom de l'application</guilabel
>.</para>

<para
>Nous utilisons « Hello » dans notre exemple, mais vous pouvez employer ce que vous souhaitez, pourvu que le nom soit composé de lettres, de chiffres et de caractères de soulignement uniquement. Vous constaterez que l'&appwizard; rejette tout autre caractère.</para>
</step>

<step>
<para
>Assurez-vous que la zone de texte <guilabel
>Emplacement</guilabel
> sous le champ d'entrée affiche le dossier de plus haut de votre projet comme configuré dans le chapitre <link linkend="gettingstarted-configure"
>Un peu de configuration</link
> ci-dessus. Dans le cas contraire, saisissez un nom de dossier approprié ou choisissez-en un dans la liste des dossiers fournie par le bouton à droite portant l'icône d'un dossier.</para>

<para
>Si tout s'est bien passé, la ligne <guilabel
>Emplacement cible</guilabel
> en bas affichera le chemin du dossier que votre nouveau projet emploiera. au cas ou un suffixe « (invalid) » serait annexé, essayez un autre nom pour votre projet et / ou assurez-vous que le dossier de plus haut niveau du projet saisi dans la zone de texte <guilabel
>Emplacement</guilabel
> existe bien et qu'il est modifiable.</para>
</step>

<step>
<para
>Une fois que tout est correct, le bouton <guibutton
>Suivant</guibutton
> sur la ligne du bas de la boîte de dialogue est activé. Cliquez sur ce dernier pour continuer.</para>
</step>
</substeps>
</step>

<step>
<para
>Cette action vousconduit à la boîte de dialogue <guilabel
>Options du projet</guilabel
>. Assurez-vous que les zones de texte <guilabel
>Auteur</guilabel
> et <guilabel
>Adresse électronique</guilabel
> sont correctement remplies. Habituellement, ce seront vos réglages utilisateur &kde; par défaut comme indiqué dans la boîte de dialogue <guilabel
>Compte utilisateur et mot de passe</guilabel
> du Centre de configuration de &kde;. Sinon, changez-les pour les réglages que vous préférez pour votre application.</para>

<screenshot id="gettingstarted-new-setup-options">
<mediaobject>
<imageobject>
<imagedata fileref="tutorial-hello-options.png" format="PNG"/>
</imageobject>
<caption>
<para
>Saisissez votre nom et (éventuellement) votre adresse électronique.</para>
</caption>
</mediaobject>
</screenshot>

<note>
<para
>Vous devez fournir un nom d'<guilabel
>auteur</guilabel
> au moins. C'est obligatoire pour la configuration des fichiers de l'application.</para>
</note>

<para
>Si tout est correct, le bouton <guibutton
>Suivant</guibutton
> est activé. Cliquez sur ce dernier pour continuer.</para>
</step>

<step>
<para
>Les boîtes de dialogue <guilabel
>Version Control System</guilabel
>, <guilabel
>Template for .h Files</guilabel
>, and <guilabel
>Template for .cpp Files</guilabel
> suivantes ne nous intéressent pas pour le moment. Ignorez-les en cliquant sur les boutons <guibutton
>Suivant</guibutton
> et, pour finir, sur le bouton <guibutton
>Terminer</guibutton
>.</para>
</step>
</procedure>

<para
>C'est tout ! L'a&appwizard; prend le relais et construit une série de fichiers initiaux dans le dossier <guilabel
>Emplacement cible</guilabel
> que vous avez fourni dans l'étape 2c ci-dessus.</para>

<para
>Une fois cette phase de création terminée, &kdevelop; ouvre une fenêtre d'édition pour le fichier d'implémentation de la <emphasis
>fenêtre principale de l'application</emphasis
> (c'est-à-dire <filename
>bonjour.cpp</filename
> dans notre exemple), donc vous pouvez continuer sans problème.</para>
</sect2>

<sect2 id="gettingstarted-new-files">
<title
>Fichiers initiaux du projet</title>

<para
>Même si notre exemple de projet Bonjour est tout à fait simple, l'&appwizard; a bien créé un ensemble complet de fichiers de gestion de sources et de projet. Vous les listerez très facilement en ouvrant la vue des outils <guilabel
>Arborescence des fichiers</guilabel
> sur la partie inférieure gauche. S'ouvre une liste de fichiers similaire à celle ci-dessous.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="tutorial-hello-new.png" format="PNG"/>
</imageobject>
<caption>
<para
>Fichiers initiaux dans notre projet « Bonjour tout le monde »</para>
</caption>
</mediaobject>
</screenshot>

<para
>Pour mettre en évidence le principal groupe de fichiers que l'&appwizard; a produit, nous avons ouvert la majeure partie des branches des dossiers dans la fenêtre de vue des outils <guilabel
>Arborescence des fichiers</guilabel
> située à gauche. Cliquez simplement sur les noms des branches dans l'arborescence pour constater par vous-même.</para>

<para
>De plus, juste à titre de démonstration, nous avons également ouvert la majeure partie des branches de la fenêtre de vue des outils <guilabel
>Gestionnaire « automake »</guilabel
> à droite, où sont listées certaines des sources du projet, également.</para>

<sect3 id="gettingstarted-new-files-copyright">
<title
>Aspects liés aux droits d'auteur</title>

<para
>Toutes les applications se conformant à &GNU; doivent être protégées par des droits d'auteur. Il y a deux niveaux qui requièrent des notices de droits d'auteur, les <emphasis
>fichiers sources individuels</emphasis
> et le <emphasis
>niveau d'application exécutable</emphasis
> (run-time application). L'&appwizard; a déjà placé les informations relatives aux droits d'auteur et à la licence dans les fichiers de projet.</para>

<formalpara>
<title
>Droits d'auteur au niveau des fichiers sources</title>
<para
>Vous rappelez-vous de la boîte de dialogue <link linkend="gettingstarted-new-setup-options"
><guilabel
>Options du projet</guilabel
></link
> dans la configuration du projet ? Vous avez dû y saisir votre nom (celui du développeur) et éventuellement une adresse électronique. Reportez-vous maintenant au début de la fenêtre d'édition de <guilabel
>bonjour.cpp</guilabel
> actuellement affichée dans la zone d'espace de travail. L'&appwizard; a saisi ces instructions au début de l'en-tête relative à la licence de chaque fichier source qu'il a créé.</para>
</formalpara>

<programlisting
>/***************************************************************************
 *   Copyright (C) 2006 by Jean Utilisateur   *
 *   jean@utilisateur.com   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
</programlisting>

<para
>Vous trouverez exactement les mêmes en-têtes de texte dans chaque fichier source que vous créerez au sein de &kdevelop; (à condition que vous utilisiez les outils intégrés lors de la création des fichiers). &kdevelop; se souvient de ces réglages dans certains modèles de fichiers que vous pouvez trouver dans le dossier <filename class="directory"
>templates</filename
>.</para>

<formalpara>
<title
>Droits d'auteurs relatifs à l'exécution de l'application</title>
<para
>Une fois que votre application &kde; tourne, l'utilisateur peut afficher certaines données <guilabel
>À propos</guilabel
>, habituellement à partir du menu <guimenu
>Aide</guimenu
>. L'&appwizard; a également veillé à cet aspect. Si vous jetez un coup d'œil au fichier <filename
>main.cpp</filename
>, vous trouverez un élément similaires à celui ci-dessous.</para>
</formalpara>

<programlisting
>int main(int argc, char **argv)
{
    KAboutData about("bonjour", I18N_NOOP("Bonjour"), version, description,
                     KAboutData::License_GPL, "(C) 2006 Jean Utilisateur", 0, 0,
                     "jean@utilisateur.com");
    about.addAuthor( "Jean Utilisateur", 0, "joe@user.com" );
</programlisting>

<para
>Ce code affiche le nom (« Jean Utilisateur » dans notre cas) et l'adresse électronique du développeur principal dans la page de droits d'auteur <guilabel
>À propos</guilabel
> et liste ses nom et adresse sur la page <guilabel
>Auteurs</guilabel
> également.</para>

<important>
<para
>Chaque fois que vous apportez des changements notables à un projet existant, veillez à saisir vos nom et adresse sur les notices de droits d'auteur sur tous les fichiers que vousavez changés et sur l'affichage des droits d'auteur de l'exécutable également. Ne soyez pas timide, vous aidez considérablement la communauté <foreignphrase
>open souce</foreignphrase
> en faisant cela..</para>
</important>
</sect3>

<sect3 id="gettingstarted-new-files-source">
<title
>Fichiers sources initiaux</title>

<para
>L'&appwizard; a placé les fichiers sources dans le sous-dossier <filename class="directory"
>src</filename
> du dossier du projet. Vous y trouverez les fichiers <filename
>main.cpp</filename
>, <filename
>bonjour.h</filename
> et <filename
>bonjour.cpp</filename
> comme vous vous y attendiez certainement.</para>

<para
>Il y a quelques fichiers supplémentaires que l'on trouve dans une application &kde; classique, à savoir</para>

<itemizedlist>
<listitem>
<para
><filename
>bonjour.desktop</filename
> contient des métadonnées utilisées par &kdevelop; pour maintenir et démarrer l'application.</para>
</listitem>

<listitem>
<para
><filename
>hi16-app-bonjour.png</filename
> et <filename
>hi32-app-bonjour.png</filename
> contiennent quelques icônes initiales par défaut que &kdevelop; emploiera pour l'affichage de l'application.</para>
</listitem>

<listitem>
<para
>Pour finir, <filename
>bonjourui.rc</filename
> contient une description de l'interface utilisateur de l'application, actuellement les menus que fournira l'application.</para>
</listitem>
</itemizedlist>
</sect3>

<sect3 id="gettingstarted-new-files-doc">
<title
>Documentation intiale de l'application</title>

<para
>Dans le sous-dossier <filename class="directory"
>doc/en</filename
> du projet, vous trouverez le fichier <filename
>index.docbook</filename
>. C'est un modèle par défaut à partir duquel vous pouvez commencer à écrire une documentation utilisateur appropriée</para>
</sect3>

<sect3 id="gettingstarted-new-files-project">
<title
>Fichiers du projet et auxiliaires</title>

<para
>Vous aurez noté que les fichiers que nous avons introduits jusqu'ici sont listés en gras dans la vue des outils <guilabel
>Arborescence des fichiers</guilabel
>, contrairement à la plupart des autres fichiers. Ce comportement illustre les tâches sensiblement différentes pour lesquelles ces fichiers sont prévus. Le contenu de ces fichiers représentés en gras influencent directement l'application. Les fichiers sources produiront le code à exécuter, d'autres généreront les données ou la documentation nécessaire. Comme ces fichiers doivent être maintenus et traités avec méthode lors des étapes de construction par le projet, ils sont appelés <emphasis
>fichiers de projet</emphasis
>.</para>

<para
>Si vous jetez un coup d'œil à la fenêtre <guilabel
>Gestionnaire « Automake »</guilabel
> inférieure à droite de la zone d'espace de travail, vous trouverez également la liste de tous les fichiers de projet. L'outil &automanag; utilise ces connaissances pour veiller au contrôle de construction comme nous le verrons dans un instant.</para>

<para
>Les autres fichiers, représentés autrement qu'en gras sont de nature plus auxiliaire. Ils appartiennent à plusieurs classes distinctives comme suit :</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Contrôle de construction d'un projet</title>
<para
>Ces fichiers contrôlent les processus de compilation, d'installation, de construction de la documentation, &etc;. Si le projet emploie le mécanisme <application
>autotools</application
> de &GNU; comme le fait notre exemple, vous trouverez un fichier <filename
>Makefile.am</filename
> dans chaque dossier de projet. Il s'agit d'une sorte de « fichier core » de base qui contiennent des commandes de contrôle de construction et sera traité en liaison avec divers fichiers <filename
>configure</filename
> pendant les étapes de construction. Un tel processus de construction produit un <filename
>Makefile</filename
> final dans chaque dossier. Et, à partir de là, à son tour l'utilitaire <application
>make</application
> construira enfin les exécutables (binaires) de l'application.</para>
</formalpara>

<para
>Ces fichiers <filename
>Makefile.am</filename
> doivent être maintenus tout au long du processus de développement. Par chance, &kdevelop; vous libère de la majeure partie de ce fardeau grâce à l'outil &automanag;, qui est avant tout une interface graphique pour maintenir le contenu de <filename
>Makefile.am</filename
>.</para>

<para
>D'autres fichiers de contrôle de contrôle de la construction du projet actuellement répertoriés sont <filename
>configure.in.in</filename
> et <filename
>subdirs</filename
> dans le dossier racine du projet. Ils seront traités par certaines des fichiers dans le dossier d'administration <filename class="directory"
>admin</filename
> propre à &kde; pour produire plus de fichiers de type <filename
>configure</filename
> et <filename
>Makefile</filename
> et enfin, les exécutables de l'application.</para>
</listitem>

<listitem>
<formalpara>
<title
>Fichiers de contrôle de &kdevelop;</title>
<para
>&kdevelop; a besoin de certaines données de contrôle et d'administration qui lui sont propres. Ils sont situés dans le dossier racine du projet, dans notre exemple <filename
>bonjour.kdevelop</filename
>, <filename
>bonjour.kdevelop.pcs</filename
> et <filename
>bonjour.kdevses</filename
>.</para>
</formalpara>

<para
>Le fichier <filename
>xxx.kdevelop</filename
> (où « xxx » désigne le nom du projet) est d'une importance toute particulière dans chaque projet. C'est le <emphasis
>fichier de projet KDevelop 3</emphasis
> principal, nécessaire si vous voulez par la suite charger ce projet dans l'&EDI;.</para>

<warning>
<para
>Il ne faut jamais modifier, renommer ou même supprimer aucun de ces fichiers de contrôle &kdevelop; ! L'&EDI; risquerait fort de ne plus fonctionner correctement sur votre projet par la suite.</para>
</warning>
</listitem>

<listitem>
<formalpara>
<title
>Fichiers de description de projet GNU</title>
<para
>Certains fichiers dans le dossier racine du projet sont obligatoires dans toute application se conformant à &GNU;. Ce sont : <filename
>AUTHORS</filename
>, <filename
>ChangeLog</filename
>, <filename
>INSTALL</filename
>, <filename
>COPYING</filename
> (qui contient la GNU GENERAL PUBLIC LICENSE), <filename
>INSTALL</filename
>, <filename
>NEWS</filename
>, <filename
>README</filename
> et <filename
>TODO</filename
>.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Autres fichiers</title>
<para
>Quelques fichiers supplémentaires, non encore mentionnés, sont :</para>
</formalpara>

<itemizedlist>
<listitem>
<para
><filename
>Doxyfile</filename
> contrôle la création de la documentation de l'interface de programmation interne de l'&API; propre au projet.</para>
</listitem>

<listitem>
<para
>Le dossier <filename class="directory"
>templates</filename
> contient les modèles de fichiers que l'&EDI; utilise comme souches pour créer de nouveaux fichiers sources. Vous pouvez à tout moment modifier ces modèles. Le nouveau contenu sera répercuté dans les fichiers sources suivants que vous créez des types liés.</para>

<para
>Comme vous pouvez &pex; être amené à réaligner les étoiles situées à droite dans les lignes relatives aux droits d'auteur que l'&appwizard; a insérées dans les modèles de fichiers <filename
>cpp</filename
> et <filename
>h</filename
>, les fichiers créés à partir de ces modèles sembleront moins incongrus.</para>
</listitem>

<listitem>
<para
>Le dossier <filename class="directory"
>po</filename
> servira à des fins de localisation. Il fait essentiellement partie des fichiers de projet (contient un <filename
>Makefile.am</filename
>) mais sera principalement utilisé pour exécuter la traduction. Il n'est pas d'un intérêt majeur pour le développeur de l'application, cependant.</para>
</listitem>

<listitem>
<para
>Enfin, le dossier <filename class="directory"
>admin</filename
> est en particulier nécessaire dans les applications orientées &kde;. Comme il fournit un ensemble complet de fichiers nécessaires pour maintenir les sources et les exécutables de l'application, ils s'intégreront sans problème dans l'environnement &kde;.</para>
</listitem>
</itemizedlist>

</listitem>
</itemizedlist>
</sect3>
</sect2>

<sect2 id="gettingstarted-new-toolviews">
<title
>Vues des outils supplémentaires</title>

<para
>Comme vous l'avez remarqué, dès l'instant où l'&appwizard; a rendu le nouveau projet ; plusieurs vues d'outils supplémentaires ont été mises à disposition. Ceux-ci ne se justifient que pendant le développement du projet et, en bref, fournissent la fonctionnalité suivante.</para>

<note>
<para
>Les vues d'outils réellement visibles sont fonction des modules externes actuellement chargés dans &kdevelop;. Il y a des moyens de contrôler ce comportement. Consultez le chapitre <link linkend="setup-plugins"
>Outils modules externes</link
> pour connaître les instructions.</para>
</note>

<sect3 id="gettingstarted-new-toolviews-left">
<title
>Outils de navigation et de sélection (côté gauche)</title>

<itemizedlist>
<listitem>
<formalpara>
<title
>Signets</title>
<para
>Vous pouvez marquer une ligne de fichier texte afin de revenir rapidement à sa position depuis n'importe où. &kdevelop; mémorisera tous ces <emphasis
>signets</emphasis
>, même si vous fermez la fenêtre d'édition après. La vue des outils <guilabel
>Signets</guilabel
> liste tous ces signets par nom de fichier et numéro de ligne. Il ne vous reste qu'à cliquer sur un élément de ce type pour ouvrir la fenêtre d'édition et positionner le curseur sur cette ligne.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Classes</title>
<para
>Liste les classes, méthodes, &etc; connues dans le projet. Un clic sur l'élément ouvre les fichier d'en-tête ou source approprié dans une fenêtre dédition et positionne le curseur à la déclaration ou la définition respective.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Groupes de fichiers</title>
<para
>Trie les fichiers dans les projets en divers groupes d'utilitaires, &cad; les sources, l'interface utilisateur, les icônes, les traductions et autres. Un clic sur un élément ouvre ce fichier dans une fenêtre d'édition.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Variables</title>
<para
>Utilisé par l'outil de débogage pour afficher, évaluer et surveiller les variables pendant les exécutions.</para>
</formalpara>
</listitem>
</itemizedlist>
</sect3>

<sect3 id="gettingstarted-new-toolviews-bottom">
<title
>Messages (en bas)</title>

<itemizedlist>
<listitem>
<formalpara>
<title
>Valgrind</title>
<para
><application
>Valgrind</application
> est un analyseur de programme exécutables. Cette vue d'outils liste les résultats d'une telle exécution d'analyse. Elle sert &pex; à rechercher des fuites mémoire.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Problèmes de sécurité</title>
<para
>Il existe un outil de module externe <guilabel
>Contrôleur de sécurité</guilabel
> pour &kdevelop;. Il analyse le fichier source en cours d'édition pour rechercher des problèmes de sécurité courants qui peuvent se produire dans l'application et informe l'utilisateur dans la fenêtre de vue des outils.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Points d'arrêt</title>
<para
>Cette vue des outils permet de définir, effacer et gérer explicitement les points d'arrêt dans les fichiers sources de l'application. Elle est utilisée en liaison avec le débogueur.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>CTags</title>
<para
>Permet de créer une base de données ou des index d'identifiants utilisant l'application <application
>CTags</application
> bien connue. Cette base de données de marqueurs peut alors être utilisée à partir de cette fenêtre de vue d'outils pour effectuer n'importe quelle consultation par identifiant nécessaire dans les sources du projet. Un clic sur une ligne d'élément ainsi trouvé ouvre une fenêtre d'édition et positionne le curseur sur l'identifiant approprié à cet endroit.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Problèmes</title>
<para
>&kdevelop; garde la trace des problèmes de programmation communs dans le fichier source modifié et avertit l'utilisateur dans cette fenêtre de vue des outils.</para>
</formalpara>
</listitem>
</itemizedlist>
</sect3>
  
<sect3 id="gettingstarted-new-toolviews-right">
<title
>Gestion des sources (côté droit)</title>
      
<itemizedlist>
<listitem>
<formalpara>
<title
>Gestionnaire Automake</title>
<para
>L'outil &automanag; est essentiellement une interface graphique pour maintenir le contenu des fichiers <filename
>Makefile.am</filename
> situés dans chaque dossier du projet. Cette vue d'outils utilise deux fenêtres pour contrôler son travail. La fenêtre supérieure reflète une partie des sous-dossiers du projet, à savoir ceux qui contiennent explicitement les <emphasis
>fichiers de projet</emphasis
>. Chaque sous-dossier de ce type doit contenir un fichier <filename
>Makefile.am</filename
> est nommé un <emphasis
>sous-projet</emphasis
> dans le contexte du &automanag;.</para>
</formalpara>

<para
>Un clic sur l'élément d'un sous-projet ouvre un affichage approprié des fichiers de projet dans ce sous-projet dans la fenêtre inférieure. Les fichiers listés ici seront groupés en fonction de leur fonctionnalité <filename
>Makefile.am</filename
> dans ce sous-projet.</para>

<para
>Le &automanag; est un outil très puissant permettant de gérer le projet et ses sous-projets ainsi que les rôles que les fichiers du projet jouent dans la construction de l'application. Nous jetterons un bref coup d'œil à quelques détails majeurs <link linkend="gettingstarted-extend-automake"
>ci-dessous</link
>. Consultez le chapitre <link linkend="project-management"
>Construction et gestion de projets</link
> pour une description plus exhaustive.</para>
</listitem>
</itemizedlist>
</sect3>
</sect2>
</sect1>


<sect1 id="gettingstarted-edit">
<title
>Quelques astuces pour travailler avec des documents</title>

<para
>Dans notre exemple de projet, comme l'&appwizard; a laissé le fichier <filename
>bonjour.cpp</filename
> ouvert dans une fenêtre d'édition, vous pouvez immédiatement commencer à travailler. Maintenant, comme nous pouvons parfaitement partir du principe que vous êtes très à l'aise avec l'utilisation d'un éditeur, nous n'avons pas besoin d'en dire plus à ce propos ici. Mais il y a certaines aspects pratiques de &kdevelop; avec la manière de travailler avec de telles fenêtres d'édition à onglet et les documents sur lesquels vous travaillez. Nous jetterons un bref coup d'œil à certains d'entre eux, à savoir :</para>

<simplelist>
<member
><link linkend="gettingstarted-edit-headers"
>Comment basculer facilement entre les fichiers d'en-tête et d'implémentation.</link
></member>
<member
><link linkend="gettingstarted-edit-defs"
>Comment accéder facilement aux déclarations et aux définitions.</link
></member>
<member
><link linkend="gettingstarted-edit-arrange"
>Comment adapter les fenêtres d'édition à vos besoins actuels.</link
></member>
<member
><link linkend="gettingstarted-edit-problems"
>Comment garder un œil sur les problèmes courants.</link
></member>
</simplelist>

<sect2 id="gettingstarted-edit-headers">
<title
>Basculer entre les fichiers d'en-tête et d'implémentation</title>

<para
>&kdevelop; fournit un moyen rapide et facile de passer d'un fichier d'implémentation donné (<filename
>.cpp</filename
>) à un fichier d'en-tête correspondant (<filename
>.h</filename
>) et vice versa. Il suffit d'un clic droit dans la fenêtre d'édition vers laquelle vous voulez basculer. Un menu similaire à celui qui suit apparaîtra.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-switch-header.png" format="PNG"/>
</imageobject>
<caption
><para
>Comment basculer entre les fichiers d'implémentation et d'en-tête.</para
></caption>
</mediaobject>
</screenshot>

<para
>Cherchez l'élément <guimenuitem
>Basculer entre les fichiers d'en-tête et les fichiers d'implémentation </guimenuitem
> et sélectionnez-le. &kdevelop; consultera le fichier d'en-tête ou d'implémentation correspondant et l'ouvrira dans une autre fenêtre dédition. Dans notre exemple, si vous avez cliqué dans le source <filename
>bonjour.cpp</filename
>, le fichier <filename
>bonjour.h</filename
> sera affiché et le curseur affiché ici.</para>

<para
>Mieux encore. Si vous cliquez avec le &BDS; dans le texte d'une implémentation de classe, &kdevelop; positionnera le curseur sur la ligne de déclaration correspondante dans le fichier d'en-tête. Et vice versa, en cliquant avec le &BDS; sur une ligne de déclatration vous amènera à la l'implémentation de classe correspondante.</para>

<para
>Si la fenêtre d'édition contenant le fichier vers lequel basculer existe déjà, &kdevelop; activera évidemment cette dernière et repositionnera le curseur ici si nécessaire.</para>
</sect2>

<sect2 id="gettingstarted-edit-defs">
<title
>Comment accéder aux déclarations et aux définitions</title>

<para
>Mais si vous travaillez sur un fichier source et que vous voulez consulter la déclaration ou la définition d'un identifiant que vous venez d'y trouver ? Eh bien, il n'y a aucun problème pour le faire. Il suffit avant tout de cliquer avec le &BDS; sur l'identifiant en question.</para>

<para
>Deux cas différents sont à prendre en compte, à savoir :</para>
<simplelist>
<member
><link linkend="gettingstarted-edit-defs-external"
>Accéder aux identifiant s définis extérieurement</link
> et</member>
<member
><link linkend="gettingstarted-edit-defs-project"
>traiter les éléments de texte internes du projet</link
>.</member>
</simplelist>

<sect3 id="gettingstarted-edit-defs-external">
<title
>Déclarations et définitions externes</title>

<para
>Dans un cas très courant, vous êtes amené à consulter un identifiant qui a été défini extérieurement par rapport à votre projet. Dans les projets &kde;, de tels identifiants sont très probablement documentés dans diverses bibliothèques &kde; ou &Qt;. Si &kde;et &kdevelop; ont été installés correctement, &kdevelop; pourra accéder à ce qu'on appelle la documentation de l'API et chercher des identifiants de ce type.</para>

<para
>Examinons un exemple. Dans la fenêtre d'édition <filename
>bonjour.cpp</filename
>, cherchez les lignes suivantes.</para>

<programlisting
>Bonjour::Bonjour()
    : KMainWindow( 0, "Bonjour" )
{
</programlisting>

<para
>Cliquez avec le &BDS; sur <classname
>KMainWindow</classname
>. Un menu apparaît. Sélectionnez dedans l'élément <guimenuitem
>Chercher dans la documentation : KMainWindow</guimenuitem
> et relâchez le bouton de la souris. Maintenant, la vue des outils <guilabel
>Documentation</guilabel
> est ouverte, affichant l'élément <classname
>KMainWindow</classname
> en tant qu'élément de recherche sur la sous-page <guilabel
>Chercher</guilabel
>. Au bout d'un instant, une autre fenêtre d'édition s'ouvre dans la zone d'espace de travail, affichant la page de référence de l'API KDE de la classe <classname
>KMainWindow</classname
>.</para>

<para
>Voici quelle en sera l'apparence globale. (Nous avons délibérément ouvert la page<guilabel
>Documentation</guilabel
>, <guilabel
>Recherche</guilabel
> déjà pour illustrer le résultat de la sélection du menu.)</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-search-doc.png" format="PNG"/>
</imageobject>
<caption
><para
>Comment consulter un identifiant documenté extérieurement.</para
></caption>
</mediaobject>
</screenshot>

<para
>Vous pourriez également sélectionner <guimenuitem
>Trouver de la documentation : KMainWindow</guimenuitem
>. Dans ce cas, la sous-page <guilabel
>Recherche de documentation</guilabel
> de la vue des outils <guilabel
>Documentation</guilabel
> apparaît, offrant habituellement une sélection de pages contenant le terme à rechercher. (Dans notre exemple, ce sera probablement les classes <classname
>KMainWindow</classname
> et <classname
>KMainWindowInterface</classname
>. Sélectionnez celle qui vous intéresse et la documentation correspondante sera affichée dans une fenêtre d'édition.</para>

<note>
<para
>Si cela ne fonctionne pas, il n'y a probablement pas encore de d'index de documents. Avez-vous initialisé les index comme illustré <link linkend="gettingstarted-configure-search"
>ci-dessus</link
> ? Dans le cas contraire, faites-le puis revenez en arrière et réessayez.</para>
</note>
</sect3>

<sect3 id="gettingstarted-edit-defs-project">
<title
>Déclarations et définitions internes du projet</title>

<para
>De telles fonctions de recherche dans la documentation externe ont leurs limites, cependant. Naturellement, on ne peut pas consulter un identifiant de façon externe s'il est seulement défini et utilisé dans le projet actuel. Mais il existe une aide. &kdevelop; peut employer des index construits par l'application <application
>CTags</application
> pour rechercher les sources dans votre projet.</para>

<para
>Avoir de pouvoir l'utiliser dans notre exemple de projet « Bonjour », nous devons toutefois d'abord générer un index approprié. Ce sera réalisé par la vue des outils <guilabel
>CTags</guilabel
> au bas de la zone d'espace de travail.</para>

<para
>Lorsque vous cliquez sur l'onglet <guibutton
>CTags</guibutton
>, une fenêtre de dialogue s'ouvre, où vous trouverez le bouton suivant dans le coin inférieur droit.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-ctags-regenerate.png" format="PNG"/>
</imageobject>
<caption
><para
>Construire un index CTags avec le bouton <guibutton
>Régénérer</guibutton
>.</para
></caption>
</mediaobject>
</screenshot>

<para
>Cliquez sur le bouton <guibutton
>Régénérer</guibutton
> et attendez quelques secondes. L'élément <guilabel
>Aucune base de données de CTags trouvée</guilabel
> sera alors remplacé par la date actuelle. Vous êtes à présent prêt à effectuer des consultations par identifiant dans votre projet source.</para>

<tip>
<para
>La date située à côté du bouton <guilabel
>Régénérer</guilabel
> est là pour vous rappeler des éventuels index trop anciens. Chaque fois que vous êtes dans l'impossibilité évidente d'effectuer une consultation par identifiant dans votre projet, pensez à régénérer l'index. Dans les gros projets, cette opération risque de prendre beaucoup de temps, mais vous devriez prendre l'habitude de régénérer l'index régulièrement après des changements importants dans le fichier source.</para>
</tip>

<para
>Pour effectuer une consultation par identifiant dans les sources de votre projet, il y a plusieurs possibilités.</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Utiliser la vue des outils CTags</title>
<para
>C'est le plus simple. Commencez simplement par saisir un nom d'identifiant qui vous intéresse dans le champ d'entrée <guilabel
>Consultation par identifiant</guilabel
> dans le bas à gauche. &kdevelop; essaiera de compléter le mot que vous avez saisi jusqu'ici et affichera toutes les occurrences de ces identifiants commençant par cette séquence de caractères.</para>
</formalpara>

<para
>Si par exemple vous souhaitez savoir Ià où l'identifiant « Bonjour » a été utilisé dans notre exemple de projet, saisissez un « H » dans le champ d'entrée <guilabel
>Consultation par identifiant</guilabel
>. &kdevelop; se met immédiatement au travail et vous présente un résultat comme celui-ci :</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-ctags-lookup.png" format="PNG"/>
</imageobject>
<caption
><para
>Comment effectuer une consultation par identifiant dans la vue des outils <guilabel
>CTags</guilabel
>.</para
></caption>
</mediaobject>
</screenshot>

<para
>Si vous cliquez sur un des éléments listés, &kdevelop; ouvre une fenêtre d'édition contenant ce fichier et la position du curseur apparaît sur l'emplacement approprié.</para>
</listitem>

<listitem>
<formalpara>
<title
>Utiliser un menu contextuel dans un fichier source</title>
<para
>Cette fonction est pratique lorsque vous travaillez sur un certain fichier source. Supposons que vous examiniez le fichier <filename
>main.cpp</filename
> de notre exemple de projet « Bonjour ». Vous y trouvez la ligne suivante</para>
</formalpara>
<programlisting
>Bonjour *mainWin = 0;
</programlisting>
<para
>et vous vous demandez pour quoi le mot « Bonjour » a été utilisé dans le programme. Pour le découvrir, il surffit d'un clic droit sur cet identifiant « Bonjour ». Un menu apparaît en réponse à ce clic droit de la souris, comportant les lignes suivantes près du bas.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-ctags-menu.png" format="PNG"/>
</imageobject>
<caption
><para
>Obtention des informations <application
>CTags</application
> sur un identifiant interne d'un projet.</para
></caption>
</mediaobject>
</screenshot>

<para
>Cliquez sur celle qui vous intéresse, par exemple <guilabel
>CTags - Aller à la définition : Bonjour</guilabel
>, et &kdevelop; ouvre immédiatement la fenêtre d'édition <filename
>bonjour.cpp</filename
> et positionne le curseur juste devant cette définition de classe :</para>
<programlisting
>Bonjour::Bonjour()
    : KMainWindow( 0, "Bonjour" )
{
</programlisting>
</listitem>

<listitem>
<formalpara>
<title
>Faire une recherche globale</title>
<para
>Cette fonction est particulièrement utile pour consulter un texte arbitraire dans le source de votre projet. Il y a deux possibilités pour démarrer une recherche globale depuis &kdevelop;.</para>
</formalpara>
<itemizedlist>
<listitem>
<para
>Démarrer une recherche globale à partir du menu <menuchoice
><guimenu
>Édition</guimenu
> <guimenuitem
>Chercher dans les fichiers...</guimenuitem
></menuchoice
>. Ou</para>
</listitem>
<listitem>
<para
>Utiliser directement le menu contextuel à l'aide d'un clic droit de la souris dans la fenêtre d'édition.</para>
</listitem>
</itemizedlist>

<para
>Nous illustrerons la seconde possibilité avecnotre exemple de projet « Bonjour ». Le résultat de l'appel de menu sera essentiellement le même. Supposons que vous examiniez le fichier source <filename
>bonjour.cpp</filename
> et que votre curseur soit positionné sur la première occurrence de « Bonjour » présente. Maintenant, vous vous demandez où ce mot « Bonjour » a été employé dans le source du projet, et combien d'occurrences il y a. C'est le cas typique où utiliser les fonctions de recherche globale de &kdevelop;.</para>

<para
>À présent, si on laisse encore le curseur quelque part sur ce « Bonjour » dans le texte source, cliquez avec le &BDS;. Le menu contextuel maintenant bien connu apparaît, où vous devrez sélectionner la ligne <guilabel
>Grep : Bonjour</guilabel
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="editor-find-menu.png" format="PNG"/>
</imageobject>
<caption
><para
>Lancement d'une recherche globale depuis une fenêtre d'édition.</para
></caption>
</mediaobject>
</screenshot>

<para
>Cette fonction fait s'ouvrir la boîte de dialogue <guilabel
>Find in Files</guilabel
> suivante (exactement la même que si vous aviez utilisé le menu <menuchoice
><guimenu
>Édition</guimenu
> <guimenuitem
>Chercher dans les fichiers...</guimenuitem
></menuchoice
>).</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="find-in-files.png" format="PNG"/>
</imageobject>
<caption
><para
>Une interface polyvalente pour effectuer des recherches globales dans le projet.</para
></caption>
</mediaobject>
</screenshot>

<para
>Comme vous le constatez, c'est un outil très souple pour lancer des recherches avec <application
>find</application
> et <application
>grep</application
> tout au long de votre projet. Nous n'entrerons pas plus avant dans les détails ici, mais vous pouvez être amené à expérimenter cette fonction par vous-même. Pour le moment, notre « Bonjour » devra être présélectionné dans le champ <guilabel
>Motif</guilabel
>. Dans le cas contraire, il suffit de le saisir puis de cliquer sur le bouton <guibutton
>Chercher</guibutton
> en bas à droite.</para>

<para
>Maintenant la vue des outils <guilabel
>Chercher dans les fichiers</guilabel
> s'ouvre en bas, affichant les noms de fichiers et les lignes de toutes les occurrences littérales de « Bonjour » dans notre exemple de projet. Comme d'habitude, si vous cliquez sur un élément, &kdevelop; vous amènera exactement à cette position dans une fenêtre d'édition dans la zone d'espace de travail.</para>

<para
>Il y a deux lignes particulièrement intéressantes dans la fenêtre de vue des outils.</para>
<itemizedlist>
<listitem>
<para
>En haut à droite, vous trouverez les séquence de commandes que &kdevelop; a réellement utilisées pour effectuer la recherche. Ce sera utile pour un contrôle plus précis du résultat de la recherche.</para>
</listitem>

<listitem>
<para
>En bas, le n ombre d'occurrences trouvées lors de l'exécution de cette recherche sera répertorié. Dans notre exemple, on devrait lire « *** 11 matches found *** ».</para>
</listitem>
</itemizedlist>

<para
>&kdevelop; se souviendra de ces résultats de recherche tout au long la session s'exécutant actuellement. Si vous lancez une autre recherche globale, ses résultats s'affficheront dans une fenêtre à onglets dans la fenêtre de vue des outils <guilabel
>Chercher dans les fichiers</guilabel
>.</para>
</listitem>
</itemizedlist>
</sect3>
</sect2>

<sect2 id="gettingstarted-edit-arrange">
<title
>Agencement des fenêtres d'édition</title>

<para
>Lorsque vous travaillez avec de gros projets complexes, vous finissez souvent par avoir vraiment beaucoup de fenêtres d'édition résidant sur la barre d'onglets. Ce comportement rend nécessaires des fonctions pour nettoyer, ordonner et grouper tous ces onglets d'éditeur. &kdevelop; fournit plusieurs moyens pour cela. Nous jetterons un bref coup d'œil à certaines d'entre elles.</para>
<simplelist>
<member
><link linkend="gettingstarted-edit-arrange-clean"
>Comme supprimer les onglets non nécessaires.</link
></member>
<member
><link linkend="gettingstarted-edit-arrange-tabs"
>Comment réorganiser les onglets.</link
></member>
<member
><link linkend="gettingstarted-edit-arrange-split"
>Comment visualiser plusieurs fichiers simultanément dans la zone d'espace de travail.</link
></member>
<member
><link
linkend="gettingstarted-edit-arrange-sourceheader"
>Comment modifier des fichiers sources et d'en-tête C++ simultanément</link
></member>
<member
><link linkend="gettingstarted-edit-arrange-group"
>Comment grouper les fichiers sources en sessions de développement.</link
></member>
</simplelist>

<sect3 id="gettingstarted-edit-arrange-clean">
<title
>Nettoyage de la rangée des onglets</title>

<para
>Si la grande quantité d'onglets de fenêtres d'édition devient extrêmement mal organisée, vous pouvez généralement être amené à fermer ces onglets dont vous n'avez plus du tout besoin. &kdevelop; offre plusieurs fonctions pour ce faire, le moyen habituel de fermer en bloc les fenêtres d'édition ouvertes et une approche plus spécifique où vous pouvez expressément décider lesquelles fermer et lesquelles laisser ouvertes.</para>

<formalpara>
<title
>Fermer plusieurs onglets à la fois</title>
<para
>C'est une sorte d'approche en bloc pour fermer les onglets ouverts sans nécessité que vous pouvez trouver dans d'autres applications &kde; également. Vous pouvez utiliser le menu <guimenu
>Fenêtre</guimenu
> ou cliquer avec le &BDS; sur un onglet pour soit</para>
</formalpara>
<itemizedlist>
<listitem>
<para
>fermer la fenêtre d'édition actuellement sélectionnée,</para>
</listitem>
<listitem>
<para
>fermer toutes les fenêtres d'édition ouvertes, soit</para>
</listitem>
<listitem>
<para
>fermer toutes les fenêtres d'édition ouvertes (disponibles depuis le menu <guimenu
>Fenêtre</guimenu
> uniquement).</para>
</listitem>
</itemizedlist>

<formalpara>
<title
>Fermer les ensembles sélectionnés d'onglets</title>
<para
>L'approche pas à pas consistant à fermer les onglets de fenêtres d'édition individuels peut devenir malaisé s'il y a un grand nombre d'onglets dont vous voulez encore garder plusieurs d'entre eux ouverts. Au lieu de faire une recherche et de fermer un onglet de fenêtre d'édition après l'autre, &kdevelop; propose un moyen de sélectionner les candidats à partir d'une liste et de fermer ceux-ci, et seulement ceux-ci, d'un seul clic de souris.</para>
</formalpara>

<para
>Illustrons ce comportement dans un exemple simple. Dans notre exemple de projet « Bonjour », supposons qu'il y a avait plusieurs fichiers ouverts pour modification : <filename
>bonjour.cpp</filename
>, <filename
>bonjour.h</filename
>, <filename
>bonjour.rc</filename
>, <filename
>bonjour.desktop</filename
> et <filename
>main.cpp</filename
>. Maintenant, vous souhaitez les fermer tous, sauf <filename
>bonjour.cpp</filename
> et <filename
>bonjour.h</filename
>. Le moyen le plus facile de le faire consiste à utiliser la vue des outils <guilabel
>Liste des fichiers</guilabel
>. du fait que cette liste de fichiers ouverts est en ordre alphabétique, vous pouvez plus facilement trouver ceux que vous voulez voir fermés. Procédez comme suit :</para>

<procedure>
<step>
<para
>Ouvrez le menu <guilabel
>Liste des fichiers</guilabel
> et, en maintenant enfoncée la touche <keycap
>Ctrl</keycap
>, cliquez sur les fichiers que vous voulez voir fermés dans la liste.</para>
</step>
<step>
<para
>Ensuite, en laissant le pointeur de la souris sur un nom de fichier dans la liste, cliquez avec le &BDS;.</para>
</step>
<step>
<para
>Depuis le menu <guimenu
>Liste des fichiers</guimenu
> qui apparaît, sélectionnez  <guimenuitem
>Fermer la sélection</guimenuitem
>.</para>
</step>
</procedure>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="file-list-close-selected.png" format="PNG"/>
</imageobject>
<caption
><para
>Comment fermer les fenêtres d'édition sélectionnées en une étape.</para
></caption>
</mediaobject>
</screenshot>
<para
>C'est tout. &kdevelop; aura fermé toutes les fenêtres d'édition selon vos souhaits, et vous êtes prêt à continuer avec une barre d'outils propre à nouveau.</para>
</sect3>

<sect3 id="gettingstarted-edit-arrange-tabs">
<title
>Comment réorganiser les onglets des fenêtres d'édition</title>

<para
>Même si seules les fenêtres d'édition réellement nécessaires sont ouvertes, vous pouvez encore être amené à avoir leurs onglets onglets d'une manière logique. &kdevelop; fournit quelques moyens communs pour le faire, en bref :</para>

<formalpara>
<title
>Installation de base &mdash; Où positionner les nouveaux onglets</title>

<para
>Par défaut, lorsque vous ouvre une nouvelle fenêtre d'édition, son onglet sera inséré à droite de l'onglet de fenêtre d'édition actuellement utilisé. Ce comportement peut être modifié de façon que le nouvel onglet s'ouvre le plus à droite sur la barre d'onglets.</para>
</formalpara>
<para
>Vous devez changer un paramètre d'interface utilisateur de base dans &kdevelop; pour activer ce comportement.</para>
<procedure>
<step>
<para
>Sélectionnez <menuchoice
><guimenu
>Configuration</guimenu
> <guimenuitem
>Configurer KDevelop...</guimenuitem
></menuchoice
></para>
</step>
<step>
<para
>Dans la barre d'icônes à gauche sur la page de dialogue qui apparaît, cliquez sur l'icône <guilabel
>Interface utilisateur</guilabel
>. La page de dialogue<guilabel
>Interface utilisateur</guilabel
> s'affiche maintenant.</para>
</step>
<step>
<para
>Dans le coin inférieur gauche, se trouve la section étiquetée <guilabel
>Navigation par onglets</guilabel
>. Supprimer la coche sur la ligne <guilabel
>Ouvrir les nouveaux onglets après l'onglet actuel</guilabel
>.</para>
</step>
<step>
<para
>Fermez &kdevelop; et redémarrez-le. Maintenant, les nouveaux onglets de la fenêtre d'édition s'ouvriront à l'extrémité la plus à droite de la rangée des onglets actuels.</para>
</step>
</procedure>

<para
>Malheureusement, ce réglage ne peut pas être modifié à la volée pendant une session de développement. Décidez du comportement que vous préférez pour le long terme et tenez-vous en à celui-ci, au moins jusqu'au prochain démarrage de &kdevelop;.</para>

<formalpara>
<title
>Comment réorganiser les onglets</title>
<para
>Comme les tâches de développement varient dans le temps, la nécessité de réorganiser les fenêtres d'édition à onglets se fera jour plus ou moins souvent. &kdevelop; s'en charge très aisément.</para>
</formalpara>
<para
>Cliquez simplement sur l'onglet que vous souhaitez déplacer avec le &BCS; et déplacez la souris à une courte distance. Le curseur se changera en un motif en croix fléchée. Vous pouvez maintenant faire glisser cet onglet en maintenant enfoncé le &BCS; jusqu'à ce qu'il s'insère à l'endroit où vous voulez qu'il soit.</para>
</sect3>

<sect3 id="gettingstarted-edit-arrange-split">
<title
>Visualiser plusieurs fichiers simultanément</title>

<para
>Au premier affichage, il y a toujours tout au plus une seule fenêtre d'édition ouverte pour travailler sur un fichier source. Bien que vous puissiez rapidement changer de fenêtres à onglets, il y a des fois où vous serez amené à avoir plusieurs fichiers ouverts à la fois, &pex; à des fins de référence ou pour mieux maîtriser des tâches complexes. Pour y parvenir, &kdevelop; offre un moyen de scinder la zone d'espace de travail en différentes sections visibles simultanément, qui peuvent chacune contenir une série de fenêtres à onglets.</para>

<para
>Il y a deux commandes de division que vous pouvez atteindre l'une et l'autre via le menu <guimenu
>Fenêtre</guimenu
> ou un clic avec le &BDS; soit dans une fenêtre à onglets soit sur l'onglet de la fenêtre elle-même. Nous allons illustrer ce comportement de division à nouveau avec notre exemple de projet « Bonjour ».</para>

<para
>Supposons qu'il y ait deux fichiers source ouverts sur la barre d'onglets, <filename
>bonjour.cpp</filename
> et <filename
>bonjour.h</filename
>. À présent, en travaillant sur le source <filename
>bonjour.cpp</filename
>, comme vous devez souvent vous référer aux déclarations dans le fichier d'en-tête <filename
>bonjour.h</filename
>, vous serez amené à garder les deux fichiers ouverts simultanément.</para>

<para
>Pour ce faire, cliquez avec le &BDS; sur l'onglet, par exemple <filename
>bonjour.h</filename
>. Le menu suivant s'ouvre alors.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="split-workspace.png" format="PNG"/>
</imageobject>
<caption
><para
>Comment scinder la zone d'espace de travail actuelle en deux parties.</para
></caption>
</mediaobject>
</screenshot>

<para
>Sélectionnez l'élément <guimenuitem
>Scinder horizontalement</guimenuitem
>. Cette action divisera la zone d'espace de travail actuelle au milieu et déplacera la fenêtre d'édition à onglets contenant le fichier <filename
>bonjour.h</filename
> dans la partie inférieure.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="split-windows.png"/>
</imageobject>
<caption
><para
>L'espace de travail a été divisé horizontalement.</para
></caption>
</mediaobject>
</screenshot>

<para
>Notez la ligne de séparateur en pointillés entre les deux fenêtres. Vous pouvez la faire glisser à l'aide de la souris et ajuster la hauteur des fenêtres d'édition selon vos besoins.</para>

<para
>Il y a plusieurs points à noter.</para>
<itemizedlist>
<listitem>
<para
>Les zones d'espace de travail sont entièrement fonctionnels en elles-mêmes. Cela signifie que de nouvelles fenêtres à onglet s'ouvriront dans l'espace de travail qui contient la fenêtre d'édition actuellement active. Et vous pouvez scinder n'importe quelle sous-zone à nouveau à votre gré, gardant ainsi autant de fenêtres ouvertes simultanément qu'il vous en faut.</para>
</listitem>

<listitem>
<para
>Toute division déplacera la fenêtre d'édition actuellement active entrera dans la nouvelle sous-zone d'espace de travail, soit vers le bas soit vers la droite. Les autres fenêtres à onglets restent toutes là où elles étaient. Vous ne pouvez pas directement déplacer des fenêtres à onglets entre des zones divisées, à la place vous devez explicitement fermer la fenêtre dans une zone d'espace de travail et la rouvrir dans une autres pour regrouper.</para>
</listitem>

<listitem>
<para
>De plus, il n'existe pas de moyen direct de fermer une zone divisée à nouveau. Elle se ferme automatiquement, une fois que la dernière fenêtre à onglets se trouvant dedans a été fermée.</para>
</listitem>
</itemizedlist>
</sect3>

<sect3 id="gettingstarted-edit-arrange-sourceheader">
<title
>Modifier des fichiers sources et d'en-tête C++ simultanément</title>

<para
>Il y a une application ingénieuse de la fonctionnalité de division de l'espace de travail mentionnée ci-dessus intégrée à &kdevelop;. Elle permet de garder automatiquement un source <filename
>.cpp</filename
> et son fichier <filename
>.h</filename
> d'accompagnement ouverts côte à côte dans la zone d'espace de travail. Et, optionnellement, elle permet de travailler sur les fichiers de façon synchronisée, de telle sorte que si vous sélectionnez une déclaration dans le fichier d'en-tête, &kdevelop; naviguera jusqu'à la définition respective dans le fichier source et  vice versa.</para>

<para
>Cette fonctionnalité est cependant désactivée par défaut. Si vous voulez l'utilisez dans votre projet, il faut l'activer.</para>

<para
>Sélectionnez <menuchoice
><guibutton
>Projet</guibutton
> <guimenuitem
>Options du projet</guimenuitem
></menuchoice
>. La boîte de dialogue <guilabel
>Options du projet</guilabel
> apparaît. Dans la barre d'icônes à gauche ici, sélectionnez <guiicon
>Prise en charge du C++</guiicon
> et plus tard l'onglet <guilabel
>Navigation</guilabel
> sur la page de dialogue qui s'affiche sur le côté droit.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="split-source-header.png" format="PNG"/>
</imageobject>
<caption
><para
>Faire s'afficher les fichiers sources et d'en-tête C++ côte à côte.</para
></caption>
</mediaobject>
</screenshot>

<para
>Cochez à présent la case <guilabel
>Activer la division des fichiers d'en-tête / source</guilabel
>. Cette action activera <guilabel
>Synchronisation automatique</guilabel
> et <guilabel
>Vertical</guilabel
> par défaut. Gardez ces réglages pour l'instant et cliquez sur <guibutton
>OK</guibutton
>.</para>

<para
>Pour illustrer cette fonctionnalités, fermons maintenant dans notre exemple de projet à la fois les fenêtres d'édition <filename
>bonjour.cpp</filename
> et <filename
>bonjour.h</filename
>, si nécessaire. Sélectionnez ensuite <filename
>bonjour.cpp</filename
> à nouveau à partir du sous-dossier <filename class="directory"
>src</filename
> du projet. La fenêtre d'édition s'ouvrira comme d'habitude. Mais si vous ouvrez à présent le <filename
>bonjour.h</filename
> lui appartenant, &kdevelop; divisera automatiquement l'espace de travail et ouvrira cette fenêtre dédition du fichier d'en-tête juste au-dessous de la fenêtre <filename
>bonjour.cpp</filename
></para>

<para
>Il y a même plus, comme nous l'avons déjà mentionné. Dans l'éditeur <filename
>bonjour.cpp</filename
>, cherchez &pex; cette ligne de la définition du constructeur :</para>
<programlisting
>Bonjour::Bonjour()
</programlisting>
<para
>et placez le curseur dessus. Puis observez la fenêtre <filename
>bonjour.h</filename
> au-dessous et notez comment &kdevelop; a navigué vers la ligne de déclaration du constructeur par défaut.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="split-source-header-navigate.png" format="PNG"/>
</imageobject>
<caption
><para
>&kdevelop; a navigué automatiquement vers la déclaration du constructeur.</para
></caption>
</mediaobject>
</screenshot>

<para
>Cela fonctionne vice versa également. Chaque fois que vous placez le curseur à un endroit quelconque dans une structure (<foreignphrase
>construct</foreignphrase
>) dans une fenêtre d'édition, &kdevelop; naviguera vers une structure correspondante dans l'autre.</para>
</sect3>

<sect3 id="gettingstarted-edit-arrange-group">
<title
>Grouper des fichiers sources en sessions de développement</title>

<para
>Lorsque votre projet grossit et que les tâches de développement deviennent de plus en plus complexes et vous forcent à basculer souvent entre des ensembles de fichiers différents, mais distincts, il est temps d'organiser votre travail de développement en sessions distinctes. La vue des outils <guilabel
>Liste des fichiers</guilabel
> de &kdevelop; vous permet simplement de le faire.</para>

<para
>En haut de la fenêtre de vue des outils <guilabel
>Liste des fichiers</guilabel
>, il y a une barre d'outils où vous pouvez créer, enregistrer, sélectionner et supprimer de telles sessions. Ou, en alternative, utilisez le sous-menu <menuchoice
><guimenu
>Affichage</guimenu
> <guimenuitem
>Affichage des sessions</guimenuitem
></menuchoice
>.</para>

<para
>Nous illustrerons cette fonction à nouveau avec notre exemple de projet « Bonjour ». Supposons que vous souhaitiez toujours ouvrir les fichiers <filename
>bonjour.cpp</filename
>, <filename
>bonjour.h</filename
> et <filename
>main.cpp</filename
> tous à la fois, quelle que soit la tâche de développement que vous veniez d'effectuer dans le projet. Pour y parvenir, vous devez d'abord créer une nouvelle session de développement nommée, par exemple « sources ».</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="file-list-session-create.png" format="PNG"/>
</imageobject>
<caption
><para
>Utiliser les sessions de développement pour mémoriser des groupes de fichiers.</para
></caption>
</mediaobject>
</screenshot>

<para
>C'est une approche à étapes multiples comme suit.</para>
<procedure>
<step>
<para
>Créer une nouvelle session</para>
<substeps>
<step>
<para
>Cliquez sur l'icône <guiicon
>Nouvelle session</guiicon
> en haut à gauche dans la fenêtre de vue des outils <guilabel
>Liste des fichiers</guilabel
>.</para>
</step>
<step>
<para
>Une boîte de dialogue apparaît. Dans le champ d'entrée <guilabel
>Saisissez le nom de la session</guilabel
>, donnez à votre nouvelle session un nom, &pex; « sources ».</para>
</step>
<step>
<para
>Fermez la boîte de dialogue avec <guibutton
>OK</guibutton
>. La nouvelle session sera maintenant listée dans la zone de liste déroulante située sur la barre d'outils.</para>
</step>
</substeps>
</step>
<step>
<para
>Cette nouvelle session sera initialement vide. Vous devez la peupler avec les fichiers que que vous voulez garder ici.</para>
<substeps>
<step>
<para
>Ouvrez tous les fichiers que vous voulez groupés dans cette session de développement. Dans notre exemple, nous avons décidé d'y maintenir <filename
>bonjour.cpp</filename
>, <filename
>bonjour.h</filename
> et <filename
>main.cpp</filename
> comme prévu.</para>
</step>
<step>
<para
>Une fois que votre fichier est complet, cliquez sur l'icône <guiicon
>Enregistrer la session</guiicon
> dans la barre d'outils. Ne sautez pas cette étape, &kdevelop; oubliera la liste des fichiers sinon.</para>
</step>
</substeps>
</step>
</procedure>

<para
>C'est tout. Chaque fois que vous sélectionnez la session <guilabel
>sources</guilabel
> à partir de la zone de liste déroulante <guilabel
>Ouvrir la session</guilabel
>, &kdevelop; ferme toutes les fenêtres d'édition actuellement ouvertes et ouvre celles qui sont mémorisées (<filename
>bonjour.cpp</filename
>, <filename
>bonjour.h</filename
> et <filename
>main.cpp</filename
> dans notre exemple) à la place.</para>

<para
>Vous pouvez définir autant de sessions que vous le souhaitez dans le contexte de votre projet. Si vous voulez changer le contenu de la session, actualisez simplement la liste des fichiers mémorisés d'un clic sur <guiicon
>Enregistrer la session</guiicon
>. Et si vous souhaitez vous débarrasser d'une session, sélectionnez-la dans la zone de liste déroulante, puis cliquez sur l'icône <guiicon
>Supprimer la session</guiicon
> à droite de la barre d'outils.</para>

<para
>Il y a encore mieux. Vous pouvez forcer &kdevelop; à ouvrir une session donnée par défaut lorsqu'il charge le projet. Sélectionnez simplement la session dans la zone de liste déroulante sur la page de configuration des options du projet <menuchoice
><guimenu
>Projects</guimenu
> <guimenuitem
>Options du projet</guimenuitem
> <guimenuitem
>Liste des fichiers</guimenuitem
></menuchoice
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="file-list-session-default.png" format="PNG"/>
</imageobject>
<caption
><para
>Laissons le soin à &kdevelop; d'ouvrir une session spécifique lorsque le projet est chargé.</para
></caption>
</mediaobject>
</screenshot>
</sect3>
</sect2>

<sect2 id="gettingstarted-edit-problems">
<title
>Garder un œil sur les problèmes courants</title>

<para
>Lorsque vous ouvrez une fenêtre d'édition contenant un fichier source, &kdevelop; analyse la syntaxe de son contenu. Cette fonction permet au <emphasis
>rapporteur de problèmes</emphasis
> intégré d'analyser le texte du source pour chercher des erreurs communes dont il a connaissance. Et il peut alerter l'utilisateur à propos des différents endroits qui ont été marqués en vue d'un traitement spécial</para>

<para
>Illustrons cette fonction avec notre exemple de projet « Bonjour ».</para>

<itemizedlist>
<listitem>
<para
>Ouvre une fenêtre d'édition avec le fichier source <filename
>main.cpp</filename
>.</para>
</listitem>

<listitem>
<para
>Assurez-vous qu'il contienne toujours la ligne suivante quelque part vers la fin :</para>
<programlisting
>/// @todo do something with the command line args here
</programlisting>
<para
>Celle-ci a été insérée par l'&appwizard; lorsque vous avez créé le projet « Bonjour » dans le chapitre <link linkend="gettingstarted-new"
>Démarrer un nouveau projet</link
> ci-dessus.</para>
</listitem>

<listitem>
<para
>Ouvrez à présent la vue des outils <guilabel
>Problèmes</guilabel
> dans la rangée des onglets en bas. Si tout s'est bien passé, il affiche actuellement ce « À faire » :</para>
<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="problem-report-todo.png"/>
</imageobject>
<caption
><para
>&kdevelop; attire l'attention sur une ligne de code source contenant une marque « À faire ».</para
></caption>
</mediaobject>
</screenshot>
</listitem>
</itemizedlist>

<para
>Le format de la commande <computeroutput
>/// @todo</computeroutput
> pour un traitement spécial par le documenteur de code <application
>Doxygen</application
>, que nous étudierons brièvement dans la section <link linkend="gettingstarted-doc"
>Documentation</link
> ci-dessous. Il n'est pas obligatoire d'utiliser ce format, les marques de commentaires les plus courantes <computeroutput
>TODO</computeroutput
> et <computeroutput
>FIXME</computeroutput
> seront reconnues également.</para>

<para
>Si vous insérez &pex; les lignes de commentaires <computeroutput
>TODO</computeroutput
> et <computeroutput
>FIXME</computeroutput
> suivantes dans notre exemple de fichier <filename
>bonjour.cpp</filename
></para>
<programlisting
>Bonjour::Bonjour()
    : KMainWindow( 0, "Bonjour" )
{
    // set the shell's ui resource file
    // TODO check the user interface
    setXMLFile("bonjour.rc");

    // FIXME change to a better suited greeting
    new QLabel( "Bonjour tout le monde", this, "bonjour label" );
}
</programlisting>
<para
>vous les trouverez listés dans la vue des outils <guilabel
>Problèmes</guilabel
> également :</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="problem-report-marks.png" format="PNG"/>
</imageobject>
<caption
><para
>Le rapporteur de problèmes listant les lignes qui requièrent de l'attention dans le fichier en cours d'édition.</para
></caption>
</mediaobject>
</screenshot>

<para
>Notez que les autres onglets dans la fenêtre de la vue des outils du rapporteur de <guilabel
>problèmes</guilabel
>, spécialement <guilabel
>Corrigez_moi</guilabel
> et <guilabel
>TODO</guilabel
>. Si vous les ouvrez, vous trouverez toutes les lignes marquées <computeroutput
>FIXME</computeroutput
> et <computeroutput
>TODO</computeroutput
> que &kdevelop; a trouvées jusqu'ici dans cette session. Par exemple, les alertes <computeroutput
>TODO</computeroutput
> apparaissent de la manière suivante :</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="problem-report-all-todos.png" format="PNG"/>
</imageobject>
<caption
><para
>Le rapporteur de problèmes a collecté les alertes <computeroutput
>TODO</computeroutput
>.</para
></caption>
</mediaobject>
</screenshot>

<para
>L'onglet <guilabel
>Erreurs</guilabel
> ne listera cependant pas chaque erreur de codage que vous faites. Ce sera le travail d'autres outils dans le processus de construction &pex;. Mais vous trouverez ici des alertes de certaines erreurs de programmation communes qui passeraient volontiers inaperçues et seraient probablement détectées avec difficulté pendant une session de débogage complexe.</para>

<para
>Comme vous constaterez que la fonction de rapporteur de problèmes de &kdevelop; est un outil très utile, vérifiez la vue des outils <guilabel
>Problèmes</guilabel
> régulièrement dans le processus de développement.</para>
</sect2>
</sect1>

<sect1 id="gettingstarted-compile">
<title
>Comment compiler un projet</title>

<para
>Compiler un projet dans &kdevelop; requiert plusieurs étapes de configuration puis la construction de l'application. Toutes sont disponibles via le menu <guimenu
>Construire</guimenu
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="build-menu.png" format="PNG"/>
</imageobject>
<caption
><para
>Construire un projet requiert plusieurs étapes.</para
></caption>
</mediaobject>
</screenshot>

<para
>Nous nous intéressons à présent à la section supérieure uniquement de ce menu. Les entrées ici sont triées dans l'ordre de leur importance. Ainsi, la commande le plus souvent nécessaire est en haut, l'élément <guimenuitem
>Construire le projet</guimenuitem
>, qui amènera tout le projet à être initialisé, compilé et lié selon les besoins. D'autres éléments sont là pour compiler les portions du projet sélectionné ou un seul projet seulement, pour effectuer plusieurs séquences d'initialisation ou pour installer les exécutables de l'application achevés.</para>

<para
>Pour l'instant, concentrons-nous sur plusieurs fonctions que fournit &kdevelop; pour la configuration du projet, l'initialisation, la construction et l'exécution d'une application. En général, ceci comprend :</para>

<simplelist>
<member
><link linkend="gettingstarted-compile-basic"
>D'étudier brièvement le cyle de construction de base.</link
></member>
<member
><link linkend="gettingstarted-compile-setup"
>D'étudier certains moyens pour configurer un projet.</link
></member>
</simplelist>

<sect2 id="gettingstarted-compile-basic">
<title
>Le cycle de construction de base</title>

<para
>Dès l'instant où vous avez créé un nouveau projet, vous êtes généralement amené à vérifier si tout s'est bien passé jusqu'ici. Ceci impliques une première construction et un lancement test de l'application que nous allons effectuer maintenant. Afin de compiler initialement un projet, il y a plusieurs étapes à effectuer, que nous allons rapidement examiner.</para>
<simplelist>
<member
><link linkend="gettingstarted-compile-basic-init"
>Comment initialiser le projet pour une première construction.</link
></member>
<member
><link linkend="gettingstarted-compile-basic-config"
>Comment effectuer la configuration initiale.</link
></member>
<member
><link linkend="gettingstarted-compile-basic-build"
>Comment construire le projet.</link
></member>
<member
><link linkend="gettingstarted-compile-basic-run"
>Comment lancer l'application depuis &kdevelop;.</link
></member>
</simplelist>

<note>
<para
>Cette étude implique que votre projet soit basé sur la suite Autotools de &GNU; qui a activé l'outil &automanag; dans &kdevelop; comme le fait notre exemple de projet « Bonjour ». Si vous avez créé un autre projet type, &pex; pour le gestionnaire de projet <application
>QMake</application
> basé sur &Qt;, vous disposerez d'autres fonctions dans les menus ou peut-être aucune d'entre elles. Vous devrez consulter la documentation du fournisseur respectif sur la gestion des projets et la construction des applications dans ces cas-là.</para>
</note>

<sect3 id="gettingstarted-compile-basic-init">
<title
>Initilaiser le projet pour la construction</title>

<para
>Lorsque l'&appwizard; a créée notre exemple de projet « Bonjour », il l'a laissé dans une sorte d'état brut, « vierge ». La chaîne autotools de &GNU; impose plusieurs étapes d'initialisation à effectuer avant que l'application puisse être réellement compilé et lié. Si vous essayez de construire un projet dans un état aussi brut, &pex; en sélectionnant le menu <menuchoice
><guimenu
>Construire</guimenu
> <guimenuitem
>Construire le projet</guimenuitem
></menuchoice
> ou en appyant sur la touche de fonction <keycap
>F8</keycap
>, vous obtiendrez la mise en garde suivante.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="raw-project-warning.png" format="PNG"/>
</imageobject>
<caption
><para
>Essayer de construire un projet basé sur « automake » brut.</para
></caption>
</mediaobject>
</screenshot>

<para
>Vous pouvez cliquer sur le bouton <guibutton
>Les exécuter</guibutton
>, auquel cas &kdevelop; essaiera de lancer automatiquement toutes les étapes requises avant de compiler et lier l'application. Mais comme nous étudierons ces étapes initiales dans l'ordre, annulez la boîte de dialogue en cliquant sur <guibutton
>Ne pas exécuter</guibutton
>. </para>

<para
>Comme déjà mentionné, la compilation et la liaison de l'application est effectuée via le menu <guimenu
>Construire</guimenu
>. Appelez-le et sélectionnez <guimenuitem
>Exécuter « automake » et ses amis</guimenuitem
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="build-menu-automake.png" format="PNG"/>
</imageobject>
<caption
><para
>Lancer l'exécution de l'initialisation de base.</para
></caption>
</mediaobject>
</screenshot>

<para
>&kdevelop; va maintenant ouvrir la fenêtre de la vue des outils <guilabel
>Messages</guilabel
> en bas et de lister une série de messages produits par plusieurs outils « make ». Si tout s'est bien passé, la dernière ligne lira <quote
><computeroutput
>*** Success ***</computeroutput
></quote
>.</para>

<para
>Si vous remontez, vous trouverez la ligne de commande que &kdevelop; a émis pour appeler les outils au-dessous de la surface :</para>

<programlisting
>cd '/home/devel/projects/bonjour' &amp;&amp; \
WANT_AUTOCONF_2_5="1" WANT_AUTOMAKE_1_6="1" gmake -f Makefile.cvs
</programlisting>

<para
>Celle-ci indique essentiellement que &kdevelop; a d'abord basculé vers le dossier racine de notre exemple de projet. Puis il a configuré un environnement dédié, recommandant le système « make » des révisions d'outils <application
>autoconf</application
> et <application
>automake</application
> utilisées pour cette initialisation. Et finalement, il a conseillé l'outil « make » (<application
>gmake</application
> de &GNU; dans ce cas) pour traiter le fichier « make » <filename
>Makefile.cvs</filename
>.</para>

<para
>Ce fichier « make » a été automatiquement configuré lorsque vous avez créé le projet « Bonjour ». Il contient toutes les commandes nécessaiires pour initialiser correctement le projet, ainsi l'application résultante s'exécutera sous &kde;. En particulier, sera créé le fichier de script <filename
>configure</filename
> nécessaire pour exécuter la prochaine étape de configuration.</para>
</sect3>

<sect3 id="gettingstarted-compile-basic-config">
<title
>Configuration initiale de « Bonjour »</title>

<para
>Configurer signifie ajuster le processus de construction aux particularités du matériel et des logiciels de votre système. C'est une exigence fondamentale dans les processus de construction basés sur le schéma de la suite « Autotools » de &GNU; comme vous le savez probablement.</para>

<para
>Vous pouvez commander une séquence de configuration une fois que l'initialisation de base d'« automake » s'est terminée avec succès du fait que, seul après cette exécution initiale les fichiers <filename
>configure</filename
> nécessaires seront disponibles. Ceci fait, sélectionnez l'élément de menu <menuchoice
><guimenu
>Construire</guimenu
> <guimenuitem
>Exécuter le script « configure »</guimenuitem
></menuchoice
> pour lancer une séquence de configuration.</para>

<para
>&kdevelop; a ouvert la fenêtre de la vue des outils <guilabel
>Messages</guilabel
> à nouveau si nécessaire et listé les messages de l'exécution de « configure ». Si tout s'est bien passé, les messages de fin seront « <computeroutput
>Good - your configure finished. Start make now</computeroutput
> » (qui seront émis par « configure ») suivis du message « <computeroutput
>*** Success ***</computeroutput
> » de &kdevelop;.</para>

<para id="gettingstarted-compile-basic-config-cmd"
>Au début de la fenêtre <guilabel
>Messages</guilabel
>, vous trouverez à nouveau la ligne de commande que &kdevelop; a employé pour lancer l'exécution de cette configuration :</para>

<programlisting
>mkdir '/home/devel/projects/bonjour/debug' &amp;&amp; \
cd '/home/devel/projects/bonjour/debug' &amp;&amp; \
CXXFLAGS="-O0 -g3" "/home/devel/projects/bonjour/configure" --enable-debug=full
</programlisting>

<para
>Vous pouvez indiquer plusieurs détails intéressants à partir de ces commandes.</para>

<informaltable frame="none">
<tgroup cols="2"
><tbody
><row>
<entry>
<mediaobject>
<imageobject>
<imagedata fileref="tutorial-debug-tree.png"/>
</imageobject>
</mediaobject>
</entry>
<entry>
<itemizedlist>
<listitem>
<para
>D'abord, &kdevelop; utilise un sous-dossier dédié dans l'arborscences des dossiers du projet pour le processus de construction. Ce dossier de construction <filename class="directory"
>debug</filename
> (affiché à gauche) reflète la structure de base du projet et contient certains ensembles de fichiers relatifs à la construction, tels que plusieurs fichiers basés sur <filename
>configure</filename
> et, en outre, un <filename
>Makefile</filename
> dans chaque sous-dossier.</para>
</listitem>
<listitem>
<para
>Dans la section <link linkend="gettingstarted-compile-setup"
>Configurer le projet</link
> brièvement décrite ci-dessous, nous jetterons un bref coup d'œil aux motivations expliquant pourquoi &kdevelop; utilise des dossiers de construction séparés dans des cas comme celui-ci. Pour le moment, il suffit de savoir que &kdevelop; a créé ce dossier <filename class="directory"
>debug</filename
> &mdash; si nécessaire &mdash; avant l'appel de « configure » et que le script <filename
>configure</filename
> a créé la sous-structure et tous les <filename
>Makefiles</filename
> dedans.</para>
</listitem>
<listitem>
<para
>Ensuite, depuis le dossier de construction <filename class="directory"
>debug</filename
>, &kdevelop; a appelé le script <filename
>configure</filename
> dans le dosser racine de notre projet en utilisant un environnement dédié, où les drapeaux <computeroutput
>CXXFLAGS="-O0 -g3"</computeroutput
> signaleront plus tard au compilateur &gcc; qu'il ne devra pas optimiser les binaires résultant ni inclure les informations de débogage complètes avec ceux-ci.</para>
</listitem>
<listitem>
<para
>Pour finir, le script <filename
>configure</filename
> a été appelé avec l'option <computeroutput
>--enable-debug=full</computeroutput
> qui lui donne pour instruction de créer chaque <filename
>Makefile</filename
> pour que la compilation et la liaison ultérieures aient toutes les informations de débogage nécessaires intégrées et utilisables.</para>
</listitem>
</itemizedlist>
</entry>
</row
></tbody
></tgroup>
</informaltable>

<para
>Tous ces réglages sont configurables pour chaque projet. Vous en saurez plus à ce sujet dans le chapitre <link linkend="project-management"
>Gestions de projets</link
>.</para>
</sect3>

<sect3 id="gettingstarted-compile-basic-build">
<title
>Construire le projet</title>

<para
>Une fois arrivé à ce stade, vous serez prêt à réelllement construire, &cad; compiler et lier l'application. Si l'on observe le menu <guimenu
>Construire</guimenu
>, il y a trois options de compilations de ce types dans lesquelles choisir.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="build-commands.png" format="PNG"/>
</imageobject>
<caption
><para
>Commandes de &kdevelop; pour construire des binaires (exécutables).</para
></caption>
</mediaobject>
</screenshot>

<para
>De bas en haut, ce sont :</para>
<itemizedlist>
<listitem>
<para
><guimenuitem
>Compiler le fichier</guimenuitem
> &mdash; Cette option compilera le fichier source dans la fenêtre d'édition actuellement ouverte, Utilisée la plupart du temps pour des contrôles d'erreur rapides.</para>
</listitem>
<listitem>
<para
><guimenuitem
>Construire la cible active</guimenuitem
> &mdash; Cette option est principalement utilisée en liaison avec le <link linkend="gettingstarted-extend-automake"
>Gestionnaire « automake »</link
> que nous verrons brièvement ci-dessous.</para>
</listitem>
<listitem>
<para
><guimenuitem
>Construire le projet</guimenuitem
> &mdash; Maintenant, c'est celle à laquelle nous nous intéressons actuellement. Elle itère sur l'ensemble du projet, compilant et liant tous les fichiers autant que nécessaire.</para>
</listitem>
</itemizedlist>

<para
>Il pourrait être intéressant d'observer ce qui se passe dans le dossier <filename class="directory"
>Déboguer</filename
> créé lors du lancement précédent de <filename
>configure</filename
>. Donc gardez-le ouvert avec tous les sous-dossiers dépliés exactement comme représenté ci-dessus. Puis sélectionnez <menuchoice
><guimenu
>Construire</guimenu
> <guimenuitem
>Construire le projet</guimenuitem
></menuchoice
> (ou appuyez sur la touche <keycap
>F8</keycap
>) pour lancer la séquence de construction. Comme précédemment, la fenêtre de la vue des outils <guilabel
>Messages</guilabel
> s'ouvrira en bas et listera le résultat de l'exécution de cette construction. Et de plus, certains fichiers apparaîtront sur le sous-arbre <filename class="directory"
>Déboguer</filename
>.</para>

<para id="gettingstarted-compile-basic-build-cmd"
>Comme il n'y a pas beaucoup de fichiers sources dans n otre exemple de projet « Bonjour », la fenêtre <guilabel
>Messages</guilabel
> ne contiendra que quelques lignes. Au début de celles-ci là aussi, cherchez la ligne de commande que &kdevelop; a émise sur le terminal sous-jacent.</para>

<programlisting
>cd '/home/devel/projects/bonjour/debug' &amp;&amp; \
WANT_AUTOCONF_2_5="1" WANT_AUTOMAKE_1_6="1" gmake -k 
</programlisting>

<para
>Sans grande surprise, &kdevelop; a basculé vers la racine du sous-arbre <filename class="directory"
>Déboguer</filename
> afin d'exécuter le  <filename
>Makefile</filename
> situé ici. Un sous-environnement dédié a été configuré à nouveau comme avant dans l'<link linkend="gettingstarted-compile-basic-init"
>étape d'initialisation</link
> dans laquelle ensuite l'outil <application
>gmake</application
> a été appelé.</para>

<para
>Notez que l'option <computeroutput
>-k</computeroutput
> dans l'appel <application
>gmake</application
>. Elle force le processus de construction à continuer jusqu'à sa fin, même si des erreurs se produisent. Ceci est judicieux puisque &kdevelop; listera tous les messages d'erreur dans la fenêtre <guilabel
>Messages</guilabel
>. S'il y en a, utilisez les avantages d'un &EDI;: Cliquez juste sur le message d'erreur dans la fenêtre <guilabel
>Messages</guilabel
> et &kdevelop; vous amènera exactement à la position où l'erreur s'est produite dans le fichier source.</para>

<para
>Et que s'est-il passé à l'intérieur du sous-arbre <filename class="directory"
>Déboguer</filename
> ? Pas grand chose. Quelques lignes se sont affichées sur les branches <filename class="directory"
>doc/en</filename
> et <filename class="directory"
>src</filename
>, plus particulièrement le fichier <filename
>bonjour</filename
> dans <filename class="directory"
>/home/devel/projects/bonjour/debug/src/</filename
>. Celui-ci, finalement, est l'exécutable de l'application que nous cherchions. Tout ce qui reste à faire dans notre contrôle initial de projet est d'exécuter ce <filename
>bonjour</filename
>.</para>
</sect3>

<sect3 id="gettingstarted-compile-basic-run">
<title
>Exécuter l'application</title>

<para
>Il n'y a pas d'étapes supplémentaires impliquées pour lancer cette nouvelle application « Bonjour ». Sélectionnez  <menuchoice
><guimenu
>Construire</guimenu
> <guimenuitem
>Exécuter le programme</guimenuitem
></menuchoice
>, appuyez sur <keycombo
><keycap
>Maj</keycap
> <keycap
>F9</keycap
></keycombo
> ou utilisez le bouton <guibutton
>Exécuter le programme</guibutton
> sur la <guilabel
>barre d'outils de construction</guilabel
> affichée ci-dessous.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="run-button.png"/>
</imageobject>
<caption
><para
>Exécuter une application à partir de la <guilabel
>barre d'outils de construction</guilabel
>.</para>
</caption>
</mediaobject>
</screenshot>

<para
>C'est tout. &kdevelop; va maintenant démarrer la nouvelle application dans la fenêtre de terminal dédié qui s'ouvre en tant que vue des outils <guilabel
>Application</guilabel
> en bas. Ici; la commande &kdevelop; émise pour exécuter le programme sera affichée sur la ligne du haut :</para>

<programlisting
>./bonjour
</programlisting>

<para
>montrant que l'&EDI; a une notion à propos de l'endroit où réside l'exécutable qu'il lancera. Cette notion peut être largement configurée. Vous en saurez plus à ce sujet dans le chapitre <link linkend="project-management"
>Gestion des projets</link
>.</para>

<para
>La ligne <computeroutput
>./bonjour</computeroutput
> sera très probablement suivie d'un message d'avertissment. Ignorez-le pour le moment. Il n'empêche pas notre application <application
>Bonjour</application
> de tourner.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="hello-world-app.png" format="PNG"/>
</imageobject>
<caption>
<para
>Notre application <application
>Bonjour</application
> initiale.</para>
</caption>
</mediaobject>
</screenshot>

<para
>Fermez la fenêtre de l'application <application
>Bonjour</application
> comme d'habitude. Si aucune erreur ne s'est produite, &kdevelop; signalera ceci sous la forme « <computeroutput
>*** Exited normally ***</computeroutput
> » dans la fenêtre de la vue des outils <guilabel
>Application</guilabel
>.</para>
</sect3>
</sect2>

<sect2 id="gettingstarted-compile-setup">
<title
>Configurer le projet</title>

<para
>Dans &kdevelop; il y a de nombreux moyens permettant de gérer votre projet. Ce comportement est configurable pour chaque projet et du plus grand intérêt pour le développeur avancé. Néanmoins, il y a quelques paramètres propres au projet que vous devriez connaître dès le départ. </para>

<simplelist>
<member
><link linkend="gettingstarted-compile-setup-build"
>Quelle est l'utilité des configurations de construction ?</link
></member>

<member
><link linkend="gettingstarted-compile-setup-config"
>Où définir le comportement du script <filename
>configure</filename
>.</link
></member>

<member
><link linkend="gettingstarted-compile-setup-make"
>Quelques considérations sur la manière dont <application
>make</application
> devra s'exécuter.</link
></member>

<member
><link linkend="gettingstarted-compile-setup-run"
>Où devra être l'exécutable et comment devra-t-il être appelé ?</link
></member>
</simplelist>

<sect3 id="gettingstarted-compile-setup-build">
<title
>Configurations de construction</title>

<para
>Lorsque nous avons lancé une première exécution du script <filename
>configure</filename
> dans la section <link linkend="gettingstarted-compile-basic-config"
>Configuration initiale de « Bonjour »</link
> ci-dessus, nous avons noté que &kdevelop; a configuré un sous-dossier <filename class="directory"
>debug</filename
> dédié dans ce but. Dans cette section, nous verrons brièvement certaines conséquences de cette fonctionnalité.</para>

<para
>Avant toute chose, &kdevelop; n'emploie pas nécessairement les sous-dossiers de construction dédiés séparément du source. Les préparations pour utiliser des configurations de constructions dédiées sont effectuées à l'aide de modèles sont l'&appwizard; se sert lorsqu'on crée un nouveau projet.</para>

<para
>Pour découvrie quelles sont les configurations de construction disponibles, jetez un coup d'œil au menu <menuchoice
><guimenu
>Projet</guimenu
> <guisubmenu
>Configuration de la construction</guisubmenu
></menuchoice
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="build-configurations.png" format="PNG"/>
</imageobject>
<caption
><para
>Il existe diverses configurations de construction disponibles pour ce projet.</para
></caption>
</mediaobject>
</screenshot>

<para
>Dans ce cas, comme notre exemple de projet « Bonjour », il y a trois configurations de construction différentes disponibles. Dans d'autres cas, il peut &mdash; initialement &mdash; y avoir uniquement une seule configuration de construction de ce type, à savoir <guimenuitem
>par défaut</guimenuitem
>.</para>

<para
>La configuration de construction actuellement utilisée porte une coche à sa gauche. Afin de basculer vers une autre configuration de construction, sélectionnez simplement son élément de menu.</para>

<para
>Maintenant, jetons un bref coup d'œil à ce que fournissent ces configurations de construction.</para>

<variablelist id="gettingstarted-compile-setup-build-configs">
<varlistentry>
<term
><guimenuitem
>débogage</guimenuitem
></term>
<listitem>
<para
>Vous devriez utiliser cette configuration à titre de configuration de construction standard pendant le processus de développement. La construction se produit séparément à partit des dossiers sources dans le sous-dossier <filename class="directory"
>debug</filename
> dédié, &cad; que tous les fichier d'objet, auxiliaires et exécutables seront placés dans les sous-dossiers ici au lieu de leurs contre-parties dans la racine du projet. Le script <filename
>configure</filename
> se verra attribuer l'option <computeroutput
>--enable-debug=full</computeroutput
> et le <computeroutput
>CXXFLAGS="-O0 -g3"</computeroutput
> signalera au compilateur &gcc; de ne pas optimiser le code et d'insérer les informations exhaustives de débogage dans les binaires résultants.</para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenuitem
>optimisée</guimenuitem
></term>
<listitem>
<para
>Cette configuration est utilisée pour construire une application finale en C++. La construction se produit séparément des dossiers sources dans le sous-dossier <filename class="directory"
>optimisée</filename
> dédié. Aucun argument spécifique au script <filename
>configure</filename
> ne sera présélectionné, néanmoins le <computeroutput
>CXXFLAGS="-O2 -g0"</computeroutput
> signalera au compilateur &gcc; compiler d'optimiser le code et de ne pas insérer d'informations de débogage dans les binaires résultants.</para>
</listitem>
</varlistentry>

<varlistentry>
<term
><guimenuitem
>par défaut</guimenuitem
></term>
<listitem>
<para
>Le terme « par défaut » désigne la configuration standard lorsque vous construisez une application à partir de la console en utilisant &pex; les outils de construction orientés ligne de commande <application
>configure</application
> et <application
>make</application
>/<application
>gmake</application
> de &GNU;. Aucun autre dossier de construction dédié que <guimenuitem
>débogage</guimenuitem
> ou <guimenuitem
>optimisée</guimenuitem
> ne sera utilisé. L'application sera par défaut construite dans les dossiers sources à la place. Il n'y a pas de commutateurs de configuration spéciaux prédéfinis. La construction et le lancement de l'application utiliseront les réglages par défaut des outils sous-jacents (&pex; &gcc;, etc.).</para>

<warning>
<para
>Réfléchissez bien avant de vous décider à utiliser l'environnement de construction <guimenuitem
> par défaut</guimenuitem
> !</para>

<para
>Il ne peut pas être employé en parallèle avec les configurations <guimenuitem
>débogage</guimenuitem
> ou <guimenuitem
>optimisée</guimenuitem
>. <emphasis
>Toute opération de construction utilisant <guimenuitem
>par défaut</guimenuitem
> rendra les deux autres environnements de construction inutilisables.</emphasis
> Ce comportement est causé par certaines particularités du processus de construction <filename
>Makefile</filename
> utilisant le mécanisme <application
>automake</application
>/<application
>autoconf</application
>, dont il n'est pas facile de venir à bout.</para>
</warning>
</listitem>
</varlistentry>
</variablelist>

<para
>À présent, pourquoi voudrait-on utiliser différentes configurations de construction, lorsqu'elles s'avèrent même ne pas être compatibles entre elles ? La réponse est &mdash; cela simplifie les cycles édition-compilation-débogage. Les instructions de débogage supplémentaires insérées dans les binaires ainsi que tous ces changements de structure subtiles apportés au code du programme pendant les optimisations affecteront le comportement au moment de l'exécution de l'application résultante. ainsi dans de nombreux cas, vous pouvez être amené à tester si elle se comporte encore correctement dans des conditions plus adaptées.</para>

<para
>C'est là où les configurations de construction de &kdevelop; interviennent. Du fait que les fichiers objet et exécutables de construction de chaque dossier de construction dédié et es commandes sont gardées séparément les uns des autres, seuls les changements du source doivent être gérés lorsque vous basculez entre ces configurations de construction.</para>

<para
>Ainsi, au lieu de nettoyer et de recompiler tout de zéro avec d'autres options, il vous suffit de basculer depuis la configuration de construction <guimenuitem
>débogage</guimenuitem
> vers <guimenuitem
>optimisée</guimenuitem
>, faire se compiler les changements du source, puis tester à nouveau l'application dans ces circonstances. Si quoi que ce soit d'inapproprié apparaît, revenez simplement en arrière vers <guimenuitem
>débogage</guimenuitem
> et continuez immédiatement votre travail à cet endroit.</para>

<para
>Une dernière remarque &mdash; de nombreux paramètres de configuration de construction sont configurables. Vous pouvez même définir vos propres configurations de construction si votre processus de développement en requiert. Nous examinerons brièvement ces possibilités dans la section suivante.</para>
</sect3>

<sect3 id="gettingstarted-compile-setup-config">
<title
>Options de configuration d'un projet</title>

<para
>Configurer l'application correctement est vital dans la chaîne de construction de la suite « autotools » de &GNU;. Cette opération est habituellement guidée par les définitions des options dans le script <filename
>configure</filename
> et/ou les réglages des drapeaux spécifiques dans l'environnement avant d'exécuter <filename
>configure</filename
> comme &pex; le <computeroutput
>CXXFLAGS</computeroutput
> dans nos exposés précédents.</para>

<para
>Vous pouvez définir la plupart des options de configuration pour un projet donné depuis l'interface graphique de &kdevelop;. Sélectionnez <menuchoice
><guimenu
>Projet</guimenu
> <guimenuitem
>Options du projet</guimenuitem
></menuchoice
> puis depuis la barre d'icônes sur la gauche de la boîte de dialogue de l'icône <guiicon
>Options de « configure »</guiicon
>. La boîte de dialogue <guilabel
>Options de « configure »</guilabel
> comprenant plusieurs fenêtre à onglets s'affichera sur le côté droit.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-configure.png" format="PNG"/>
</imageobject>
<caption
><para
>La plupart des options de « configure » peuvent être définies ici.</para
></caption>
</mediaobject>
</screenshot>

<para
>Comme vous le voyez, il y a beaucoup d'options susceptibles d'être configurées dans cette boîte de dialogue. Pour l'instant, nous n'en examinerons que quelques-unes en ce qui concerne notre exemple de projet « Bonjour ». Pour des instructions détaillées, consultez le chapitre <link linkend="projects-configure"
>Configurer des projets</link
>. Si vous voulez en savoir plus sur la signification des divers drapeaux qui peuvent être définis, consultez <command
>info make</command
> depuis la console (ou <command
>info:make</command
> depuis &konqueror;) et là, la section <menuchoice
><guimenu
>Implicit Rules</guimenu
> <guimenuitem
>Implicit Variables</guimenuitem
></menuchoice
>.</para>

<para
>Il y a plusieurs fenêtres de configuration de boîtes de dialogue à onglets dont la première, <guilabel
>Général</guilabel
> se rapporte aux paramètres d'utilisation courante, alors que les autres sont plutôt propres au compilateur. Dans tous les cas, cependant, le contenu réel de ces boîtes de dialogue sera administré par la configuration de construction donnée.</para>

<para
>Sélectionnez la configuration de construction dont les paramètres de configuration doivent être définis depuis la zone de liste modifiable <guilabel
>Configuration</guilabel
> en haut de la boîte de dialogue <guilabel
>Options de « configure »</guilabel
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-buildconfig.png" format="PNG"/>
</imageobject>
<caption
><para
>Sélectionnez la configuration de construction dont les les paramètres sont à définir.</para
></caption>
</mediaobject>
</screenshot>

<para
>À présent, sélectionnez une configuration de ocnstruction à partir de cette zone de liste modifiable et notez comment le contenu, &pex; des zones de texte <guilabel
>Arguments du script « configure »</guilabel
> et <guilabel
>Dossier de construction</guilabel
> changent en fonction des paramètres que nous avons mentionnés dans la <link linkend="gettingstarted-compile-setup-build-configs"
>liste des confogurations de construction</link
> ci-dessus.</para>

<sect4 id="gettingstarted-compile-setup-config-general">
<title
>Paramètres généraux de de la configuration</title>

<para
>Sur la page de dialogue <guilabel
>Général</guilabel
>, on peut définir ces options de configuration :</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Arguments du script « configure »</title>
<para
>Ce sont les options que &kdevelop; affecte à l'appel du script <filename
>configure</filename
> dans le processus de construction. Voir l'<link linkend="gettingstarted-compile-basic-config-cmd"
>exemple</link
> dans la section « Configuration initiale de « Bonjour » »  ci-dessus.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Dossier de construction</title>
<para
>C'est le sous-dossier dans la racine du projet actuel, où &kdevelop; placera tous les fichiers créés au cours du processus de construction. Dans l'idéal, celui-ci devra correspondre au nom de la configuration de construction en cours d'utilisation, mais vous êtes libre d'employer le nom de votre choix, pourvu qu'il soit différent de tout autre dossier de configuration de construction.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Dossier racine des sources</title>
<para
>Vous n'en pas souvent besoin. Ce paramètre est réglé par défaut sur le dossier racine du projet et ne doit être redéfini que si les sources de votre projet sont situées dans un autre endroit.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Drapeaux du préprocesseur C/C++ (CPPFLAGS)</title>
<para
>Placez les instructions spécifiques pour le préprocesseur ici. &kdevelop; utilisera ce paramètres pour configurer un environnement temporaire avant d'appeler l'outil de construction proprement dit. Là aussi, consultez l'<link linkend="gettingstarted-compile-basic-config-cmd"
>exemple</link
> dans la section « Configuration initiale de « Bonjour » » ci-dessus pour savoir comment faire.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Drapeaux de l'éditeur de liens (LDFLAGS)</title>
<para
>Ce sont des informations supplémentaires pour l'outil d'édition de liens <application
>ld</application
> où il devra rechercher les bibliothèques additionnelles. Il est utilisé pour construire l'environnement de construction temporaire également.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Variables d'environnement</title>
<para
>Ici vous pouvez décider de configurer des variables supplémentaires dans l'environnement de construction temporaire que &kdevelop; installera avant d'appeler l'outil de construction respectif. Là encore, vous devez définir ces variables d'environnement pour chaque configuration de construction là où elles doivent être employées.</para>
</formalpara>
</listitem>
</itemizedlist>
</sect4>

<sect4 id="gettingstarted-compile-setup-config-spec">
<title
>Paramètres propres au compilateur</title>

<para
>Les autres onglets sur la page de dialogue <guilabel
>Options du script « configure »</guilabel
> sont des réglages propres au compilateur. Comme ils sont structurés de la même manière, il suffit de jeter un petit coup d'd'œil à la page <guilabel
>C++</guilabel
>.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-cpp.png" format="PNG"/>
</imageobject>
<caption
><para
>Sélectionnez le compilateur et l'environnement de travail que &kdevelop; utilisera ici.</para
></caption>
</mediaobject>
</screenshot>

<para
>Voici ce que vous pouvez configurer à partir d'ici :</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Compilateur C++</title>
<para
>Sélectionnez le compilateur C++ que &kdevelop; devra utiliser régulièrement à partir de cette zone de liste modifiable. Elle ne liste toutefois que les compilateurs dont &kdevelop; a réellement connaissance.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Commande système du compilateur (CXX)</title>
<para
>Seulement pour les experts. Ce paramètre n'est nécessaire que si le compilateur C++ n'est pas standard. Placez le nom par lequel il est appelé ici.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Drapeaux du compilateur (CXXFLAGS)</title>
<para
>Ici vous pouvez saisir n'importe quelle option supplémentaire que &kdevelop; passera (via le <filename
>Makefile</filename
>) au compilateur. Certaines valeurs des option seront prédéfinies en fonction de la configuration de construction sélectionnée dans la zone de liste modifiable <guilabel
>Configuration</guilabel
>.</para>
</formalpara>

<para
>Notez que beaucoup d'options communes du compilateur peuvent être sélectionnés à partir d'une boîte de dialogue qui s'ouvre lorsque vous cliquez sur le bouton  <guibutton
>...</guibutton
> à droite de la zone de texte.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-cppoptions.png" format="PNG"/>
</imageobject>
<caption
><para
>Utilisez cette boîte de dialogue pour définir le comportement du compilateur C++ de &GNU;.</para
></caption>
</mediaobject>
</screenshot>

<para
>Nous avons délibérément choisi l'onglet <guilabel
>Optimisation</guilabel
> ici. Notez comment l'option <guilabel
>Aucune optimisation</guilabel
> a été présélectionnée (en fonction de l'option <computeroutput
>-O0</computeroutput
> prédéfinie dans la configuration de construction <computeroutput
>débogage</computeroutput
>).</para>

<para
>Malheureusement, vous ne pouvez pas actuellement sélectionner toutes les options à partir de cette boîte de dialogue. L'option <computeroutput
>-g3</computeroutput
>, &pex;, utilisée par la configuration de construction <computeroutput
>debug</computeroutput
> devra être changée à la main si jamais elle était nécessaire.</para>
</listitem>
</itemizedlist>
</sect4>
</sect3>

<sect3 id="gettingstarted-compile-setup-make">
<title
>Comment « make » devra construire le programme</title>

<para
>Vous pouvez également configurer la manière dont &kdevelop; appellera l'outil <application
>make</application
> dans la construction du projet. Sélectionnez <menuchoice
><guimenu
>Projet</guimenu
> <guimenuitem
>Options du projet</guimenuitem
></menuchoice
> puis l'icône <guiicon
>Options de « make »</guiicon
> sur le côté gauche de la fenêtre de dialogue. La page de dialogue <guilabel
>Options de « make »</guilabel
> sera alors affichée sur la droite.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-make.png" format="PNG"/>
</imageobject>
<caption
><para
>Définissez comment &kdevelop; appellera l'outil <application
>make</application
>.</para
></caption>
</mediaobject>
</screenshot>

<para
>Il n'y a pas grand chose à faire ici pour l'instant. Le seul paramètre digne d'intérêt dans la plupart des cas sera le commutateur <guilabel
>Arrêter dès la première erreur</guilabel
>. Vous le trouverez désactivé dans la majorité des projets. Ce comportement correspond à l'option <computeroutput
>-k</computeroutput
> dans l'appel de <application
>gmake</application
> que nous avons trouvé dans la <link linkend="gettingstarted-compile-basic-build-cmd"
>construction initiale</link
> de notre exemple de projet « Bonjour ».</para>

<para
>Ceci prend tout son sens dans un &EDI; comme &kdevelop; qui journalisera tout message d'erreur pendant la construction. Après le processus de construction, vous pouvez facilement naviguer jusqu'à un message d'erreur quelconque dans la fenêtre de la vue des outils <guilabel
>Messages</guilabel
>. Cliquez sur <menuchoice
><guimenu
>Affichage</guimenu
> <guimenuitem
>Erreur suivante</guimenuitem
></menuchoice
> et <menuchoice
><guimenu
>Affichage</guimenu
> <guimenuitem
>Erreur précédente</guimenuitem
></menuchoice
> ou appuyez respectivement sur les touches <keycap
>F4</keycap
> et <keycombo
><keycap
>Maj</keycap
> <keycap
>F4</keycap
></keycombo
> pour cela. &kdevelop; activera automatiquement la fenêtre d'édition du fichier source en question et placera le curseur sur la ligne contenant l'erreur.</para>

<para
>Si par ailleurs, vous souhaitez plutôt arrêter la construction à chaque fois qu'une erreur se produit, cochez l'option <guilabel
>Arrêter dès la première erreur</guilabel
> dans cette boîte de dialogue. &kdevelop; appellera alors <application
>gmake</application
> sans l'option <computeroutput
>-k</computeroutput
>.</para>
</sect3>

<sect3 id="gettingstarted-compile-setup-run">
<title
>Comment lancer l'exécutable</title>

<para
>Une fois que la construction est achevée, vous pouvez facilement lancer l'application depuis &kdevelop;. Utilisez soit <menuchoice
><guimenu
>Construire</guimenu
> <guimenuitem
>Exécuter le programme</guimenuitem
></menuchoice
>, les touches <keycombo
><keycap
>Maj</keycap
> <keycap
>F9</keycap
></keycombo
>, soit le bouton <guibutton
>Exécuter le programme</guibutton
> dans la <guilabel
>barre d'outils de construction</guilabel
> de &kdevelop;.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="run-button.png" format="PNG"/>
</imageobject>
<caption
><para
>Exécutez le programme à partir d'ici.</para
></caption>
</mediaobject>
</screenshot>

<para
>Mais où est situé l'exécutable qui devra être lancé ? Comment fait-on pour ajouter des options &kdevelop; à l'appel ? Ou encore, comment puis-je faire s'exécuter l'application dans un terminal indépendant pour en tester le comportement interactif en mode console ?</para>

<para
>Tous ces aspects peuvent être résolus en configurant certaines options d'exécution orientées projet dans &kdevelop;. Cliquez sur <menuchoice
><guimenu
>Projet</guimenu
> <guimenuitem
>Options du projet</guimenuitem
></menuchoice
> puis sur l'icône <guiicon
>Options d'exécution</guiicon
> depuis la barre d'icône située sur le côté gauche de la fenêtre de dialogue. La page de dialogue <guilabel
>Options d'exécution</guilabel
> s'affichera à droite.</para>

<screenshot>
<mediaobject>
<imageobject>
<imagedata fileref="configure-project-run.png" format="PNG"/>
</imageobject>
<caption
><para
>Définissez où et comment votre programme devra être exécuté.</para
></caption>
</mediaobject>
</screenshot>

<para
>Maintenant, il y a énormément de paramètres à configurer à partir de cette boîte de dialogue. Pour l'essentiel, il existe quatre groupes d'éléments de configuration.</para>

<itemizedlist>
<listitem>
<formalpara>
<title
>Dossier</title>
<para
>Ce paramètre indique à &kdevelop; où il devra en principe supposer que se trouve l'exécutable à appeler. Vous avez trois possibilités parmi lesquelles choisir.</para>
</formalpara>

<para
>Notez cependant que seuls les dossiers racine sont définis ici. &kdevelop; cherche habituellement l'exécutable dans un sous-dossier indiqué dans le prochain groupe de configuration.</para>

<itemizedlist>
<listitem>
<para
>Lancez depuis le dossier dans lequel l'exécutable a été construit la dernière fois. C'est le réglage par défaut. Vous pouvez le conserver pour l'instant.</para>
</listitem>

<listitem>
<para
>Lancez à partir du dossier de construction en fonction de la <link linkend="gettingstarted-compile-setup-build"
>configuration de construction</link
> actuellement sélectionnée. Le nom de ce dossier a été établi dans la page de dialogue <link linkend="gettingstarted-compile-setup-config-general"
>Configuration générale</link
>.</para>

<para
>Il s'agit du dossier racine où &kdevelop; trouvera l'exécutable. Il change automatiquement avec la sélection que vous avez effectuée dans le menu <menuchoice
><guimenu
>Projet</guimenu
> <guisubmenu
>Configurations de construction</guisubmenu
></menuchoice
>. Essayez.</para>

<para
>En dehors de toujours lancer l'exécutable construit le plus récemment selon le réglage ci-dessus, ceci permet de changer de programme à exécuter en sélectionnant simplement une autre configuration de construction à partir du menu <guimenu
>Projet</guimenu
>.</para>
</listitem>

<listitem>
<para
>Lancez l'exécutable trouvé dans un dossier personnalisé fixe. Là encore, il s'agit de la racine uniquement à partir de laquelle l'exécutable réel doit être trouvé.</para>

<para
>Utilisez ce paramètre si vous voulez &pex; exécuter le programme réellement installé au lieu de la version située dans les dossiers du projet.</para>
</listitem>
</itemizedlist>
</listitem>

<listitem>
<formalpara>
<title
>Programme</title>
<para
>Ce paramètre indique à &kdevelop; la position relative et le nom du programme qu'il devra réellement appeler. Celle-ci est relative au dossier racine définie dans le groupe de configuration ci-dessus. En outre, vous pouvez définir tout argument que &kdevelop; passera au programme lorsqu'il est effectivement appelé.</para>
</formalpara>

<note>
<para
>Si vous laissez la zone de texte <guilabel
>Programme principal</guilabel
> vide, les réglages de la <emphasis
>cible active</emphasis
> du &automanag; seront utilisés. Bien que ce soit un paramètre réservés aux experts, laisser par inadvertance ce champ d'entrée vierge est une source de problème courante. Vérifiez ce réglage s'il apparaît que &kdevelop; n'appelle pas l'exécutable que vous souhaitiez.</para>
</note>
</listitem>

<listitem>
<formalpara>
<title
>Variables d'environnement</title>
<para
>&kdevelop; configurera un environnement de shell dédié dans lequel exécuter le programme. Définissez toute variable d'environnement supplémentaire dans ce groupe de configuration.</para>
</formalpara>
</listitem>

<listitem>
<formalpara>
<title
>Divers</title>
<para
>Deux cases à cocher supplémentaire sont situées au bas de cette page de dialogue.</para>
</formalpara>

<itemizedlist>
<listitem>
<para
><guilabel
>Compiler automatiquement avant l'exécution</guilabel
> est bien utile la plupart du temps. &kdevelop; examinera le projet pour vérifier les changements et effectuer les étapes de configuration et de construction nécessaires à votre place chaque fois que vous lui demander de lancer le programme.</para>

<para
>Décochez cette case si vous voulez exécuter la version du programme antérieure à la dernière modification.</para>
</listitem>

<listitem>
<para
><guilabel
>Lancer dans un terminal externe</guilabel
> vous intéressera si vous souhaitez tester le comportement des entrées / sorties des programmes non graphiques dans un terminal. Cette case n'étant pas cochée par défaut, &kdevelop; démarre le programme dans une fenêtre qui lui est propre sans les fonctions d'E/S du terminal.</para>
</listitem>
</itemizedlist>
</listitem>
</itemizedlist>
</sect3>
</sect2
> 
</sect1>

<sect1 id="gettingstarted-extend">
<title
>Comment étendre un projet &mdash; le &automanag;</title>

<para
>(- à écrire -)</para>

<sect2 id="gettingstarted-extend-automake">
<title
>Un bref coup d'œil au mécanisme « Automake »</title>

<para
>(- à écrire -)</para>
</sect2
> 

<sect2 id="gettingstarted-extend-pics">
<title
>Comment placer des icônes dans un dossier séparé</title>

<para
>(- à écrire -)</para>
</sect2
> 

<sect2 id="gettingstarted-extend-class">
<title
>Comment ajouter de nouvelles classes</title>

<para
>(- à écrire -)</para>

<caution
><para
>Soyez prudent quand vous sélectionnez les noms de fichiers de vos classes. Il est extrêmement difficile de changer par la suite.</para
></caution>
</sect2
> 

<sect2 id="gettingstarted-extend-subproject">
<title
>Qu'y a-t-il dans un sous-projet ?</title>

<para
>(- à écrire -)</para>

<sect3 id="gettingstarted-extend-subproject-active">
<title
>Concentrez-vous sur votre travail &mdash; la cible active</title>

<para
>(- à écrire -)</para>
</sect3
> 
</sect2
> 

<sect2 id="gettingstarted-extend-restructure">
<title
>Quelques étapes pour restructurer un projet</title>

<para
>(- à écrire -)</para>
</sect2
> 
</sect1>


<sect1 id="gettingstarted-debug">
<title
>Comment déboguer</title>

<para
>(- à écrire -)</para>
</sect1
> 


<sect1 id="gettingstarted-doc">
<title
>Une note sur la documentation de votre projet</title>

<para
>Le projet &kde; utilise <ulink url="http://www.docbook.org/tdg5/en/html/docbook.html"
>docbook</ulink
> pour générer le manuel de votre projet (&cad; le manuel utilisateur). Le manuel utilisateur est disponible via la barre de menus de votre application en cliquant sur <menuchoice
><guimenu
>Aide</guimenu
> <guimenuitem
>Manuel de <replaceable
> votre_application</replaceable
></guimenuitem
></menuchoice
> lorsque votre application graphique &kde; s'exécute. Après avoir construit votre projet, le manuel utilisateur est affiché dans le &centreAide; de &kde;. Il devra expliquer à l'utilisateur comment fonctionne votre application, quelles en sont les principales fonctionnalités et comment la configurer. Il devra également décrire les fonctionnalités avancées s'il y a lieu. </para>
<para
>Dans &kdevelop;, tous les modèles basés sur &kde; comportent un sous-dossier « doc » qui contient un modèle <filename
>index.docbook</filename
> dans le dossier « en » pour vous permettre de commencer à écrire le manuel utilisateur. Vous devrez modifier ce <filename
>index.docbook</filename
> dans &kdevelop; et commencer à changer des détails personnels tels que le nom, l'adresse électronique, &etc;. Observez les commentaires dans ce fichier et essayez de suivre ces indications pour démarrer la documentation de votre application. Reconstruisez votre projet pour voir les changements dans le &centreAide;.</para>
<note
><para
>Vous devez installer votre projet à l'aide de <menuchoice
><guimenu
>Construire</guimenu
> <guimenuitem
>Installer</guimenuitem
></menuchoice
> ou <guimenuitem
>Installer (en tant qu'utilisateur « root »)</guimenuitem
> dans &kdevelop; pour voir le manuel utilisateur dans le &centreAide;.</para
></note>
<para
>Vous pourrez en savoir plus sur la syntaxe docbook sur le <ulink url="http://l10n.kde.org/docs/markup/index.html"
>site web de la documentation de &kde;</ulink
> (en anglais).</para>
</sect1>

<sect1 id="gettingstarted-keys">
<title
>Dernier point mais non des moindres, les raccourcis clavier</title>

<para
>(- à écrire -)</para>
</sect1>

<sect1 id="gettingstarted-whereto">
<title
>Où aller à partir d'ici</title>

<para
>(- à écrire -)</para>

<sect2 id="gettingstarted-whereto-faq">
<title
>Problèmes fréquents</title>

<simplelist>
<member
>Le chapitre « En quelques mots »</member>
<member
>Pages « FAQ »</member>
<member
>Forum</member>
<member
>Listes de diffusion</member>
</simplelist>
</sect2>

<sect2 id="gettingstarted-whereto-projects">
<title
>Travailler avec des projets</title>

<para
>(- à écrire -)</para>

<sect3 id="gettingstarted-whereto-projects-open">
<title
>Utiliser des projets &kdevelop; existants</title>

<para
>(- à écrire -)</para>
</sect3>

<sect3 id="gettingstarted-whereto-projects-import">
<title
>Importer des projets externes</title>

<para
>(- à écrire -)</para>
</sect3>
</sect2>
</sect1>

</chapter>
