Bernd
Pol
Joëlle
Cornavin

    jcornavi@club-internet.fr

Traduction française
Ludovic
Grossard

    grossard@kde.org

Traduction française

# Premiers pas avec &kdevelop; — visite guidée

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

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 :

- Un premier aperçu — les éléments de l'interface utilisateur de l'&EDI; &kdevelop;.
- Un peu de configuration initiale.
- Comment créer un nouveau projet.
- Quelques astuces sur la manipulation des documents.
- Comment compiler l'application dans ce projet.
- Comment ajouter des classes et d'autres détails à votre projet.
- Que faire pour déboguer l'application.
- Quelques outils de base pour construire un programme ou une documentation utilisateur.
- Et pour finir, les raccourcis clavier

Avant de commencer, une notion importante devra être éclaircie.

## Qu'espérer ?

Comme indiqué, &kdevelop; est un environnement de développement intégré. 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.

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.

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 Développement sous &UNIX; et dedans, tout particulièrement au chapitre Intégrer des concepts et des outils.

Les exposés suivants s'appliquent au cas par défaut, où &kdevelop; démarre en mode fenêtre IDEAl simplifié. 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 Configuration Configurer KDevelop... Interface utilisateur.

## Un tout premier coup d'œil à &kdevelop;

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 :

- Qu'y a-t-il en surface ?
- Comment obtenir de l'aide.
- Qu'y a-t-il dans les menus ?
- À quoi servent ces vues des outils ?

### En surface

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

La disposition initiale de &kdevelop;

(En fait, la fenêtre initiale de &kdevelop; sera plus grande mais les éléments que vous voyez sont les mêmes.)

#### Zone d'espace de travail et onglets des vues des outils

Dans ce cas initial, &kdevelop; utilise ce qu'on appelle le mode d'interface utilisateur IDEAl. 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 fenêtre des vues des outils s'ouvre, qui vous permet de travailler sur une tâche précise.

#### Barres de menus et barres d'outils

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.

#### Barre d'état

Enfin, il y a une barre d'état au bas de la fenêtre, affichant de courtes informations sur plusieurs tâches.

### Comment obtenir de l'aide

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

#### Que fait exactement cet élément de menu ?

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.

#### Quel est le nom de cet élément ?

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.

#### Que fait exactement cet élément ?

D'autres informations sont disponibles grâce à l'aide étendue sous forme d'infobulles pour de nombreux éléments de l'&EDI;. Sélectionnez Aide Qu'est-ce que c'est ? ou appuyez sur &Maj;F1 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.

### Qu'y a-t-il dans les menus ?

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.

Ce n'est qu'une vue d'ensemble préliminaire. Pour obtenir une description détaillée, reportez-vous à la référence des commandes.

Fichier

  #### Actions habituelles

  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.

  #### Tout annuler

  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.

Édition

  Ce menu n'est utile que si un document est ouvert.

  #### Actions habituelles

  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.

  #### Recherche et remplacement

  Il y a deux fonctions de recherche très puissantes disponibles, Édition Chercher dans les fichiers... et Édition Chercher / Sélectionner / Remplacer.... 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.

  #### Édition de texte avancée

  Il y a des ressources pour reformater le document en cours et compléter automatiquement les textes saisis partiellement de différentes manières.

Affichage

  Comme le menu Édition, ce menu n'est utile que s'il y a un projet ouvert. Dans ce cas, les actions suivantes seront disponibles (entre autres) :

  #### Historique de navigation

  Avancez et reculez dans les documents, &etc; que vous avez visités.

  #### Suivi des erreurs

  Naviguez jusqu'aux lignes de source des erreurs rencontrées dans le processus de compilation / construction le plus récent.

  #### Actions liées à l'éditeur

  Certains éléments du menu Affichage 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 :

  - Contrôle le comportement du retour à la ligne dans la fenêtre du document.

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

  - Contrôle de l'affichage des sections repliées (cachées temporairement) dans un texte source.

Projet

  Tout le fonctionnement de &kdevelop; est basé sur des projets, 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 :

  #### Ouverture d'un projet

  Permet de créer de nouveaux projets, d'ouvrir des projets existants et d'en importer d'autres environnements.

  #### Options d'un projet

  Permet de définir un ensemble complet des différentes propriétés d'un projet.

  #### Gestion des classes

  Ajoute de nouvelles au projet et traverse l'arbre d'héritage d'une classe.

  #### Distribution du projet

  Aide à construire les paquetages de distribution du projet.

Construire

  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 :

  #### Compiler, lier, exécuter

  Permet de compiler et de lier le projet entier ou des parties de ce dernier, ainsi que de lancer l'application depuis l'&EDI;.

  #### Préparer les opérations de construction

  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 `Makefile.cvs` et `configure` propres. Il y a aussi des dispositions pour supprimer les fichiers traduits du projets à diverses stades d'intensité.

  #### Installer l'application

  Permet d'installer l'application à la fois dans les dossiers locaux et dans les dossiers système accessibles uniquement à l'utilisateur « root ».

  #### Documentation de l'API

  Construit ou supprime une documentation d'API basée sur « doxygen », comme défini dans les options du projet.

Déboguer

  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 Projet Options du projet). Les actions suivantes sont disponibles dans ce cas :

  #### Actions habituelles du débogueur

  La première section dans le menu Déboguer 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.

  #### Points d'arrêt

  &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 menuBasculer le point d'arrêt.

  #### Débogage avancé

  D'autres éléments du menu Déboguer permettent une analyse plus sophistiquée du programme. Appuyez sur &Maj;F1 pour obtenir plus d'informations sur leur objectif.

Scripts

  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.

Fenêtre

  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.

  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.

Outils

  &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 Outils reflète la majeure partie de cette configuration.

  #### Édition avancée

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

  #### Gestion côté web

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

  #### Autres outils

  D'habitude il existe un groupe d'autres éléments, selon les outils disponibles actuellement. Appuyez sur &Maj; F1 pour obtenir plus d'informations sur leurs objectifs.

Configuration

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

Aide

  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.

### À quoi servent ces outils ?

Dans le mode d'interface utilisateur IDEAl, l'espace de travail sera entourée de trois zones de boutons, ce qu'on appelle les onglets des vues d'outils. Ils fournissent l'accès aux fenêtres de vues d'outils 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.

- #### Côté gauche

  Fournit un accès aux outils de navigation et de sélection.

- #### Bas

  Ces vues affichent les messages produits par divers outils.

- #### Côté droit

  Fournit un accès à la documentation et aux outils de gestion des sources.

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 outils modules externes actuellement disponibles pour &kdevelop;. Vous en saurez plus sur ce sujet dans le chapitre Configuring KDevelop.

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.

Navigation et sélection

  #### Sélecteur de fichiers

  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.

  #### Liste des fichiers

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

Affichages des messages

  #### Application

  Affiche la sortie d'une application démarrée depuis &kdevelop;.

  #### Diff

  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 Outils Afficheur de différences....

  #### Messages

  Affiche les messages produits oar les outils construits depuis &kdevelop;, habituellement à partir du menu Construire.

  #### Chercher dans les fichiers

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

  #### Remplacer

  Liste les résultats de l'opération de rechercher-et-remplacer globale émis à partir du menu Édition Rechercher / Sélectionner / Remplacer.... Dans cette vue, vous pouvez décider sur chaque élément trouvé si vous souhaitez réellement qu'il soit remplacé ou non.

  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 Édition Chercher / Sélectionner / Remplacer... sera en fait désactivé.

  #### Konsole

  Ouvre une Konsole &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.

Documentation et manipulation des sources

  #### Documentation

  &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;.

  Consultez les chapitres Documentation et Configurer la documentation pour plus de détails.

  #### Fragments de code

  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.

  D'autres informations à ce sujet sont disponibles dans les chapitres Fragments de code et Configuration de l'outil « Fragments de code ».

## Un peu de configuration

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.

Si vous voulez en savoir plus sur la configuration de &kdevelop;, jetez un coup d'œil au chapitre Configuration de KDevelop.

### Quelques réglages généraux

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

La boîte de dialogue de configuration générale de &kdevelop;

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

#### Dossier par défaut des projets

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 Ouvrir le sélecteur de fichiers portant une icône de dossier à sa droite.

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

&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 `/home/devel/projects/bonjour`.

Vous pouvez naturellement annuler les réglages de ce dossier si nécessaire. Consultez le chapitre &appwizard; pour plus d'informations à ce sujet.

#### Sortie du compilateur

Chaque fois que &kdevelop; compile un source quelconque, il affiche les messages des outils de construction make, etc, dans la fenêtre Messages 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.

Selon la version de &kdevelop; que vous utilisez, la sélection Sortie du compilateurt 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.

Soyez conscient que seules les informations les plus élémentaires seront affichées dans la fenêtre Messages 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 Messages et sélectionnez par exemple « Sortie du compilateur longue » à partir du menu qui apparaît.

### Initialisation des index de recherche de documentation

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

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

Où générer les index de recherche.

Cliquez maintenant sur le bouton Mettre à jour la configuration 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 OK pour la faire disparaître.

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 Mettre à jour l'index à droite. Maintenant, la boîte de dialogue Générer l'index de recherche s'ouvre, affichant la progression des opérations de construction de l'index.

&kdevelop; génère les index de recherche de documentation.

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

- Cela fermera en principe la boîte de dialogue. Dans certains cas, il se peut que l'application htdig que &kdevelop; utilise pour effectuer ses recherches de texte ne soit pas correctement installée. Consultez le chapitre Configuration des recherches de texte pour obtenir de l'aide dans ce cas.

- Pour être en mesure de consulter la documentation de l'API propre à &kde; et à &Qt;, il est obligatoire que les KDELibs Apidocs soient présentes lorsque est installé. Si vous rencontrez des problèmes en construisant les indexe ou que vous exécutez les exemples de consultation par identifiants plus loin dans ce chapitre, assurez-vous que cette documentation existe et est accessible à &kdevelop;. Reportez-vous à Installation de KDevelop pour plus de détails.

## Démarrer un nouveau projet

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 projets. Ainsi, la première étape pratique pour développer des logiciels dans &kdevelop; consiste habituellement à créer un nouveau projet.

Heureusement, cela ne pose pas de problème. &kdevelop; fournit ce qu'on appelle l'outil &appwizard; pour ce faire. (consultez le chapitre Premiers pas — l'&appwizard; pour en savoir plus.)

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 :

- Comment créer un nouveau projet avec l'aide de l'&appwizard;.
- Quels sont les fichiers que l'&appwizard; a configuré initialement.
- Qu'en est-il de la vue des outils additionnels affichés avec le projet ?

### Comment créer un nouveau projet

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

1. Pour démarrer l'&appwizard; cliquez sur le menu Projet Nouveau projet....

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

   1. Nous voulons construire un application &kde; en C++ comme d'habitude, donc cliquez sur l'étiquette + à gauche de l'étiquette C++ pour ouvrir cette branche.

   2. 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 + à côté de KDE.

   3. S'affiche alors à une série de modèles de projets. Naviguez jusqu'à la fin de cette branche et cliquez sur Application KDE simple.

      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.

      Sélection d'un modèle de projet « Hello World »

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

      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.

   5. Assurez-vous que la zone de texte Emplacement sous le champ d'entrée affiche le dossier de plus haut de votre projet comme configuré dans le chapitre Un peu de configuration 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.

      Si tout s'est bien passé, la ligne Emplacement cible 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 Emplacement existe bien et qu'il est modifiable.

   6. Une fois que tout est correct, le bouton Suivant sur la ligne du bas de la boîte de dialogue est activé. Cliquez sur ce dernier pour continuer.

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

   Saisissez votre nom et (éventuellement) votre adresse électronique.

   Vous devez fournir un nom d'auteur au moins. C'est obligatoire pour la configuration des fichiers de l'application.

   Si tout est correct, le bouton Suivant est activé. Cliquez sur ce dernier pour continuer.

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

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

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

### Fichiers initiaux du projet

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 Arborescence des fichiers sur la partie inférieure gauche. S'ouvre une liste de fichiers similaire à celle ci-dessous.

Fichiers initiaux dans notre projet « Bonjour tout le monde »

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 Arborescence des fichiers située à gauche. Cliquez simplement sur les noms des branches dans l'arborescence pour constater par vous-même.

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

#### Aspects liés aux droits d'auteur

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 fichiers sources individuels et le niveau d'application exécutable (run-time application). L'&appwizard; a déjà placé les informations relatives aux droits d'auteur et à la licence dans les fichiers de projet.

##### Droits d'auteur au niveau des fichiers sources

Vous rappelez-vous de la boîte de dialogue Options du projet 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 bonjour.cpp 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éé.

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

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

##### Droits d'auteurs relatifs à l'exécution de l'application

Une fois que votre application &kde; tourne, l'utilisateur peut afficher certaines données À propos, habituellement à partir du menu Aide. L'&appwizard; a également veillé à cet aspect. Si vous jetez un coup d'œil au fichier `main.cpp`, vous trouverez un élément similaires à celui ci-dessous.

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

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 À propos et liste ses nom et adresse sur la page Auteurs également.

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é open souce en faisant cela..

#### Fichiers sources initiaux

L'&appwizard; a placé les fichiers sources dans le sous-dossier `src` du dossier du projet. Vous y trouverez les fichiers `main.cpp`, `bonjour.h` et `bonjour.cpp` comme vous vous y attendiez certainement.

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

- `bonjour.desktop` contient des métadonnées utilisées par &kdevelop; pour maintenir et démarrer l'application.

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

- Pour finir, `bonjourui.rc` contient une description de l'interface utilisateur de l'application, actuellement les menus que fournira l'application.

#### Documentation intiale de l'application

Dans le sous-dossier `doc/en` du projet, vous trouverez le fichier `index.docbook`. C'est un modèle par défaut à partir duquel vous pouvez commencer à écrire une documentation utilisateur appropriée

#### Fichiers du projet et auxiliaires

Vous aurez noté que les fichiers que nous avons introduits jusqu'ici sont listés en gras dans la vue des outils Arborescence des fichiers, 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 fichiers de projet.

Si vous jetez un coup d'œil à la fenêtre Gestionnaire « Automake » 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.

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

- ##### Contrôle de construction d'un projet

  Ces fichiers contrôlent les processus de compilation, d'installation, de construction de la documentation, &etc;. Si le projet emploie le mécanisme autotools de &GNU; comme le fait notre exemple, vous trouverez un fichier `Makefile.am` 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 `configure` pendant les étapes de construction. Un tel processus de construction produit un `Makefile` final dans chaque dossier. Et, à partir de là, à son tour l'utilitaire make construira enfin les exécutables (binaires) de l'application.

  Ces fichiers `Makefile.am` 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 `Makefile.am`.

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

- ##### Fichiers de contrôle de &kdevelop;

  &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 `bonjour.kdevelop`, `bonjour.kdevelop.pcs` et `bonjour.kdevses`.

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

  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.

- ##### Fichiers de description de projet GNU

  Certains fichiers dans le dossier racine du projet sont obligatoires dans toute application se conformant à &GNU;. Ce sont : `AUTHORS`, `ChangeLog`, `INSTALL`, `COPYING` (qui contient la GNU GENERAL PUBLIC LICENSE), `INSTALL`, `NEWS`, `README` et `TODO`.

- ##### Autres fichiers

  Quelques fichiers supplémentaires, non encore mentionnés, sont :

  - `Doxyfile` contrôle la création de la documentation de l'interface de programmation interne de l'&API; propre au projet.

  - Le dossier `templates` 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.

    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 `cpp` et `h`, les fichiers créés à partir de ces modèles sembleront moins incongrus.

  - Le dossier `po` servira à des fins de localisation. Il fait essentiellement partie des fichiers de projet (contient un `Makefile.am`) 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.

  - Enfin, le dossier `admin` 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;.

### Vues des outils supplémentaires

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.

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 Outils modules externes pour connaître les instructions.

#### Outils de navigation et de sélection (côté gauche)

- ##### Signets

  Vous pouvez marquer une ligne de fichier texte afin de revenir rapidement à sa position depuis n'importe où. &kdevelop; mémorisera tous ces signets, même si vous fermez la fenêtre d'édition après. La vue des outils Signets 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.

- ##### Classes

  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.

- ##### Groupes de fichiers

  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.

- ##### Variables

  Utilisé par l'outil de débogage pour afficher, évaluer et surveiller les variables pendant les exécutions.

#### Messages (en bas)

- ##### Valgrind

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

- ##### Problèmes de sécurité

  Il existe un outil de module externe Contrôleur de sécurité 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.

- ##### Points d'arrêt

  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.

- ##### CTags

  Permet de créer une base de données ou des index d'identifiants utilisant l'application CTags 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.

- ##### Problèmes

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

#### Gestion des sources (côté droit)

- ##### Gestionnaire Automake

  L'outil &automanag; est essentiellement une interface graphique pour maintenir le contenu des fichiers `Makefile.am` 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 fichiers de projet. Chaque sous-dossier de ce type doit contenir un fichier `Makefile.am` est nommé un sous-projet dans le contexte du &automanag;.

  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é `Makefile.am` dans ce sous-projet.

  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 ci-dessous. Consultez le chapitre Construction et gestion de projets pour une description plus exhaustive.

## Quelques astuces pour travailler avec des documents

Dans notre exemple de projet, comme l'&appwizard; a laissé le fichier `bonjour.cpp` 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 :

- Comment basculer facilement entre les fichiers d'en-tête et d'implémentation.
- Comment accéder facilement aux déclarations et aux définitions.
- Comment adapter les fenêtres d'édition à vos besoins actuels.
- Comment garder un œil sur les problèmes courants.

### Basculer entre les fichiers d'en-tête et d'implémentation

&kdevelop; fournit un moyen rapide et facile de passer d'un fichier d'implémentation donné (`.cpp`) à un fichier d'en-tête correspondant (`.h`) 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.

Comment basculer entre les fichiers d'implémentation et d'en-tête.

Cherchez l'élément Basculer entre les fichiers d'en-tête et les fichiers d'implémentation 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 `bonjour.cpp`, le fichier `bonjour.h` sera affiché et le curseur affiché ici.

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.

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.

### Comment accéder aux déclarations et aux définitions

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.

Deux cas différents sont à prendre en compte, à savoir :

- Accéder aux identifiant s définis extérieurement et
- traiter les éléments de texte internes du projet.

#### Déclarations et définitions externes

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.

Examinons un exemple. Dans la fenêtre d'édition `bonjour.cpp`, cherchez les lignes suivantes.

    Bonjour::Bonjour()
        : KMainWindow( 0, "Bonjour" )
    {

Cliquez avec le &BDS; sur `KMainWindow`. Un menu apparaît. Sélectionnez dedans l'élément Chercher dans la documentation : KMainWindow et relâchez le bouton de la souris. Maintenant, la vue des outils Documentation est ouverte, affichant l'élément `KMainWindow` en tant qu'élément de recherche sur la sous-page Chercher. 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 `KMainWindow`.

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

Comment consulter un identifiant documenté extérieurement.

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

Si cela ne fonctionne pas, il n'y a probablement pas encore de d'index de documents. Avez-vous initialisé les index comme illustré ci-dessus ? Dans le cas contraire, faites-le puis revenez en arrière et réessayez.

#### Déclarations et définitions internes du projet

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 CTags pour rechercher les sources dans votre projet.

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 CTags au bas de la zone d'espace de travail.

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

Construire un index CTags avec le bouton Régénérer.

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

La date située à côté du bouton Régénérer 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.

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

- ##### Utiliser la vue des outils CTags

  C'est le plus simple. Commencez simplement par saisir un nom d'identifiant qui vous intéresse dans le champ d'entrée Consultation par identifiant 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.

  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 Consultation par identifiant. &kdevelop; se met immédiatement au travail et vous présente un résultat comme celui-ci :

  Comment effectuer une consultation par identifiant dans la vue des outils CTags.

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

- ##### Utiliser un menu contextuel dans un fichier source

  Cette fonction est pratique lorsque vous travaillez sur un certain fichier source. Supposons que vous examiniez le fichier `main.cpp` de notre exemple de projet « Bonjour ». Vous y trouvez la ligne suivante

      Bonjour *mainWin = 0;

  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.

  Obtention des informations CTags sur un identifiant interne d'un projet.

  Cliquez sur celle qui vous intéresse, par exemple CTags - Aller à la définition : Bonjour, et &kdevelop; ouvre immédiatement la fenêtre d'édition `bonjour.cpp` et positionne le curseur juste devant cette définition de classe :

      Bonjour::Bonjour()
          : KMainWindow( 0, "Bonjour" )
      {

- ##### Faire une recherche globale

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

  - Démarrer une recherche globale à partir du menu Édition Chercher dans les fichiers.... Ou

  - Utiliser directement le menu contextuel à l'aide d'un clic droit de la souris dans la fenêtre d'édition.

  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 `bonjour.cpp` 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;.

  À 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 Grep : Bonjour.

  Lancement d'une recherche globale depuis une fenêtre d'édition.

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

  Une interface polyvalente pour effectuer des recherches globales dans le projet.

  Comme vous le constatez, c'est un outil très souple pour lancer des recherches avec find et grep 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 Motif. Dans le cas contraire, il suffit de le saisir puis de cliquer sur le bouton Chercher en bas à droite.

  Maintenant la vue des outils Chercher dans les fichiers 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.

  Il y a deux lignes particulièrement intéressantes dans la fenêtre de vue des outils.

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

  - 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 *** ».

  &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 Chercher dans les fichiers.

### Agencement des fenêtres d'édition

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.

- Comme supprimer les onglets non nécessaires.
- Comment réorganiser les onglets.
- Comment visualiser plusieurs fichiers simultanément dans la zone d'espace de travail.
- Comment modifier des fichiers sources et d'en-tête C++ simultanément
- Comment grouper les fichiers sources en sessions de développement.

#### Nettoyage de la rangée des onglets

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.

##### Fermer plusieurs onglets à la fois

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 Fenêtre ou cliquer avec le &BDS; sur un onglet pour soit

- fermer la fenêtre d'édition actuellement sélectionnée,

- fermer toutes les fenêtres d'édition ouvertes, soit

- fermer toutes les fenêtres d'édition ouvertes (disponibles depuis le menu Fenêtre uniquement).

##### Fermer les ensembles sélectionnés d'onglets

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.

Illustrons ce comportement dans un exemple simple. Dans notre exemple de projet « Bonjour », supposons qu'il y a avait plusieurs fichiers ouverts pour modification : `bonjour.cpp`, `bonjour.h`, `bonjour.rc`, `bonjour.desktop` et `main.cpp`. Maintenant, vous souhaitez les fermer tous, sauf `bonjour.cpp` et `bonjour.h`. Le moyen le plus facile de le faire consiste à utiliser la vue des outils Liste des fichiers. 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 :

1. Ouvrez le menu Liste des fichiers et, en maintenant enfoncée la touche Ctrl, cliquez sur les fichiers que vous voulez voir fermés dans la liste.

2. Ensuite, en laissant le pointeur de la souris sur un nom de fichier dans la liste, cliquez avec le &BDS;.

3. Depuis le menu Liste des fichiers qui apparaît, sélectionnez Fermer la sélection.

Comment fermer les fenêtres d'édition sélectionnées en une étape.

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.

#### Comment réorganiser les onglets des fenêtres d'édition

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 :

##### Installation de base — Où positionner les nouveaux onglets

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.

Vous devez changer un paramètre d'interface utilisateur de base dans &kdevelop; pour activer ce comportement.

1. Sélectionnez Configuration Configurer KDevelop...

2. Dans la barre d'icônes à gauche sur la page de dialogue qui apparaît, cliquez sur l'icône Interface utilisateur. La page de dialogueInterface utilisateur s'affiche maintenant.

3. Dans le coin inférieur gauche, se trouve la section étiquetée Navigation par onglets. Supprimer la coche sur la ligne Ouvrir les nouveaux onglets après l'onglet actuel.

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

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

##### Comment réorganiser les onglets

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.

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.

#### Visualiser plusieurs fichiers simultanément

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.

Il y a deux commandes de division que vous pouvez atteindre l'une et l'autre via le menu Fenêtre 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 ».

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

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

Comment scinder la zone d'espace de travail actuelle en deux parties.

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

L'espace de travail a été divisé horizontalement.

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.

Il y a plusieurs points à noter.

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

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

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

#### Modifier des fichiers sources et d'en-tête C++ simultanément

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 `.cpp` et son fichier `.h` 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.

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

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

Faire s'afficher les fichiers sources et d'en-tête C++ côte à côte.

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

Pour illustrer cette fonctionnalités, fermons maintenant dans notre exemple de projet à la fois les fenêtres d'édition `bonjour.cpp` et `bonjour.h`, si nécessaire. Sélectionnez ensuite `bonjour.cpp` à nouveau à partir du sous-dossier `src` du projet. La fenêtre d'édition s'ouvrira comme d'habitude. Mais si vous ouvrez à présent le `bonjour.h` 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 `bonjour.cpp`

Il y a même plus, comme nous l'avons déjà mentionné. Dans l'éditeur `bonjour.cpp`, cherchez &pex; cette ligne de la définition du constructeur :

    Bonjour::Bonjour()

et placez le curseur dessus. Puis observez la fenêtre `bonjour.h` au-dessous et notez comment &kdevelop; a navigué vers la ligne de déclaration du constructeur par défaut.

&kdevelop; a navigué automatiquement vers la déclaration du constructeur.

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

#### Grouper des fichiers sources en sessions de développement

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 Liste des fichiers de &kdevelop; vous permet simplement de le faire.

En haut de la fenêtre de vue des outils Liste des fichiers, 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 Affichage Affichage des sessions.

Nous illustrerons cette fonction à nouveau avec notre exemple de projet « Bonjour ». Supposons que vous souhaitiez toujours ouvrir les fichiers `bonjour.cpp`, `bonjour.h` et `main.cpp` 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 ».

Utiliser les sessions de développement pour mémoriser des groupes de fichiers.

C'est une approche à étapes multiples comme suit.

1. Créer une nouvelle session

   1. Cliquez sur l'icône Nouvelle session en haut à gauche dans la fenêtre de vue des outils Liste des fichiers.

   2. Une boîte de dialogue apparaît. Dans le champ d'entrée Saisissez le nom de la session, donnez à votre nouvelle session un nom, &pex; « sources ».

   3. Fermez la boîte de dialogue avec OK. La nouvelle session sera maintenant listée dans la zone de liste déroulante située sur la barre d'outils.

2. Cette nouvelle session sera initialement vide. Vous devez la peupler avec les fichiers que que vous voulez garder ici.

   1. 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 `bonjour.cpp`, `bonjour.h` et `main.cpp` comme prévu.

   2. Une fois que votre fichier est complet, cliquez sur l'icône Enregistrer la session dans la barre d'outils. Ne sautez pas cette étape, &kdevelop; oubliera la liste des fichiers sinon.

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

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 Enregistrer la session. 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 Supprimer la session à droite de la barre d'outils.

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 Projects Options du projet Liste des fichiers.

Laissons le soin à &kdevelop; d'ouvrir une session spécifique lorsque le projet est chargé.

### Garder un œil sur les problèmes courants

Lorsque vous ouvrez une fenêtre d'édition contenant un fichier source, &kdevelop; analyse la syntaxe de son contenu. Cette fonction permet au rapporteur de problèmes 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

Illustrons cette fonction avec notre exemple de projet « Bonjour ».

- Ouvre une fenêtre d'édition avec le fichier source `main.cpp`.

- Assurez-vous qu'il contienne toujours la ligne suivante quelque part vers la fin :

      /// @todo do something with the command line args here

  Celle-ci a été insérée par l'&appwizard; lorsque vous avez créé le projet « Bonjour » dans le chapitre Démarrer un nouveau projet ci-dessus.

- Ouvrez à présent la vue des outils Problèmes dans la rangée des onglets en bas. Si tout s'est bien passé, il affiche actuellement ce « À faire » :

  &kdevelop; attire l'attention sur une ligne de code source contenant une marque « À faire ».

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

Si vous insérez &pex; les lignes de commentaires `TODO` et `FIXME` suivantes dans notre exemple de fichier `bonjour.cpp`

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

vous les trouverez listés dans la vue des outils Problèmes également :

Le rapporteur de problèmes listant les lignes qui requièrent de l'attention dans le fichier en cours d'édition.

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

Le rapporteur de problèmes a collecté les alertes `TODO`.

L'onglet Erreurs 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.

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 Problèmes régulièrement dans le processus de développement.

## Comment compiler un projet

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

Construire un projet requiert plusieurs étapes.

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 Construire le projet, 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.

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 :

- D'étudier brièvement le cyle de construction de base.
- D'étudier certains moyens pour configurer un projet.

### Le cycle de construction de base

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.

- Comment initialiser le projet pour une première construction.
- Comment effectuer la configuration initiale.
- Comment construire le projet.
- Comment lancer l'application depuis &kdevelop;.

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 QMake 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à.

#### Initilaiser le projet pour la construction

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 Construire Construire le projet ou en appyant sur la touche de fonction F8, vous obtiendrez la mise en garde suivante.

Essayer de construire un projet basé sur « automake » brut.

Vous pouvez cliquer sur le bouton Les exécuter, 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 Ne pas exécuter.

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

Lancer l'exécution de l'initialisation de base.

&kdevelop; va maintenant ouvrir la fenêtre de la vue des outils Messages 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 `*** Success ***`.

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

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

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 autoconf et automake utilisées pour cette initialisation. Et finalement, il a conseillé l'outil « make » (gmake de &GNU; dans ce cas) pour traiter le fichier « make » `Makefile.cvs`.

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 `configure` nécessaire pour exécuter la prochaine étape de configuration.

#### Configuration initiale de « Bonjour »

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.

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 `configure` nécessaires seront disponibles. Ceci fait, sélectionnez l'élément de menu Construire Exécuter le script « configure » pour lancer une séquence de configuration.

&kdevelop; a ouvert la fenêtre de la vue des outils Messages à 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 « `Good - your configure finished. Start make now` » (qui seront émis par « configure ») suivis du message « `*** Success ***` » de &kdevelop;.

Au début de la fenêtre Messages, vous trouverez à nouveau la ligne de commande que &kdevelop; a employé pour lancer l'exécution de cette configuration :

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

Vous pouvez indiquer plusieurs détails intéressants à partir de ces commandes.

- 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 `debug` (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 `configure` et, en outre, un `Makefile` dans chaque sous-dossier.

- Dans la section Configurer le projet 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 `debug` — si nécessaire — avant l'appel de « configure » et que le script `configure` a créé la sous-structure et tous les `Makefiles` dedans.

- Ensuite, depuis le dossier de construction `debug`, &kdevelop; a appelé le script `configure` dans le dosser racine de notre projet en utilisant un environnement dédié, où les drapeaux `CXXFLAGS="-O0 -g3"` 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.

- Pour finir, le script `configure` a été appelé avec l'option `--enable-debug=full` qui lui donne pour instruction de créer chaque `Makefile` pour que la compilation et la liaison ultérieures aient toutes les informations de débogage nécessaires intégrées et utilisables.

Tous ces réglages sont configurables pour chaque projet. Vous en saurez plus à ce sujet dans le chapitre Gestions de projets.

#### Construire le projet

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

Commandes de &kdevelop; pour construire des binaires (exécutables).

De bas en haut, ce sont :

- Compiler le fichier — 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.

- Construire la cible active — Cette option est principalement utilisée en liaison avec le Gestionnaire « automake » que nous verrons brièvement ci-dessous.

- Construire le projet — 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.

Il pourrait être intéressant d'observer ce qui se passe dans le dossier `Déboguer` créé lors du lancement précédent de `configure`. Donc gardez-le ouvert avec tous les sous-dossiers dépliés exactement comme représenté ci-dessus. Puis sélectionnez Construire Construire le projet (ou appuyez sur la touche F8) pour lancer la séquence de construction. Comme précédemment, la fenêtre de la vue des outils Messages 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 `Déboguer`.

Comme il n'y a pas beaucoup de fichiers sources dans n otre exemple de projet « Bonjour », la fenêtre Messages 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.

    cd '/home/devel/projects/bonjour/debug' && \
    WANT_AUTOCONF_2_5="1" WANT_AUTOMAKE_1_6="1" gmake -k

Sans grande surprise, &kdevelop; a basculé vers la racine du sous-arbre `Déboguer` afin d'exécuter le `Makefile` situé ici. Un sous-environnement dédié a été configuré à nouveau comme avant dans l'étape d'initialisation dans laquelle ensuite l'outil gmake a été appelé.

Notez que l'option `-k` dans l'appel gmake. 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 Messages. S'il y en a, utilisez les avantages d'un &EDI;: Cliquez juste sur le message d'erreur dans la fenêtre Messages et &kdevelop; vous amènera exactement à la position où l'erreur s'est produite dans le fichier source.

Et que s'est-il passé à l'intérieur du sous-arbre `Déboguer` ? Pas grand chose. Quelques lignes se sont affichées sur les branches `doc/en` et `src`, plus particulièrement le fichier `bonjour` dans `/home/devel/projects/bonjour/debug/src/`. 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 `bonjour`.

#### Exécuter l'application

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

Exécuter une application à partir de la barre d'outils de construction.

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 Application en bas. Ici; la commande &kdevelop; émise pour exécuter le programme sera affichée sur la ligne du haut :

    ./bonjour

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 Gestion des projets.

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

Notre application Bonjour initiale.

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

### Configurer le projet

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.

- Quelle est l'utilité des configurations de construction ?
- Où définir le comportement du script `configure`.
- Quelques considérations sur la manière dont make devra s'exécuter.
- Où devra être l'exécutable et comment devra-t-il être appelé ?

#### Configurations de construction

Lorsque nous avons lancé une première exécution du script `configure` dans la section Configuration initiale de « Bonjour » ci-dessus, nous avons noté que &kdevelop; a configuré un sous-dossier `debug` dédié dans ce but. Dans cette section, nous verrons brièvement certaines conséquences de cette fonctionnalité.

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.

Pour découvrie quelles sont les configurations de construction disponibles, jetez un coup d'œil au menu Projet Configuration de la construction.

Il existe diverses configurations de construction disponibles pour ce projet.

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 — initialement — y avoir uniquement une seule configuration de construction de ce type, à savoir par défaut.

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.

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

débogage

  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 `debug` 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 `configure` se verra attribuer l'option `--enable-debug=full` et le `CXXFLAGS="-O0 -g3"` 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.

optimisée

  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 `optimisée` dédié. Aucun argument spécifique au script `configure` ne sera présélectionné, néanmoins le `CXXFLAGS="-O2 -g0"` 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.

par défaut

  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 configure et make/gmake de &GNU;. Aucun autre dossier de construction dédié que débogage ou optimisée 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.).

  Réfléchissez bien avant de vous décider à utiliser l'environnement de construction par défaut !

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

À 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 — 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.

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.

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 débogage vers optimisée, 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 débogage et continuez immédiatement votre travail à cet endroit.

Une dernière remarque — 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.

#### Options de configuration d'un projet

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 `configure` et/ou les réglages des drapeaux spécifiques dans l'environnement avant d'exécuter `configure` comme &pex; le `CXXFLAGS` dans nos exposés précédents.

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

La plupart des options de « configure » peuvent être définies ici.

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 Configurer des projets. Si vous voulez en savoir plus sur la signification des divers drapeaux qui peuvent être définis, consultez `info make` depuis la console (ou `info:make` depuis &konqueror;) et là, la section Implicit Rules Implicit Variables.

Il y a plusieurs fenêtres de configuration de boîtes de dialogue à onglets dont la première, Général 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.

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

Sélectionnez la configuration de construction dont les les paramètres sont à définir.

À 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 Arguments du script « configure » et Dossier de construction changent en fonction des paramètres que nous avons mentionnés dans la liste des confogurations de construction ci-dessus.

##### Paramètres généraux de de la configuration

Sur la page de dialogue Général, on peut définir ces options de configuration :

- ###### Arguments du script « configure »

  Ce sont les options que &kdevelop; affecte à l'appel du script `configure` dans le processus de construction. Voir l'exemple dans la section « Configuration initiale de « Bonjour » » ci-dessus.

- ###### Dossier de construction

  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.

- ###### Dossier racine des sources

  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.

- ###### Drapeaux du préprocesseur C/C++ (CPPFLAGS)

  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'exemple dans la section « Configuration initiale de « Bonjour » » ci-dessus pour savoir comment faire.

- ###### Drapeaux de l'éditeur de liens (LDFLAGS)

  Ce sont des informations supplémentaires pour l'outil d'édition de liens ld où il devra rechercher les bibliothèques additionnelles. Il est utilisé pour construire l'environnement de construction temporaire également.

- ###### Variables d'environnement

  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.

##### Paramètres propres au compilateur

Les autres onglets sur la page de dialogue Options du script « configure » 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 C++.

Sélectionnez le compilateur et l'environnement de travail que &kdevelop; utilisera ici.

Voici ce que vous pouvez configurer à partir d'ici :

- ###### Compilateur C++

  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.

- ###### Commande système du compilateur (CXX)

  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.

- ###### Drapeaux du compilateur (CXXFLAGS)

  Ici vous pouvez saisir n'importe quelle option supplémentaire que &kdevelop; passera (via le `Makefile`) 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 Configuration.

  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 ... à droite de la zone de texte.

  Utilisez cette boîte de dialogue pour définir le comportement du compilateur C++ de &GNU;.

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

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

#### Comment « make » devra construire le programme

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

Définissez comment &kdevelop; appellera l'outil make.

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 Arrêter dès la première erreur. Vous le trouverez désactivé dans la majorité des projets. Ce comportement correspond à l'option `-k` dans l'appel de gmake que nous avons trouvé dans la construction initiale de notre exemple de projet « Bonjour ».

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 Messages. Cliquez sur Affichage Erreur suivante et Affichage Erreur précédente ou appuyez respectivement sur les touches F4 et Maj F4 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.

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

#### Comment lancer l'exécutable

Une fois que la construction est achevée, vous pouvez facilement lancer l'application depuis &kdevelop;. Utilisez soit Construire Exécuter le programme, les touches Maj F9, soit le bouton Exécuter le programme dans la barre d'outils de construction de &kdevelop;.

Exécutez le programme à partir d'ici.

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 ?

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

Définissez où et comment votre programme devra être exécuté.

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.

- ##### Dossier

  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.

  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.

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

  - Lancez à partir du dossier de construction en fonction de la configuration de construction actuellement sélectionnée. Le nom de ce dossier a été établi dans la page de dialogue Configuration générale.

    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 Projet Configurations de construction. Essayez.

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

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

    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.

- ##### Programme

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

  Si vous laissez la zone de texte Programme principal vide, les réglages de la cible active 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.

- ##### Variables d'environnement

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

- ##### Divers

  Deux cases à cocher supplémentaire sont situées au bas de cette page de dialogue.

  - Compiler automatiquement avant l'exécution 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.

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

  - Lancer dans un terminal externe 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.

## Comment étendre un projet — le &automanag;

(- à écrire -)

### Un bref coup d'œil au mécanisme « Automake »

(- à écrire -)

### Comment placer des icônes dans un dossier séparé

(- à écrire -)

### Comment ajouter de nouvelles classes

(- à écrire -)

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

### Qu'y a-t-il dans un sous-projet ?

(- à écrire -)

#### Concentrez-vous sur votre travail — la cible active

(- à écrire -)

### Quelques étapes pour restructurer un projet

(- à écrire -)

## Comment déboguer

(- à écrire -)

## Une note sur la documentation de votre projet

Le projet &kde; utilise docbook 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 Aide Manuel de votre_application 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.

Dans &kdevelop;, tous les modèles basés sur &kde; comportent un sous-dossier « doc » qui contient un modèle `index.docbook` dans le dossier « en » pour vous permettre de commencer à écrire le manuel utilisateur. Vous devrez modifier ce `index.docbook` 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;.

Vous devez installer votre projet à l'aide de Construire Installer ou Installer (en tant qu'utilisateur « root ») dans &kdevelop; pour voir le manuel utilisateur dans le &centreAide;.

Vous pourrez en savoir plus sur la syntaxe docbook sur le site web de la documentation de &kde; (en anglais).

## Dernier point mais non des moindres, les raccourcis clavier

(- à écrire -)

## Où aller à partir d'ici

(- à écrire -)

### Problèmes fréquents

- Le chapitre « En quelques mots »
- Pages « FAQ »
- Forum
- Listes de diffusion

### Travailler avec des projets

(- à écrire -)

#### Utiliser des projets &kdevelop; existants

(- à écrire -)

#### Importer des projets externes

(- à écrire -)