Intro Cpp Builder Borland[1]

Prise en main

Borland®

C++Builder™ 6pour Windows™

Reportez-vous au fichier DEPLOY.TXT situé dans le répertoire racine de votre produit C++Builder 6 pour obtenir la liste complète des fichiers que vous pouvez distribuer en accord avec les termes du contrat de licence de C++Builder.

Les applications mentionnées dans ce manuel sont brevetées ou en attente de brevet. Ce document ne donne aucun droit sur ces brevets. Reportez-vous au CD du produit ou à la boîte de dialogue A propos.

COPYRIGHT © 1983, 2002 Borland Software Corporation. Tous droits réservés. Tous les produits Borland sont des marques commerciales ou des marques déposées de Borland Software Corporation aux Etats-Unis ou dans les autres pays. Toutes les autres marques sont la propriété de leurs fabricants respectifs.

CPE1360WW21000 6E2R01020203040506-9 8 7 6 5 4 3 2 1PDF

i

Chapitre 1Introduction 1-1Qu’est-ce que C++Builder ? . . . . . . . . . . . 1-1Enregistrement de C++Builder. . . . . . . . . . 1-2Où trouver des informations ? . . . . . . . . . . 1-3

Aide en ligne . . . . . . . . . . . . . . . . . . 1-4Aide F1 . . . . . . . . . . . . . . . . . . . . . 1-4

Documentation imprimée . . . . . . . . . . . . 1-6Services de support développeur . . . . . . . . 1-6Conventions typographiques. . . . . . . . . . . 1-6

Chapitre 2Parcours rapide

de l’environnement 2-1Démarrage de C++Builder . . . . . . . . . . . . 2-1L’EDI . . . . . . . . . . . . . . . . . . . . . . . . 2-1Menus et barres d’outils . . . . . . . . . . . . . 2-2Le concepteur de fiche, la palette de composants

et l’inspecteur d’objets . . . . . . . . . . . . . 2-3L’arborescence d’objets . . . . . . . . . . . . . . 2-4Le référentiel d’objets . . . . . . . . . . . . . . . 2-5L’éditeur de code . . . . . . . . . . . . . . . . . 2-6

Audit de code . . . . . . . . . . . . . . . . 2-6Navigation dans le code . . . . . . . . . . 2-7

La page Diagramme . . . . . . . . . . . . . . 2-8Visualisation du code des fiches . . . . . . . 2-9

L’explorateur de classe . . . . . . . . . . . . . . 2-9Le gestionnaire de projet . . . . . . . . . . . . . 2-9Liste A faire . . . . . . . . . . . . . . . . . . . . 2-10

Chapitre 3Programmation avec C++Builder 3-1Création d’un projet . . . . . . . . . . . . . . . . 3-1

Ajout de modules de données . . . . . . . . 3-2Construction de l’interface utilisateur . . . . . 3-2

Positionnement des composants sur une fiche . . . . . . . . . . . . . . . . . 3-2

Définition des propriétés des composants . 3-4Ecriture du code . . . . . . . . . . . . . . . . . . 3-5

Ecriture des gestionnaires d’événements . . 3-5Utilisation des bibliothèques VCL et CLX . 3-6

Compilation et débogage des projets . . . . . . 3-7Déploiement des applications . . . . . . . . . . 3-8Internationalisation d’applications . . . . . . . 3-9

Types de projets. . . . . . . . . . . . . . . . . . . 3-9Applications CLX . . . . . . . . . . . . . . . 3-10Applications serveur Web . . . . . . . . . . 3-10Applications de bases de données . . . . . 3-11

Administrateur BDE. . . . . . . . . . . . 3-12Explorateur SQL

(explorateur de base de données) . . . 3-12Module base de données . . . . . . . . . 3-12Dictionnaire de données . . . . . . . . . 3-13

Composants personnalisés . . . . . . . . . . 3-13DLL . . . . . . . . . . . . . . . . . . . . . . . 3-13COM et ActiveX. . . . . . . . . . . . . . . . 3-14

Bibliothèques de types . . . . . . . . . . 3-14

Chapitre 4Tutoriel : création d’un éditeur de texte 4-1

Démarrage d’une nouvelle application . . . . . 4-1Définition des valeurs d’une propriété . . . . . 4-2Ajout de composants à la fiche . . . . . . . . . . 4-3Ajout du support pour un menu

et une barre d’outils . . . . . . . . . . . . . . . 4-6Différences entre l’éditeur du gestionnaire

d’actions et l’éditeur de liste d’actions . . . 4-7Ajout d’images aux menus et à la barre

d’outils (Entreprise et Professionnel) . . . . 4-7Ajout d’actions au gestionnaire d’actions

(Entreprise et Professionnel) . . . . . . . . . 4-9Ajout d’actions standard

(Entreprise et Professionnel) . . . . . . . . 4-11Ajout d’un menu

(Entreprise et Professionnel) . . . . . . . . 4-13Ajout d’une barre d’outils

(Entreprise et Professionnel) . . . . . . . . 4-14Ajout d’une liste d’images et d’images

(édition Personnelle) . . . . . . . . . . . . 4-15Ajout d’actions à la liste d’actions

(édition Personnelle) . . . . . . . . . . . . 4-16Ajout d’actions standard à la liste d’actions

(édition Personnelle) . . . . . . . . . . . . 4-18Ajout d’un menu (édition Personnelle) . . 4-20Ajout d’une barre d’outils

(édition Personnelle) . . . . . . . . . . . . 4-23Effacement de la zone de texte

(toutes éditions) . . . . . . . . . . . . . . . . . 4-24

Table des matières

ii

Ecriture de gestionnaires d’événements . . . . 4-25Création d’un gestionnaire d’événement

pour la commande Nouveau . . . . . . . . 4-25Création d’un gestionnaire d’événement

pour la commande Ouvrir . . . . . . . . . 4-28Création d’un gestionnaire d’événement

pour la commande Enregistrer . . . . . . . 4-29Création d’un gestionnaire d’événement

pour la commande Enregistrer sous . . . . 4-30Création d’un fichier d’aide . . . . . . . . . . . 4-32

Création d’un gestionnaire d’événement pour la commande Rubriques d’aide . . . 4-32

Création d’un gestionnaire d’événement pour la commande Index de l’aide . . . . 4-33

Création d’une boîte de dialogue A propos . . 4-34Achèvement de l’application . . . . . . . . . . . 4-36

Chapitre 5Tutoriel : création d’une application

de base de données CLX 5-1Présentation de l’architecture

des bases de données . . . . . . . . . . . . . . 5-1Création d’une nouvelle application CLX . . . 5-2Installation des composants

d’accès aux données . . . . . . . . . . . . . . . 5-3Installation de la connexion

à la base de données . . . . . . . . . . . . . 5-3Installation de l’ensemble de données

unidirectionnel . . . . . . . . . . . . . . . . 5-5Installation du fournisseur,

de l’ensemble de données client et de la source de données . . . . . . . . . 5-5

Conception de l’interface utilisateur . . . . . . 5-6Création de la grille

et de la barre de navigation. . . . . . . . . 5-7

Ajout du support pour un menu . . . . . . . 5-8Ajout d’un menu . . . . . . . . . . . . . . . 5-10Ajout d’un bouton . . . . . . . . . . . . . . 5-12

Affichage d’un titre et d’une image . . . . . . 5-12Ecriture d’un gestionnaire d’événements . . . 5-14

Ecriture d’un gestionnaire d’événement pour la commande Mise à jour immédiate ! . . 5-14

Ecriture d’un gestionnaire d’événement pour la commande Quitter. . . . . . . . . 5-15

Ecriture d’un gestionnaire d’événement pour fermer la fiche . . . . . . . . . . . . . 5-15

Chapitre 6Personnalisation du bureau 6-1Organisation de votre espace de travail . . . . . 6-1

Agencement des menus et des barres d’outils . . . . . . . . . . . . . 6-1

Ancrage des fenêtres d’outils . . . . . . . . . 6-2Enregistrement des dispositions du bureau . 6-4

Personnalisation de la palette de composants . 6-5Organisation de la palette de composants . . 6-5Création de modèles de composants . . . . . 6-5Installation de paquets de composants. . . . 6-6

Utilisation des cadres . . . . . . . . . . . . 6-7Ajout de contrôles ActiveX. . . . . . . . . 6-8

Définition des options des projets . . . . . . . . 6-8Définition des options de projet par défaut . 6-8

Spécification des modèles de projet et de fiches par défaut . . . . . . . . . . . . . . 6-8

Ajout de modèles au référentiel d’objets. . . 6-9Définition des préférences pour les outils . . . 6-10

Personnalisation du concepteur de fiche. . 6-10Personnalisation de l’éditeur de code . . . 6-11

Index I-1

I n t r o d u c t i o n 1-1

C h a p i t r e

1Chapitre 1Introduction

Ce manuel, Prise en main, présente l’environnement de développement de C++Builder pour vous permettre d’utiliser immédiatement le produit. Il indique aussi où rechercher des renseignements sur l’utilisation des outils et des fonctionnalités disponibles dans C++Builder.

Le chapitre 2, “Parcours rapide de l’environnement”, décrit les principaux outils disponibles sur le bureau C++Builder, c’est-à-dire l’environnement de développement intégré (EDI). Le chapitre 3, “Programmation avec C++Builder”, explique l’utilisation de certains de ces outils pour créer une application. Le chapitre 4, “Tutoriel : création d’un éditeur de texte”, vous guide, étape par étape, dans l’écriture d’un programme d’éditeur de texte. Le chapitre 5, “Tutoriel : création d’une application de base de données CLX”, vous guide pas à pas dans la création d’une application de base de données. Le chapitre 6, “Personnalisation du bureau”, décrit comment personnaliser l’EDI de C++Builder pour qu’il réponde à vos besoins de développement.

Qu’est-ce que C++Builder ?C++Builder est un environnement de programmation visuel orienté objet pour le développement rapide d’applications (RAD). En utilisant C++Builder, vous pouvez, avec un minimum de codage manuel, créer de performantes applications pour Microsoft Windows XP, Microsoft Windows 2000 et Microsoft Windows 98. C++Builder fournit tous les outils nécessaires pour développer, tester et déployer vos applications, notamment une importante bibliothèque de composants réutilisables, une suite d’outils de conception, des modèles d’applications et de fiches, ainsi que des experts de programmation.

1-2 P r i s e e n m a i n

E n r e g i s t r e m e n t d e C + + B u i l d e r

Enregistrement de C++BuilderC++Builder peut être enregistré de plusieurs façons. La première fois que vous lancez C++Builder après son installation, vous êtes invité à entrer un numéro de série et une clé d’autorisation. Après cela, la boîte de dialogue d’enregistrement vous propose trois possibilités :

• En ligne (enregistrement et activation du logiciel).

Utilisez cette option pour effectuer l’enregistrement en ligne via votre connexion internet en cours.

• Par téléphone ou navigateur Web (enregistrement et activation du logiciel).

Utilisez cette option pour effectuer l’enregistrement par téléphone ou via votre navigateur web. Si vous avez reçu une clé d’activation par e-mail, entrez-la en utilisant cette option.

• Je m’enregistrerai ultérieurement.

L’enregistrement en ligne est le moyen le plus simple d’enregistrer C++Builder, mais il nécessite qu’une connexion internet soit active. Si vous êtes déjà membre de la Communauté Borland ou si vous avez un compte d’enregistrement de logiciel, entrez simplement les informations concernant ce compte. Cela enregistrera automatiquement C++Builder. Sinon, le processus d’enregistrement vous propose le moyen de créer un compte.


O ù t r o u v e r d e s i n f o r m a t i o n s ?

La deuxième option (enregistrement et activation par téléphone ou navigateur) est utile si la machine sur laquelle vous effectuez l’installation n’est pas connectée à internet, si un pare-feu bloque les enregistrements en ligne ou si vous avez déjà reçu une clé d’activation.

Remarque Sauf si vous avez une raison particulière de ne pas le faire, préférez l’option d’enregistrement en ligne.

Où trouver des informations ?Vous pouvez trouver des informations sur C++Builder de différentes façons (les sections qui suivent décrivent ces sources d’information) :

• dans l’aide en ligne, • dans la documentation imprimée,• sur le site Web de Borland et de ses services de support aux développeurs.

Pour des informations sur les nouveautés de cette version, reportez-vous à la rubrique Nouveautés de l’aide en ligne.



Aide en ligne

Le système d’aide en ligne fournit des informations détaillées sur les fonctionnalités de l’interface utilisateur, l’implémentation du langage, les tâches de programmation et les composants de la bibliothèque de composants visuels Borland (VCL) et de la bibliothèque de composants Borland multiplate-forme (CLX). Il contient toutes les informations se trouvant dans le Guide du développeur ainsi que de nombreux fichiers d’aide pour d’autres éléments fournis avec C++Builder.

Pour afficher la table des matières, choisissez Aide|Aide C++Builder et Aide|Outils C++Builder et choisissez l’onglet Sommaire. Pour rechercher des informations sur les objets VCL, CLX ou d’autres sujets, choisissez les onglets Index ou Rechercher et saisissez votre requête.

Aide F1

Pour obtenir de l’aide sur la VCL, CLX ou tout élément de l’environnement de développement (y compris les éléments de menu, les boîtes de dialogue, les barres d’outils et les composants) sélectionnez l’élément et appuyez sur F1.

Appuyez sur F1 au niveau d’un nom de propriété ou d’événement dans l’inspecteur d’objets afin d’afficher l’aide VCL.



Appuyez sur F1 au niveau d’un mot clé ou d’un élément de la VCL dans l’éditeur de code.

Appuyez sur F1 au niveau d’un objet dans le concepteur de fiche.

Appuyez sur F1 au niveau de n’importe quelle commande de menu, boîte de dialogue ou fenêtre pour afficher l’aide correspondant à cet élément.


D o c u m e n t a t i o n i m p r i m é e

L’appui sur le bouton Aide dans toute boîte de dialogue affiche également une aide contextuelle.

Les messages d’erreur issus du compilateur et du lieur apparaissent dans une fenêtre spéciale située sous l’éditeur de code. Pour avoir de l’aide sur les erreurs de compilation, sélectionnez un message dans la liste et appuyez sur F1.

Documentation impriméeCe manuel, Prise en main, est une introduction à C++Builder. Outre ce manuel, vous disposez du manuel suivant selon la version de C++Builder que vous avez acquise : Guide du développeur.

Services de support développeurBorland offre aussi de nombreuses possibilités de support si vous avez besoin d’informations supplémentaires. Pour des informations sur les services de support développeur de Borland, visitez le site Web à l’adresse http://www.borland.fr/support.

A partir de ce site, vous pouvez accéder à divers groupes de discussion où les développeurs C++Builder échangent informations, astuces et techniques. Ce site propose également une liste de livres traitant de C++Builder, d’autres documents techniques C++Builder et des foires aux questions (FAQ).

Conventions typographiquesCe manuel utilise les types de caractères décrits dans le tableau ci-dessous.

Types de caractères Signification

Espacement fixe Les caractères d’espacement fixe représentent du texte qui apparaît sur l’écran ou du code. Ils représentent aussi tout texte que vous tapez.

Gras Les mots en gras dans le texte ou les programmes représentent des mots réservés ou des options du compilateur.

Italique Les mots en italique dans le texte représentent des identificateurs C++Builder tels que des noms de variables ou de types. Les italiques sont aussi utilisés pour mettre en valeur certains mots tels que les nouveaux termes.

Touches Ce type de caractères indique une touche de votre clavier. Par exemple, “Appuyez sur Echap pour fermer un menu.”

P a r c o u r s r a p i d e d e l ’ e n v i r o n n e m e n t 2-1

C h a p i t r e

2Chapitre 2Parcours rapide de l’environnement

Ce chapitre explique comment démarrer C++Builder et donne un aperçu rapide des principales parties et des outils de l’environnement de développement intégré (EDI).

Démarrage de C++BuilderVous pouvez démarrer C++Builder de plusieurs façons :

• Double-cliquer sur l’icône C++Builder (si vous avez créé un raccourci).

• Choisir Programmes|Borland C++Builder dans le menu Démarrer de Windows.

• Choisir Exécuter dans le menu Démarrer de Windows, puis entrer Bcb.

• Double-cliquer sur Bcb.exe dans le répertoire CBuilder6\Bin.

L’EDILorsque vous démarrez C++Builder pour la première fois, vous voyez apparaître quelques-uns des principaux outils proposés dans l’EDI. Dans C++Builder, l’EDI comprend des barres d’outils, des menus, la palette de composants, l’inspecteur d’objets, l’arborescence d’objets, l’éditeur de code, l’explorateur de classes, le gestionnaire de projet et bien d’autres outils. Selon l’édition de C++Builder, les caractéristiques et les composants disponibles varient.


M e n u s e t b a r r e s d ’ o u t i l s

Le modèle de développement C++Builder repose sur des outils bidirectionnels. Cela signifie que vous pouvez passer alternativement des outils de conception visuelle aux modifications du code sous forme de texte. Par exemple, après avoir utilisé le concepteur de fiche pour agencer les boutons et les autres éléments d’une interface graphique, vous pouvez voir immédiatement le fichier fiche contenant la description textuelle de votre fiche. De même, vous pouvez modifier manuellement tout code généré par C++Builder sans perdre l’accès à l’environnement de programmation visuelle.

Dans l’EDI, tous les outils de programmation sont facilement accessibles. Vous pouvez concevoir des interfaces graphiques, parcourir les bibliothèques de classes, écrire du code, compiler, tester, déboguer et gérer des projets sans quitter l’EDI.

Pour apprendre à organiser et à configurer l’EDI, reportez-vous au chapitre 6, “Personnalisation du bureau”.

Menus et barres d’outilsLa fenêtre principale, qui occupe la partie supérieure de l’écran, contient le menu principal, les barres d’outils et la palette de composants.

Concepteur de fiche contenant une fiche vierge pour démarrer laconception de l’interface utilisateur de votre application. Une application peut inclure plusieurs fiches.

Palette de composants prêts à être utilisés dans votre application.

Editeur de code permettant de visualiser et de modifier le code.

L’explorateur de code montre les classes, variables et routines de votre unité et vous permet de naviguer rapidement.

L’inspecteur d’objets est utilisé pour changer les propriétés des objets et sélectionner les gestionnaires d’événements.

La vue arborescente de l’objet affiche une représentation hiérarchique des relations parent-enfant des composants.

Fenêtre principale dans son agencement par défaut.


L e c o n c e p t e u r d e f i c h e , l a p a l e t t e d e c o m p o s a n t s e t l ’ i n s p e c t e u r d ’ o b j e t s

Les barres d’outils de C++Builder permettent un accès rapide aux opérations et aux commandes les plus utilisées. La plupart des opérations accessibles dans les barres d’outils se retrouvent dans les menus déroulants.

De nombreuses opérations possèdent des équivalents clavier ainsi que des boutons dans la barre d’outils. Lorsqu’un raccourci clavier est disponible, il est toujours inscrit à côté de la commande dans le menu déroulant.

Vous pouvez cliquer avec le bouton droit de la souris sur la plupart des outils et des icônes pour afficher un menu de commandes appropriées à l’objet que vous manipulez. Il s’agit des menus contextuels.

Vous pouvez également personnaliser les barres d’outils en leur ajoutant des commandes ou en les déplaçant. Pour plus d’informations, voir “Agencement des menus et des barres d’outils” à la page 6-1 et “Enregistrement des dispositions du bureau” à la page 6-4.

Pour plus d’informations...Si vous voulez des informations sur une option de menu, pointez-la et appuyez sur F1.

Le concepteur de fiche, la palette de composants et l’inspecteur d’objets

La palette des composants, le concepteur de fiche, l’inspecteur d’objets et l’arborescence d’objets vous permettent de concevoir l’interface utilisateur d’une application.

La palette de composants est composée de pages à onglets où des groupes d’icônes représentent les composants VCL et CLX visuels ou non visuels que vous pouvez utiliser pour la conception de l’interface de vos applications.

Vous pouvez aussi utiliser le menu contextuel pour cacher les barres d’outils. Pour afficher une barre d’outils cachée, choisissez Voir|Barres d’outils et cochez la barre d’outils voulue.

Pour connaître la fonction d’un bouton, pointez dessus pendant un court moment pour qu’un message s’affiche

Exécuter

Ouvrir un projet

Tout enregistrer

Ajouter un fichier au projet

Ouvrir

Enregistrer

Nouvelle fiche

Retirer un fichier du projetNouveau

Basculer fiche/unité

Voir une fiche

Voir une unité

Barre d’outils Standard

Suspendre

Pas à pas approfondi

Pas à pas

Barre d’outils Voir

Barre d’outils Déboguer

Liste des projets exécutables

Barre d’outils Bureaux

Nom de la disposition du bureau enregistré

Définir le bureau de débogage

Enregistrer le bureau

Nouveau module de page WebSnap

Nouveau module de données WebSnap

Editeur externe

Barre d’outils Internet

Nouvelle application WebSnap


L ’ a r b o r e s c e n c e d ’ o b j e t s

Les pages regroupent les composants selon leurs diverses fonctionnalités. Ainsi les pages Supplément et Win32 contiennent des contrôles fenêtrés comme les boîtes de saisie ou les cases à cocher ; la page Dialogues contient les boîtes de dialogue standard utilisées dans les opérations de fichier comme l’ouverture ou l’enregistrement de fichiers.

Chaque composant possède des attributs spécifiques (propriétés, événements et méthodes) vous permettant de contrôler votre application.

Utilisez le concepteur de fiche pour arranger les composants à votre convenance dans l’interface utilisateur. Pour chaque composant que vous placez sur une fiche, utilisez l’inspecteur d’objets pour définir des propriétés de conception, créer des gestionnaires d’événements, filtrer la visibilité des propriétés et des événements, ce qui établira le lien entre l’apparence visuelle de votre application et le code qui la fait s’exécuter. Voir “Positionnement des composants sur une fiche” à la page 3-2.

Pour plus d’informations...Voir “palette de composants” dans l’index de l’aide.

L’arborescence d’objetsL’arborescence d’objets affiche les relations parent-enfant et entre enfants des composants dans une vue hiérarchique arborescente. Cette arborescence est synchronisée avec l’inspecteur d’objets et le concepteur de fiche : si vous déplacez la sélection dans l’arborescence d’objets, elle est déplacée en conséquence dans l’inspecteur d’objets et dans la fiche.

L’arborescence d’objets vous permet de changer la relation établie entre des composants. Si par exemple, vous ajoutez des composants volet et case à cocher à votre fiche, ces deux composants sont frères. Mais, si vous utilisez l’arborescence d’objets pour déplacer la case à cocher sur l’icône du volet, la case à cocher devient un enfant du volet.

Si les propriétés d’un objet n’ont pas été renseignées, l’arborescence d’objets affiche un point d’interrogation rouge à côté. Vous pouvez également double-cliquer sur un objet dans l’arborescence pour ouvrir l’éditeur de code afin d’écrire un gestionnaire d’événement.

Si l’arborescence d’objets n’apparaît pas, sélectionnez Voir|Arborescence d’objets.

L’arborescence d’objets est particulièrement utile pour afficher les relations entre objets de base de données.

Pages de la palette de composants, regroupées par fonctions

Composants

Cliquez ici pour visualiser les autres pages.


L e r é f é r e n t i e l d ’ o b j e t s

Pour plus d’informations...Voir “arborescence d’objets” dans l’index de l’aide.

Le référentiel d’objetsLe référentiel d’objets contient des fiches, boîtes de dialogue, modules de données, experts, exemples d’applications DLL ainsi que d’autres éléments pouvant simplifier le développement. Choisissez Fichier|Nouveau|Autre pour afficher la boîte de dialogue Nouveaux éléments par laquelle débute un projet. Cette boîte de dialogue est également appelée le référentiel d’objets. Recherchez dans le référentiel un objet qui ressemble à celui que vous voulez créer.

Pour modifier ou supprimer des objets dans le référentiel d’objets, choisissez Outils|Référentiel ou cliquez avec le bouton droit dans la boîte de dialogue Nouveaux éléments et choisissez Propriétés.

Pour ajouter des modèles de projet ou de fiche au référentiel d’objets, voir “Ajout de modèles au référentiel d’objets” à la page 6-9.

Pour plus d’informations...Voir “référentiel d’objets” dans l’index de l’aide en ligne. Les objets disponibles dépendent de votre édition C++Builder.

Les pages à onglet du référentiel d’objets contiennent des objets tels des fiches, des cadres, des unités, ainsi que des experts pour créer des éléments spécialisés.

Lorsque vous créez un élément à partir d’un objet du référentiel, vous pouvez choisir de copier l’élément, d’hériter de lui ou de l’utiliser :Copier (par défaut) crée une copie de l’élément dans votre projet. Hériter signifie que les modifications apportées à l’objet du référentiel sont héritées par l’objet de votre projet. Utiliser signifie que les modifications apportées à l’objet de votre projet sont héritées par l’objet du référentiel.

Vous pouvez ajouter, supprimer ou renommer un onglet dans le référentiel d’objets.

Cliquez sur les flèches pour modifier l’ordre dans lequel apparaissent les onglets de la boîte de dialogue Nouveaux éléments.


L ’ é d i t e u r d e c o d e

L’éditeur de codeA mesure que vous construisez l’interface utilisateur de votre application, C++Builder génère le code sous-jacent. Lorsque vous sélectionnez et modifiez les propriétés des fiches et des composants, ces modifications sont automatiquement répercutées dans les fichiers source. Vous pouvez ajouter directement du code à vos fichiers source en utilisant l’éditeur de code intégré, un éditeur ASCII complet. C++Builder propose diverses aides à l’écriture de code, dont les outils d’audit de code (Code Insight), l’achèvement de classe et la navigation dans le code.

Audit de codeLes outils d’audit de code (Code Insight) affichent des fenêtres surgissantes contextuelles.

Tableau 2.1 Les outils d’audit de code

Outil Fonctionnement de l’outil

Achèvement du code Entrez le nom d’une variable qui représente un pointeur sur un objet suivi d’une flèche (->) ou qui représente un objet non VCL suivi par un point. Tapez le début d’une instruction d’affectation puis appuyez sur Ctrl+espace pour afficher une liste d’arguments valides pour la variable. Tapez un nom de procédure, de fonction ou de méthode pour faire apparaître une liste d’arguments.

Paramètres du code Tapez un nom de méthode et une parenthèse ouvrante pour afficher la syntaxe des arguments de la méthode.

Modèles de code Appuyez sur Ctrl+J pour lister les instructions de programmation courantes que vous pouvez insérer dans votre code. Vous pouvez créer vos propres modèles qui viendront s’ajouter à ceux qui sont fournis par C++Builder.

L’ajout de composants à la fiche est répercuté dans le code.

Code généré.



Pour activer ou désactiver ces outils, choisissez Outils|Options de l’éditeur et sélectionnez l’onglet Audit de code. Cochez ou non les outils dans la zone Fonctionnalités automatiques.

Pour plus d’informations...Voir “Audit de code” dans l’index de l’aide en ligne.

Navigation dans le codeQuand vous faites passer la souris au-dessus d’un nom de classe, de variable, de propriété de méthode ou de tout autre identificateur, le menu surgissant appelé Audit de symbole dans conseil indique où l’identificateur est déclaré. Appuyez sur Ctrl : le curseur prend la forme d’une main, l’identificateur devient bleu et vous pouvez cliquer dessus pour atteindre sa définition.

L’éditeur de code dispose de boutons Suivant et Précédent similaires à ceux d’un navigateur Web. Quand vous atteignez une définition, l’éditeur de code se souvient de vos déplacements dans le code. Vous pouvez cliquer sur les flèches placées à côté des boutons Parcourir vers l’avant et Parcourir vers l’arrière pour parcourir l’historique de ces références.

Pour personnaliser l’environnement de l’éditeur de code, voir “Personnalisation de l’éditeur de code” à la page 6-11.

Pour plus d’informations...Voir “éditeur de code” dans l’index de l’aide en ligne.

Evaluation d’expression dans conseil

Lors d’un arrêt pendant le débogage, pointez sur une variable pour afficher sa valeur courante.

Audit de symbole dans conseil

Pendant l’édition du code, pointez sur un identificateur quelconque pour afficher sa déclaration.

Tableau 2.1 Les outils d’audit de code (suite)

Outil Fonctionnement de l’outil

Utilisez l’éditeur comme un navigateur Web.

Appuyez sur Ctrl et pointez sur n’importe quel identificateur. Le curseur prend la forme d’une main et l’identificateur devient bleu et souligné. Cliquez pour aller à l’endroit où est défini l’identificateur.Ensuite, cliquez sur la flèche Précédent pour revenir à l’emplacement précédent.



La page Diagramme

En bas de l’éditeur de code, il peut y avoir un ou plusieurs onglets, en fonction de l’édition de C++Builder que vous utilisez. La page de code dans laquelle vous écrivez votre code apparaît par défaut au premier plan. La page Diagramme affiche des icônes reliées par des lignes représentant les relations entre les composants que vous avez placés dans une fiche ou un module de données. Ces relations s’établissent entre enfants, de parents à enfants ou entre les composants et les propriétés.

Pour créer un diagramme, cliquez sur la page Diagramme. Depuis l’arborescence d’objets, faites glisser vers la page Diagramme une ou plusieurs icônes pour les organiser verticalement. Pour les organiser horizontalement, appuyez sur Maj tout en déplaçant les icônes. Quand vous déplacez des icônes ayant des dépendances de type parent-enfant ou composant-propriété, des lignes (ou connecteurs) affichant la relation de dépendance sont automatiquement ajoutées. Si, par exemple, vous ajoutez un composant ensemble de données à un module de données, puis déplacez dans la page Diagramme l’icône ensemble de données plus ses icônes de propriété, le connecteur de propriété relie automatiquement les icônes de propriétés à l’icône de l’ensemble de données.

Pour les composants n’ayant pas de relation de dépendance mais où vous voulez en voir une, utilisez les boutons de la barre d’outils en haut de la page Diagramme pour ajouter l’un des quatre types de connecteurs (bloc de texte, propriété, maître/détail et référence). Vous pouvez également ajouter des blocs de commentaire qui se connectent ensemble ou à l’icône appropriée.

Vous pouvez attribuer un nom et une description à votre diagramme, l’enregistrer et l’imprimer une fois qu’il est complet.

Pour plus d’informations...Voir “page diagramme” dans l’index de l’aide en ligne.

Utilisez les boutons de la barre d’outils de la page Diagramme (Propriété, Maître /détail, Référence) pour désigner la relation entre des composants ou entre des composants et leurs propriétés. Le type de trait change selon le type de relation.Cliquez sur le bouton Bloc de commentaire pour ajouter un bloc de commentaire et sur le bouton Connecteur de blocs de texte pour établir une connexion avec un autre bloc de commentaire ou une icône.

Depuis l’arborescence des objets, faites glisser les icônes des composants dans la page Diagramme.

Pour voir d’autres diagrammes nommés du projet en cours, choisissez dans la liste déroulante.Entrez le nom et la description de votre diagramme.


L ’ e x p l o r a t e u r d e c l a s s e

Visualisation du code des fiches

Les fiches constituent la partie visible de la majorité des projets C++Builder. C’est là que vous concevez l’interface utilisateur d’une application. Normalement, vous concevez les fiches en utilisant les outils visuels de C++Builder, et C++Builder les stocke dans des fichiers. Les fichiers des fiches (.dfm ou .xfm pour une application CLX) décrivent chacun des composants d’une fiche, y compris la valeur de toutes les propriétés persistantes. Pour voir et modifier le fichier d’une fiche dans l’éditeur de code, cliquez avec le bouton droit sur la fiche et sélectionnez Voir comme texte. Pour revenir à la vue graphique de la fiche, cliquez avec le bouton droit et choisissez Voir comme fiche.

Vous pouvez enregistrer les fichiers des fiches soit en format texte (par défaut) soit en format binaire. Choisissez Outils|Options d’environnement, cliquez sur la page Concepteur, et cochez ou non l’option Nouvelles fiches comme texte pour préciser le format à utiliser pour les fiches nouvellement créées.

Pour plus d’informations...Voir “fichiers fiche” dans l’index de l’aide en ligne.

L’explorateur de classeA l’ouverture de C++Builder, l’explorateur de classe est ancré à gauche de la fenêtre de l’éditeur de code, la disponibilité de l’explorateur de code dépend de l’édition de C++Builder dont vous disposez. L’explorateur de classe affiche la table des matières sous la forme d’une arborescence du code source ouvert dans l’éditeur de code, en énumérant les types, classes, propriétés, méthodes, variables globales et les routines définies dans l’unité.

Vous pouvez utiliser l’explorateur de classe pour parcourir le contenu de l’éditeur de code. Si par exemple, vous double-cliquez sur un nom de méthode dans l’explorateur de classe, le curseur passe dans l’éditeur de code à sa définition dans la déclaration de classe de l’unité dans la partie interface de l’unité.

Pour configurer l’affichage du contenu de l’explorateur de code, choisissez Outils|Options d’environnement et sélectionnez l’onglet Explorateur.

Pour plus d’informations...Voir “explorateur de classe” dans l’index de l’aide en ligne.

Le gestionnaire de projetLorsque vous démarrez C++Builder pour la première fois, il ouvre automatiquement un nouveau projet. Un projet comprend plusieurs fichiers qui constituent ensemble l’application ou la DLL que vous développez. Vous pouvez voir et organiser ces fichiers, comme les fichiers fiche, unité, ressource, objet et


L i s t e A f a i r e

bibliothèque, dans un outil de gestion des projets appelé le gestionnaire de projet. Pour afficher le gestionnaire de projet, choisissez Voir|Gestionnaire de projet.

Vous pouvez utiliser le gestionnaire de projet pour combiner et afficher des informations concernant des projets qui sont associés en un groupe de projets. En organisant ainsi des projets, par exemple plusieurs exécutables, vous pouvez les compiler en même temps. Pour modifier les options des projets, comme celles de la compilation, reportez-vous à “Définition des options des projets” à la page 6-8.

Pour plus d’informations...Voir “gestionnaire de projet” dans l’index de l’aide en ligne.

Liste A faireLes listes A faire enregistrent les éléments à terminer pour un projet. Vous pouvez inclure dans une liste des éléments du niveau du projet en les ajoutant directement à la liste ou vous pouvez ajouter des éléments spécifiques directement dans le code source. Choisissez Voir|Liste A faire pour ajouter ou voir des informations associées à un projet.

Pour plus d’informations...Voir “liste A faire” dans l’index de l’aide en ligne.

Cliquez avec le bouton droit sur une liste A faire pour afficher les commandes permettant de trier ou de filtrer cette liste.

Cliquez ici lorsque vous en avez terminé avec un élément.

P r o g r a m m a t i o n a v e c C + + B u i l d e r 3-1

C h a p i t r e

3Chapitre 3Programmation avec C++Builder

Les sections suivantes fournissent une analyse du développement de logiciels avec C++Builder : création d’un projet, travail sur les fiches, écriture de code, compilation, débogage, déploiement et internationalisation des programmes. Elles présentent également les types de projets que vous pouvez développer.

Création d’un projetUn projet est une collection de fichiers qui sont soit créés au moment de la conception soit générés lorsque vous compilez le code source du projet. Lorsque vous démarrez C++Builder pour la première fois, un nouveau projet est ouvert. Cela génère automatiquement, entre autres fichiers, un fichier projet (Project1.dpr), un fichier unité (Unit1.pas) et un fichier ressource (Unit1.dfm, Unit1.xfm pour les applications CLX).

Si un projet est déjà ouvert et si vous voulez en ouvrir un nouveau, choisissez Fichier|Nouveau|Application, ou choisissez Fichier|Nouveau|Autre et double-cliquez sur l’icône Application. Fichier|Nouveau|Autre ouvre un référentiel d’objets qui fournit les fiches, les cadres et les modules, ainsi que les modèles pré-fabriqués comme les boîtes de dialogue, que vous pouvez ajouter à votre projet. Pour en savoir plus sur le référentiel d’objets, reportez-vous à “Le référentiel d’objets” à la page 2-5.

Lorsque vous démarrez un projet, vous devez savoir ce que vous voulez développer, par exemple une application ou une DLL. Pour des informations sur les types de projets que vous pouvez développer avec C++Builder, voir “Types de projets” à la page 3-9.

Pour plus d’informations...Voir “projets” dans l’index de l’aide en ligne.


C o n s t r u c t i o n d e l ’ i n t e r f a c e u t i l i s a t e u r

Ajout de modules de données

Un module de données est une sorte de fiche qui contient des composants uniquement non visuels. Les composants non visuels d’un module de données peuvent être placés sur des fiches normales, à côté de composants visuels. Mais, si vous prévoyez de réutiliser des groupes de bases de données et d’objets système, ou si vous voulez séparer les parties de votre application concernant la connexion aux bases de données et les règles de gestion, les modules de données offrent un outil d’organisation pratique.

Pour créer un module de données, choisissez Fichier|Nouveau|Module de données. C++Builder ouvre un module de données vide, ce qui affiche dans l’éditeur de code un fichier unité supplémentaire, et ajoute le module au projet en cours en tant que nouvelle unité. Pour ajouter des composants non visuels à un module de données, procédez comme avec une fiche.

Lorsque vous rouvrez un module de données existant, C++Builder affiche ses composants.

Pour plus d’informations...

Voir “modules de données” dans l’index de l’aide.

Construction de l’interface utilisateurAvec C++Builder, vous devez d’abord créer une interface utilisateur (IU) en sélectionnant des composants dans la palette de composants et en les plaçant sur la fiche principale.

Positionnement des composants sur une fiche

Pour placer des composants sur une fiche :

1 Double-cliquez sur le composant ou

2 Cliquez une seule fois sur le composant puis sur la fiche à l’endroit où vous voulez le faire apparaître.

Double-cliquez sur un composant non visuel de la palette de composants pour le placer dans le module de données.



Sélectionnez le composant et faites-le glisser là où vous voulez le faire apparaître sur la fiche.

Pour plus d’informations...Voir “palette des composants” dans l’index de l’aide en ligne.

Vous pouvez aussi réorganiser la palette et lui ajouter de nouvelles pages. Choisissez Options d’environnement, puis la page Palette.

La palette des composants présente de nombreux composants, groupés par fonction.

Cliquez sur un composant dans la palette de composants

Cliquez ensuite sur l’endroit où vous voulez le positionner sur la fiche.

Ou, choisissez un composant dans une liste alphabétique.

Vous pouvez installer de nouveaux composants dans la palette des composants.



Définition des propriétés des composants

Après avoir placé des composants sur une fiche, définissez leurs propriétés et codez leurs gestionnaires d’événements. En définissant les propriétés d’un composant, vous changez la façon dont celui-ci apparaît et se comporte dans votre application. Lorsqu’un composant est sélectionné sur une fiche, ses propriétés et ses événements sont affichés dans l’inspecteur d’objets.

De nombreuses propriétés possèdent des valeurs simples, comme les noms des couleurs, True ou False, et des entiers. Pour les propriétés booléennes, vous pouvez double-cliquer sur le mot pour passer alternativement de True à False. Certaines propriétés sont associées à des éditeurs permettant de définir des valeurs plus complexes. Lorsque vous cliquez sur la valeur d’une de ces propriétés, des points de suspension apparaissent. Pour certaines propriétés, comme la taille, il faut entrer une valeur.

Lorsque plusieurs composants sont sélectionnés dans la fiche, l’inspecteur d’objets affiche toutes les propriétés partagées par ces composants.

Utilisez cette liste déroulante pour sélectionner un objet. Ici, Button1 est sélectionné et ses propriétés sont affichées.

Vous pouvez aussi cliquer sur le signe plus pour ouvrir une liste de détails.

Sélectionnez une propriété et changez sa valeur dans la colonne de droite.Cliquez sur les points de suspension pour ouvrir une boîte de dialogue permettant de modifier les propriétés d’un objet utilitaire.

Vous pouvez sélectionner un composant, ou objet, sur la fiche en cliquant dessus.

Double-cliquez ici pour changer la valeur True en False.

Cliquez sur la flèche vers le bas pour faire votre choix parmi les valeurs valides de la propriété.

Cliquez sur les points de suspension pour afficher l’éditeur de cette propriété.


E c r i t u r e d u c o d e

L’inspecteur d’objets permet également de développer en ligne les références à un composant. Cela permet d’accéder aux propriétés et événements d’un composant référencé sans avoir à le sélectionner. Si, par exemple, vous ajoutez un bouton et un composant menu surgissant dans une fiche, vous pouvez sélectionner le composant bouton, dans l’inspecteur d’objets, initialiser sa propriété PopupMenu à PopupMenu1, ce qui affiche toutes les propriétés du menu surgissant.

Pour plus d’informations...Voir “inspecteur d’objets” dans l’index de l’aide en ligne.

Ecriture du codeLa partie fondamentale de toute application est le code associé à chaque composant. Bien que l’environnement RAD de C++Builder apporte la majorité des blocs de construction de vos applications, comme les composants visuels et non visuels pré-empaquetés, il vous faudra habituellement écrire des gestionnaires d’événements et, sans doute, certaines de vos propres classes. Pour vous aider dans cette tâche, les milliers d’objets des bibliothèques de classes VCL et CLX de C++Builder sont à votre disposition. Pour apprendre à voir et à modifier votre code source, reportez-vous à “L’éditeur de code” à la page 2-6.

Ecriture des gestionnaires d’événements

Votre code doit répondre aux événements qui se produisent pour un composant au moment de l’exécution. Un événement est le lien établi entre une occurrence du système, comme le clic d’un bouton, et une portion de code qui répond à cette occurrence. Le code qui répond est le gestionnaire de l’événement. Ce code modifie les valeurs des propriétés et appelle des méthodes.

Initialisez la propriété PopupMenu du composant bouton à PopupMenu1 : toutes les propriétés du menu surgissant apparaissent quand vous cliquez sur le signe plus (+).

Les références en ligne aux composants sont affichées en rouge et les sous-propriétés en vert.


E c r i t u r e d u c o d e

Pour voir les gestionnaires d’événements prédéfinis pour un composant de la fiche, sélectionnez le composant et cliquez sur l’onglet Evénements dans l’inspecteur d’objets.

Pour plus d’informations...Voir “événements” dans l’index de l’aide en ligne.

Utilisation des bibliothèques VCL et CLX

C++Builder est fourni avec deux bibliothèques de classes constituées d’objets, certains étant également des composants ou des contrôles, que vous pouvez utiliser pour écrire du code. Vous pouvez utiliser la bibliothèque de composants visuels (VCL) pour les applications Windows et la bibliothèque de composants Borland multiplate-forme (CLX) pour les applications Windows et Linux. Ces bibliothèques contiennent des objets visibles à l’exécution, comme les contrôles de saisie, les boutons et les autres éléments d’interface utilisateur, ainsi que des contrôles non visuels comme les ensembles de données ou les timers. Le diagramme suivant montre certaines des classes principales constituant la VCL. La hiérarchie CLX est similaire.

Sélectionnez un gestionnaire d’événement existant dans la liste déroulante.

Ou double-cliquez sur la colonne de la valeur pour que C++Builder génère le squelette du code d’un nouveau gestionnaire.

Ici, Button1 est sélectionné et son type est affiché : TButton. Cliquez sur l’onglet Evénements dans l’inspecteur d’objets pour voir les événements que le composant Button peut gérer.

TObject

TPersistentTStreamException

TComponent TStringsTGraphicTGraphicsObject

TControl TCommonDialogTMenuTDataSet

TWinControlTGraphicControl

TCustomControlTScrollingWinControl

TApplication

TComObject

TCollection

TField

TInterface

TCustomForm

La plupart des composants visuels dérivent de TWinControlet dans la CLX de TWidgetControl.


C o m p i l a t i o n e t d é b o g a g e d e s p r o j e t s

Les objets dérivés de TComponent possèdent les propriétés et les méthodes autorisant leur installation dans la palette de composants et leur ajout aux fiches C++Builder. Les composants de VCL et CLX étant étroitement liés à l’EDI, vous pouvez utiliser des outils comme le concepteur de fiche pour développer des applications très rapidement.

Les composants apportent un haut degré d’encapsulation. Par exemple, les boutons sont pré-programmés pour répondre aux clics de souris en déclenchant des événements OnClick. Si vous utilisez un contrôle bouton de VCL ou CLX, vous n’avez pas à écrire de code gérant les événements générés lors d’un clic sur le bouton ; vous n’êtes chargé que de la logique de l’application qui doit s’exécuter en réponse au clic lui-même.

La majorité des versions de C++Builder sont livrées avec le code source complet de la VCL et de CLX.

Pour plus d’informations...Voir “Référence de la bibliothèque de composants visuels” et “Référence CLX” dans le sommaire de l’aide et “VCL” dans l’index de l’aide en ligne.

Compilation et débogage des projetsAprès avoir écrit votre code, vous devez compiler et déboguer votre projet. Avec C++Builder, vous pouvez soit compiler votre projet en premier et le déboguer ensuite indépendamment, soit le compiler et le déboguer en une seule étape en utilisant le débogueur intégré. Pour compiler votre programme avec les informations de débogage, choisissez Projet|Options, cliquez sur la page Compilateur, cochez Informations de débogage.

C++Builder utilise un débogueur intégré grâce auquel vous pouvez contrôler l’exécution du programme, suivre les variables et modifier les valeurs des données. Vous pouvez avancer dans votre code ligne par ligne, en examinant l’état du programme à chaque point d’arrêt. Pour vous servir du débogueur intégré, choisissez Outils|Options du débogueur, cliquez sur l’onglet Général et vérifiez que la case Débogage intégré est cochée.


D é p l o i e m e n t d e s a p p l i c a t i o n s

Vous pouvez commencer une session de débogage dans l’EDI en choisissant Exécuter|Exécuter ou en appuyant sur F9.

Le débogueur intégré met à votre disposition de nombreuses fenêtres de débogage, notamment Points d’arrêt, Pile d’appels, Points de suivi, Variables locales, Threads, Modules, CPU et Journal d’événements. Affichez-les en choisissant Voir|Fenêtres de débogage. Toutes les vues du débogueur ne sont pas disponibles dans toutes les éditions de C++Builder.

Pour savoir comment combiner les fenêtres de débogage pour en faciliter l’utilisation, voir “Ancrage des fenêtres d’outils” à la page 6-2.

Lorsque vous avez défini votre bureau tel que vous voulez qu’il fonctionne pendant le débogage, vous pouvez enregistrer ces paramètres en tant que bureau de débogage ou d’exécution. Cette disposition du bureau sera utilisée chaque fois que vous déboguerez une application. Pour plus de détails, voir “Enregistrement des dispositions du bureau” à la page 6-4.

Pour plus d’informations...Voir “débogage” et “utilisation du débogueur intégré” dans l’index de l’aide.

Déploiement des applicationsVous pouvez permettre à tous d’installer et d’exécuter votre application en la déployant. Pour déployer une application, créez un paquet d’installation incluant non seulement les fichiers indispensables comme les exécutables, mais aussi tous les fichiers de support, les DLL, les fichiers paquet ou les applications complémentaires. C++Builder est fourni avec un utilitaire d’installation, InstallShield Express, qui vous permet de créer un programme d’installation avec

Bouton Exécuter

Choisissez une des commandes de débogage dans le menu Exécuter. Certaines commandes sont aussi accessibles dans la barre

Pour simplifier l’utilisation, vous pouvez combiner plusieurs fenêtres de débogage.


I n t e r n a t i o n a l i s a t i o n d ’ a p p l i c a t i o n s

ces fichiers. Pour installer InstallShield Express, dans l’écran d’installation de C++Builder, choisissez l’édition personnalisée de InstallShield Express pour C++Builder.

Pour plus d’informations...Voir “déploiement” dans l’index de l’aide en ligne.

Internationalisation d’applicationsC++Builder offre de nombreuses fonctionnalités consacrées à l’internationalisation et à la localisation des applications pour différents paramètres régionaux. L’EDI et la VCL apportent le support des éditeurs de méthodes de saisie (IME) et des jeux de caractères étendus pour internationaliser votre projet. Lorsque votre application est internationalisée, vous pouvez créer des versions localisées pour chacun des marchés étrangers où vous voulez la distribuer. Avec certaines éditions de C++Builder, vous disposez d’un environnement de traduction qui permet la localisation des logiciels et le développement simultané dans plusieurs langues. Il vous permet de gérer plusieurs versions localisées d’une application comme des parties d’un même projet.

L’environnement de traduction comprend trois outils intégrés :

• L’expert DLL ressource, un expert DLL qui génère et gère les DLL de ressources.

• Le gestionnaire de traduction, une grille pour visualiser et modifier les ressources traduites.

• Le référentiel de traduction, base de données partageable pour les traductions.

Pour ouvrir l’expert DLL ressource, choisissez Fichier|Nouveau|Autre et double-cliquez sur l’icône Expert DLL de ressources. Pour configurer les outils de traduction choisissez, Outils|Options des outils de traduction.

Pour plus d’informations...Voir “applications internationales” dans l’index de l’aide en ligne.

Types de projetsToutes les éditions de C++Builder gèrent la programmation Windows 32 bits générale et permettent d’écrire une grande variété d’applications GUI, de DLL, de paquets, de composants personnalisés, de contrôleurs COM. Certaines éditions supportent les applications serveur comme les applications serveur Web, les applications de bases de données, les serveurs COM, les applications multiniveaux, les applications CORBA et des systèmes d’aide à la décision.


T y p e s d e p r o j e t s

Pour plus d’informations...Pour connaître les outils que gèrent votre édition, voir la liste des caractéristiques à l’adresse www.borland.com.

Applications CLX

Vous pouvez utiliser C++Builder pour développer des applications 32 bits multiplates-formes fonctionnant à la fois sous Windows et sous Linux. Pour Linux, la solution Borland C++ n’est pas encore disponible, mais vous pouvez prendre les devants en développant l’application avec C++Builder aujourd’hui. Pour développer une application CLX, choisissez Fichier|Nouveau|Application CLX. L’EDI est similaire à l’environnement d’une application C++Builder normale, à cette différence que n’apparaissent dans la palette des composants et dans le référentiel d’objets que les éléments utilisables dans une application CLX. Les caractéristiques spécifiques Windows gérées par C++Builder ne sont pas portées directement dans un environnement Linux.

Pour plus d’informations...Pour connaître les composants disponibles dans les applications multiplates-formes, voir “référence CLX” dans le sommaire de l’aide.

Applications serveur Web

Une application serveur Web fonctionne avec un serveur Web en traitant les requêtes d’un client et en renvoyant un message HTTP sous la forme d’une page Web. Pour publier des données sur le Web, C++Builder propose deux technologies différentes, selon l’édition de C++Builder dont vous disposez.

La technologie d’application serveur Web la plus ancienne de C++Builder est l’agent Web (Web Broker). Les applications agent Web peuvent répartir des requêtes, effectuer des actions et renvoyer des pages Web aux utilisateurs. La plus grande partie de la logique métier d’une application est définie dans des gestionnaires d’événements écrits par le développeur de l’application. Pour créer une application serveur agent Web, choisissez Fichier|Nouveau|Autre et double-cliquez sur l’icône Application Serveur Web. Vous pouvez ajouter à votre module Web des composants des pages Internet et InternetExpress de la palette des composants.

WebSnap apporte en plus des adaptateurs, des répartiteurs et des générateurs de page supplémentaires, la gestion des sessions et des modules de page Web. Ces fonctionnalités supplémentaires ont été conçues pour gérer automatiquement les tâches courantes des applications serveur Web. Le développement WebSnap est plus simple et plus visuel que le développement Web Broker. Un développeur d’applications WebSnap peut consacrer davantage de temps à la conception de la logique métier de l’application, plutôt qu’à l’écriture de gestionnaires d’événements pour les tâches communes de transfert de pages. Pour créer une nouvelle application serveur WebSnap, choisissez Fichier|Nouveau|Autre, sélectionnez la page WebSnap et double-cliquez sur l’icône Application



WebSnap. Vous pouvez ajouter les composants de la page WebSnap de la palette des composants.

Pour plus d’informations...Voir “applications Web” dans l’index de l’aide en ligne.

Applications de bases de données

C++Builder apporte une grande variété d’outils de bases de données et de connectivité qui simplifient le développement des applications de bases de données.

Pour créer une application de bases de données, commencez par concevoir l’interface d’une fiche en utilisant les composants de page ContrôleBD. Puis, ajoutez une source de données dans un module de données en utilisant la page AccèsBD. Enfin, pour vous connecter à divers serveurs de bases de données, ajoutez un composant ensemble de données ou connexion de données au module de données depuis les pages déjà citées de la palette ou depuis celles associées aux outils de connectivité suivants :

• dbExpress est un ensemble de pilotes utilisés par des applications multiplates-formes donnant un accès rapide à des serveurs SQL comme DB2, InterBase, MySQL et Oracle. Avec un pilote dbExpress, vous pouvez accéder aux bases de données en utilisant des ensembles de données unidirectionnels.

• Le BDE (Borland Database Engine) est un ensemble de pilotes supportant de nombreux formats de bases de données parmi les plus utilisés, y compris dBASE, Paradox, FoxPro, Microsoft Access, et toute source de données ODBC. Les pilotes SQL Links, disponibles dans certaines versions de C++Builder, prennent en charge les serveurs tels qu’Oracle, Sybase, Informix, DB2, SQL Server et InterBase.

• ADO (ActiveX Data Objects) est une interface Microsoft de haut niveau pour toute source de données, dont les bases de données relationnelles ou non, les

Vous pouvez créer une application s’exécutant sur divers types de serveurs Web, y compris un serveur de test qui vous permet de déboguer votre application serveur Web.Décidez si vous souhaitez un module de données ou un module de page qui affiche votre page HTML.

Vous pouvez également accéder au module de données d’application WebSnap en choisissant Voir|Barres d’outils|Internet, et en cliquant sur l’icône Nouvelle application WebSnap.



systèmes de messagerie électronique et les systèmes de fichiers, le texte et les graphiques, ainsi que les objets de gestion personnalisés.

• Les composants InterBase Express (IBX) sont basés sur l’architecture de composants d’accès aux données personnalisés de C++Builder. Les applications IBX donnent accès aux fonctionnalités avancées d’InterBase et offrent une interface de composants ultra-performante pour InterBase 5.5 et ses versions ultérieures. IBX est compatible avec la bibliothèque C++Builder de composants orientés données.

Certains outils de connectivité aux bases de données ne sont pas proposés dans toutes les éditions de C++Builder.

Pour plus d’informations...Voir “Applications de bases de données” dans l’index de l’aide en ligne.

Administrateur BDEUtilisez l’administrateur BDE (BDEAdmin.exe) pour configurer les pilotes BDE et définir les alias employés par les contrôles orientés données de la VCL pour se connecter aux bases de données.

Pour plus d’informations...A partir du menu Démarrer de Windows, choisissez Programmes|Borland C++Builder|Administrateur BDE. Choisissez ensuite Aide|Index.

Explorateur SQL (explorateur de base de données)L’explorateur SQL (DBExplor.exe) vous permet de parcourir et de modifier les bases de données. Vous pouvez l’utiliser pour créer des alias, voir les informations de schéma, exécuter des requêtes SQL et maintenir les dictionnaires de données ou les jeux d’attributs.

Pour plus d’informations...Depuis le menu principal de C++Builder, choisissez Base de données|Explorateur pour ouvrir l’explorateur, puis appuyez sur F1. Ou recherchez “explorateur de base de données” dans l’index principal de l’aide.

Module base de donnéesLe module base de données (DBD32.exe) vous permet de créer, de voir et de modifier les tables des bases de données Paradox et dBase dans divers formats.

Pour plus d’informations...A partir du menu Démarrer de Windows. Choisissez Programmes|Borland C++Builder|Module Base de données. Puis, choisissez Aide|Guide de l’utilisateur.



Dictionnaire de donnéesLe dictionnaire de données fournit un espace de stockage personnalisable indépendant de vos applications dans lequel vous pouvez créer des jeux d’attributs de champs étendus décrivant le contenu et l’aspect des données. Le dictionnaire de données peut résider sur un serveur distant pour un partage des informations encore plus important.

Pour plus d’informations...Choisissez Aide|C++Builder et recherchez “dictionnaire des données”.

Composants personnalisés

Les composants livrés avec C++Builder sont pré-installés dans l’EDI et proposent des fonctionnalités suffisamment étendues pour répondre à la majorité des besoins de développement. Vous pourriez programmer avec C++Builder pendant des années sans avoir besoin d’installer de nouveaux composants. Mais, parfois pour résoudre certains problèmes spéciaux ou encapsuler des types de comportement très particuliers, la contribution des composants personnalisés devient nécessaire. Les composants personnalisés favorisent la réutilisation du code et la cohérence des applications.

Vous pouvez installer des composants personnalisés fournis par des tiers ou créer les vôtres. Pour créer un nouveau composant, choisissez Composant|Nouveau composant pour afficher l’expert nouveau composant. Pour installer des composants fournis par un tiers, voir “Installation de paquets de composants” à la page 6-6.

Pour plus d’informations...Voir la Partie V, “Création de composants personnalisés” dans le Guide du développeur et “composants, création” dans l’index de l’aide en ligne.

DLL

Les DLL (bibliothèques de liaison dynamique) sont des modules compilés contenant des routines pouvant être appelées par les applications et d’autres DLL. Une DLL contenant du code et des ressources partageables, elle est habituellement utilisée par plusieurs applications. Pour créer un modèle de DLL, choisissez Fichier|Nouveau|Autre et double-cliquez sur l’icône Expert DLL.

Pour plus d’informations...Voir “DLL” dans l’index de l’aide en ligne.



COM et ActiveX

C++Builder supporte le standard COM de Microsoft et offre des experts facilitant la création des contrôles ActiveX. Des exemples de contrôles ActiveX sont installés dans la page ActiveX de la palette de composants. De nombreux composants serveur COM sont proposés dans l’onglet Serveurs de la palette de composants. Vous pouvez les utiliser comme des composants de la VCL. Par exemple, vous pouvez placer un des composants Microsoft Word sur une fiche, afin d’offrir une instance de Microsoft Word à l’interface d’une application.

Pour plus d’informations...Voir “COM” et “ActiveX” dans l’index de l’aide en ligne.

Bibliothèques de typesLes bibliothèques de types sont des fichiers contenant des informations sur les types de données, les interfaces, les fonctions membres et les classes d’objets présentées dans un contrôle ou un serveur ActiveX. En incluant une bibliothèque de types à votre application COM ou votre bibliothèque ActiveX, vous mettez ces informations à la disposition d’autres applications et d’autres outils de programmation. C++Builder possède un éditeur de bibliothèques de types qui permet la création et la maintenance de celles-ci.

Pour plus d’informations...Voir “bibliothèque de types” dans l’index de l’aide en ligne.

T u t o r i e l : c r é a t i o n d ’ u n é d i t e u r d e t e x t e 4-1

C h a p i t r e

4Chapitre 4Tutoriel : création

d’un éditeur de texteCe tutoriel vous guide dans les étapes de la création d’un éditeur de texte complet avec des menus, une barre d’outils et une barre d’état.

Remarque Ce tutoriel est réalisable avec toutes les éditions de C++Builder.

Démarrage d’une nouvelle applicationAvant de démarrer une nouvelle application, créez un répertoire destiné à contenir ses fichiers source.

1 Créez un répertoire appelé TextEditor dans votre répertoire C:\Program Files\Borland\CBuilder6\Projects.

2 Commencez un nouveau projet en choisissant Fichier|Nouveau|Application ou utilisez le projet par défaut qui est déjà ouvert lorsque vous démarrez C++Builder.

Chaque application est représentée par un projet. Lorsque vous démarrez C++Builder, il ouvre par défaut un projet vide et crée automatiquement les fichiers suivants.

• Project1.cpp : le fichier de code source associé au projet. C’est ce que nous appellerons un fichier projet.

• Unit1.cpp : le fichier de code source associé à la fiche principale du projet. C’est ce que nous appellerons un fichier unité.

• Unit1.h: un fichier en-tête associé à la fiche principale du projet. C’est ce que nous appellerons fichier en-tête d’unité.

• Unit1.dfm: le fichier de ressources stockant les informations de la fiche principale du projet. C’est ce que nous appellerons un fichier fiche.


D é f i n i t i o n d e s v a l e u r s d ’ u n e p r o p r i é t é

Chaque fiche possède ses propres fichiers unité (Unit1.cpp), en-tête (Unit1.h) et fiche (Unit1.dfm). Si vous créez une deuxième fiche, une deuxième unité (Unit2.cpp), un deuxième en-tête (Unit2.h) et un deuxième fichier fiche (Unit2.dfm) sont automatiquement créés.

3 Choisissez Fichier|Tout enregistrer pour enregistrer vos fichiers sur disque. Lorsque la boîte de dialogue Enregistrer sous apparaît :

• Positionnez-vous sur votre répertoire TextEditor.

• Enregistrez Unit1 en utilisant le nom par défaut Unit1.cpp.

• Enregistrez le projet sous le nom TextEditor.bpr. (L’exécutable portera le même nom que le projet, avec l’extension .exe.)

Par la suite, vous pourrez enregistrer votre travail à tout moment en choisissant Fichier|Tout enregistrer.

Lorsque vous enregistrez votre projet, C++Builder crée des fichiers supplémentaires dans le répertoire de votre projet. Ne le supprimez pas.

Définition des valeurs d’une propriétéLorsque vous ouvrez un nouveau projet, C++Builder affiche la fiche principale du projet, appelée par défaut Form1. Vous allez créer l’interface utilisateur et les autres parties de votre application en plaçant des composants dans cette fiche.

A côté de la fiche se trouve l’inspecteur d’objets qui vous permet de modifier la valeur des propriétés de la fiche et des composants placés dedans. Lorsque vous définissez des propriétés, c’est C++Builder qui met à jour pour vous le code source. La définition des valeurs dans l’inspecteur d’objets est appelée paramétrage en mode conception.

La fiche par défaut dispose des boutons Agrandissement et Réduction, d’un bouton Fermeture et d’un menu de contrôle.Si vous exécutez à présent la fiche en appuyant sur F9, vous verrez ces boutons à l’œuvre.Pour revenir en mode conception, cliquez sur le X pour fermer la fiche.


A j o u t d e c o m p o s a n t s à l a f i c h e

1 Trouvez dans l’inspecteur d’objets la propriété Caption de la fiche et entrez Tutoriel éditeur de texte à la place du libellé par défaut Form1. Notez que l’intitulé en haut de la fiche change au fil de la saisie.

2 Même s’il n’y a pas de composants dans la fiche, exécutez l’application en appuyant sur F9.

3 Pour revenir à la vue de Form1 en conception, vous pouvez, au choix :

• Cliquer sur le X dans le coin supérieur droit de la barre de titre de votre application (la vue de la fiche à l’exécution) ;

• Cliquer sur le bouton Quitter l’application dans le coin supérieur gauche de la barre de titre et cliquer sur Fermer ;

• Choisir Voir|Fiches, sélectionner Form1 et cliquer sur OK ;

• Choisir Exécuter|Réinitialiser le programme.

Ajout de composants à la ficheAvant de commencer à ajouter des composants à la fiche, vous devez réfléchir à la meilleure manière d’organiser l’interface utilisateur de votre application. L’interface utilisateur est ce qui permet à l’utilisateur de votre application d’interagir avec elle ; elle doit donc être conçue pour simplifier l’utilisation de l’application.

C++Builder propose de nombreux composants qui représentent des éléments d’une application. Par exemple, des composants de la palette (appelés également objets) simplifient la programmation des menus, des barres d’outils, des boîtes de dialogue et de nombreux autres éléments de programme, visuels ou non visuels.

L’application éditeur de texte nécessite une zone de saisie, une barre d’état pour afficher des informations comme le nom du fichier en cours de modification, des menus et une barre d’outils avec des boutons pour simplifier l’accès aux commandes. La puissance de C++Builder pour la conception d’interface tient à ce que vous pouvez expérimenter différents composants et voir immédiatement le résultat. De cette manière, vous pouvez réaliser très vite un prototype de l’interface de l’application.

Pour commencer la conception de l’éditeur de texte, ajoutez à la fiche une zone de texte et une barre d’état.

La liste déroulante en haut de l’inspecteur d’objets indique le composant sélectionné. Dans ce cas, le composant est Form1 et son type est TForm1.

Quand un composant est sélectionné, l’inspecteur d’objets affiche ses propriétés.



1 Pour créer une zone de texte, ajoutez d’abord un composant RichEdit. Pour trouver le composant RichEdit, sur la page Win32 de la palette de composants, pointez le curseur de la souris sur une icône de la palette pendant quelques instants ; C++Builder affiche un conseil d’aide qui donne le nom du composant.

Lorsque vous avez trouvé le composant RichEdit, vous pouvez, au choix :

• Sélectionner le composant dans la palette et cliquer sur la fiche là où vous voulez le faire apparaître ;

• Double-cliquer dessus pour le placer au milieu de la fiche.

Chaque composant C++Builder est une classe ; en plaçant un composant dans la fiche, vous créez une instance de cette classe. Une fois le composant placé dans la fiche, C++Builder génère le code nécessaire à la construction d’une instance de l’objet lors de l’exécution de votre programme.

2 Le composant RichEdit étant sélectionné, cliquez dans l’inspecteur d’objets sur la flèche vers le bas de la propriété Align et choisissez la valeur alClient.

Vérifiez que le composant RichEdit1 est bien sélectionné dans la fiche.

Recherchez la propriété Align dans l’inspecteur d’objets. Cliquez sur la flèche vers le bas pour afficher la liste déroulante de la propriété.Sélectionnez alClient.



Maintenant, le composant RichEdit remplit toute la fiche et vous disposez d’une zone d’édition plus grande. En choisissant la valeur alClient pour la propriété Align, la taille du contrôle RichEdit varie pour remplir la taille dans laquelle la fenêtre est affichée, et ce même si la fiche est redimensionnée.

3 Double-cliquez sur le composant StatusBar de la page Win32 de la palette de composants, pour ajouter une barre d’état en bas de la fiche.

4 Double-cliquez sur la barre d’état pour ouvrir la boîte de dialogue Modification de StatusBar1->Panels.

Astuce Vous pouvez également ouvrir la boîte de dialogue Modification de StatusBar1->Panels en cliquant sur les points de suspension (TStatusPanel) de la propriété Panels de la barre d’état.

5 Cliquez sur le bouton Ajouter nouveau dans la barre d’outils de la boîte de dialogue ou cliquez avec le bouton droit et choisissez Ajouter, afin d’ajouter un volet à la barre d’état. Le volet affichera le nom et le chemin d’accès du fichier en cours de modification dans votre éditeur de texte.

Barre d’état

Zone de saisie

Cliquez avec le bouton droit de la souris pour afficher le menu contextuel. Choisissez Ajouter pour créer dans la barre d’état un volet qui puisse contenir du texte persistant.


A j o u t d u s u p p o r t p o u r u n m e n u e t u n e b a r r e d ’ o u t i l s

6 Dans l’inspecteur d’objets, définissez la propriété Text par sans titre.txt. Quand vous utilisez l’éditeur de texte, si le fichier en cours de modification n’a pas encore été enregistré, il est nommé sans titre.txt.

7 Cliquez sur le X pour fermer la boîte de dialogue Modification de StatusBar1->Panels.

Maintenant, la zone d’édition principale de l’interface utilisateur est définie.

Ajout du support pour un menu et une barre d’outilsPour que l’application fasse quelque chose, elle a besoin d’un menu, de commandes et, pour le confort, d’une barre d’outils. Bien que vous puissiez coder les commandes séparément, C++Builder fournit une liste d’actions ou un gestionnaire d’actions qui centralise les actions, les images et le code pour les commandes des menus et les barres d’outils.

Par convention, les actions connectées aux commandes de menu sont nommées en utilisant le nom du menu de niveau supérieur et le nom de la commande. Ainsi, l’action FichierQuitter désigne la commande Quitter du menu Fichier. Le tableau suivant énumère les commandes de menu dont a besoin votre application éditeur de texte et indique si l’action est associée à un bouton de la barre d’outils :

Tableau 4.1 Les commandes prévues pour l’éditeur de texte

Menu Commande

Dans la barre d’outils ? Description

Fichier Nouveau Oui Crée un nouveau fichier.Fichier Ouvrir Oui Ouvre un fichier existant pour le modifier.Fichier Enregistrer Oui Stocke sur disque le fichier en cours.Fichier Enregistrer

sousNon Stocke un fichier sous un nouveau nom (vous permet

également de stocker un nouveau fichier en utilisant un nom spécifié).

Fichier Quitter Oui Sort du programme éditeur.Edition Couper Oui Efface du texte et le stocke dans le Presse-papiers.Edition Copier Oui Copie du texte et le stocke dans le Presse-papiersEdition Coller Oui Insère le texte contenu dans le Presse-papiers.Aide Rubriques

d’aideNon Affiche l’écran de sommaire qui vous permet d’accéder

aux rubriques de l’aide.Aide Index Non Affiche l’écran de l’index de l’aide.Aide A propos Non Affiche dans une boîte de dialogue des informations

sur l’application.



Différences entre l’éditeur du gestionnaire d’actions et l’éditeur de liste d’actions

Selon votre édition de C++Builder, il existe deux moyens de gérer les actions et les images de vos menus et de la barre d’outils. Toutes les éditions de C++Builder proposent un éditeur de liste d’actions, qui fournit un emplacement pour centraliser les réponses des commandes utilisateur. L’éditeur de liste d’actions fait partie de la bibliothèque de composants multiplate-forme (CLX) Borland et doit être utilisée à la place de l’éditeur du gestionnaire d’actions si vous prévoyez de migrer plus tard vers une autre plate-forme (par exemple Linux).

L’éditeur du gestionnaire d’actions offre des fonctionnalités spéciales, mais n’est disponible qu’à partir de la bibliothèque de composants visuels (VCL), spécifique à la plate-forme Windows. L’utilisation du dialogue de personnalisation de l’éditeur du gestionnaire d’actions peut offrir des actions de menu personnalisables par l’utilisateur final, et possédant des propriétés de Microsoft Office (comme cacher les options de menus rarement utilisées). En outre, le gestionnaire d’actions offre un processus de développement plus rapide, car il suffit de faire glisser les actions du dialogue de personnalisation du gestionnaire d’actions vers le composant de menu se trouvant sur la fiche.

Attention Ce tutoriel utilise le dialogue de personnalisation du gestionnaire d’actions pour les éditions Entreprise et Professionnelle de C++Builder. Si vous possédez l’édition Entreprise ou Professionnelle, continuez par “Ajout d’images aux menus et à la barre d’outils (Entreprise et Professionnel)”, ci-après.

Si vous possédez l’édition Personnelle ou si vous voulez utiliser l’éditeur de liste d’actions, allez directement à “Ajout d’une liste d’images et d’images (édition Personnelle)”, page 4-15.

Ajout d’images aux menus et à la barre d’outils (Entreprise et Professionnel)

Dans cette section, vous allez ajouter des images à utiliser avec des bandes d’actions.

Dans la plupart des cas, vous voudrez ajouter un composant ImageList1 à votre fiche et importer vos propres images. Pour ce tutoriel, vous gagnerez du temps en important la liste d’images qui a été utilisée pour créer l’EDI de C++Builder. Au lieu de vos propres graphiques, le composant ImageList1 de la palette utilise des images par défaut pour les actions standard.

Pour ajouter la liste d’images existante :

1 Si vous avez installé C++Builder dans le répertoire par défaut, choisissez Fichier|Ouvrir et sélectionnez C:\Program Files\Borland\CBuilder6\Source\vcl\actnres.pas. Pour voir ce fichier, définissez le type de fichier par (Tous les fichiers *.*) dans le dialogue d’ouverture.



2 Sélectionnez le composant ImageList1, copiez-le, puis collez-le dans votre fiche. C’est un composant non visuel, peu importe où vous le collez.

Remarque Pour copier ImageList1, cliquez avec le bouton droit de la souris sur le composant et sélectionnez Edition|Copier. Dans la fiche, cliquez avec le bouton droit de la souris et sélectionnez Edition|Coller.

3 Fermez la fenêtre StandardActions.

4 Double-cliquez sur ImageList1 afin d’afficher toutes les images que vous pouvez utiliser.

Les propriétés ImageIndex des actions standard et de l’ImageList1 que nous avons ajoutées incluent :

Remarque Il est possible d’ajouter des images d’une autre liste. Voir “Ajout d’une liste d’images et d’images (édition Personnelle)”, page 4-15. Cliquez sur OK pour fermer le dialogue ImageList1.

Commande Propriété ImageIndex

Edition|Couper 0

Edition|Copier 1

Edition|Coller 2

Fichier|Nouveau 6

Fichier|Ouvrir 7

Fichier|Enregistrer 8

Fichier|Enregistrer sous 30

Fichier|Quitter 43

Aide|Rubriques d’aide 40

Les nombres sous les images correspondent à la valeur de la propriété ImageIndex de chaque action.

Vous pouvez cliquer sur le bouton Ajouter pour ajouter d’autres images.



Ajout d’actions au gestionnaire d’actions (Entreprise et Professionnel)

Les éditions Entreprise et Professionnelle proposent un gestionnaire d’actions qui facilite l’ajout d’actions aux menus et aux barres d’outils. Vous ajoutez d’abord le gestionnaire d’actions et vous ajoutez les actions ensuite.

1 Dans la page Supplément de la palette de composants, double-cliquez sur le composant ActionManager pour le déposer dans la fiche. Comme c’est un composant non-visuel, vous pouvez le placer n’importe où dans la fiche.

Astuce Pour afficher le libellé des composants placés dans une fiche, choisissez Outils|Options d’environnement, sélectionnez la page Concepteur, sélectionnez l’option Afficher les libellés des composants puis cliquez sur OK. Passer la souris au-dessus d’un composant affiche également son nom.

2 ActionManager1 étant toujours sélectionné dans la fiche, définissez sa propriété Images dans l’inspecteur d’objets par ImageList1.

Vous allez ensuite ajouter les actions au gestionnaire d’actions et définir leurs propriétés. Vous allez ajouter des actions non standard dont vous définirez toutes les propriétés ainsi que des actions standard dont les propriétés sont définies automatiquement.

3 Double-cliquez sur le composant ActionManager pour l’ouvrir.

La boîte de dialogue Modification de Form1->ActionManager1, appelée aussi éditeur du gestionnaire d’actions, apparaît.

4 Assurez-vous que l’onglet Actions est affiché. Cliquez sur le bouton flèche vers le bas à côté du bouton Nouvelle Action et sélectionnez Nouvelle Action.

Astuce Vous pouvez également cliquer avec le bouton droit de la souris dans l’éditeur du gestionnaire d’actions et choisir Nouvelle action.

Cliquez sur la propriété Images, puis sur la flèche vers le bas à côté de Images. ImageList1 apparaît. Sélectionnez-le. Cela associe les images de la liste d’images aux actions de la liste d’actions.



5 Vérifiez que pas de catégorie est sélectionnée dans la liste d’actions et que Action1 est sélectionnée sous Actions. Dans l’inspecteur d’objets, définissez les propriétés suivantes :

• Pour Caption, saisissez &Nouveau. Remarquez comment la saisie d’un caractère & avant l’une des lettres fait de cette lettre un raccourci pour accéder à la commande.

• Pour Category, saisissez Fichier (cela regroupe les commandes de fichier en un seul emplacement).

• Pour Hint, saisissez Créer un fichier (c’est le conseil d’aide).• Vérifiez que ImageIndex est définie par 6 (Cela correspond à la liste d’image

que nous avons importée. Vous pouvez aussi cliquer sur la flèche vers le bas et sélectionner l’image appropriée).

• Pour Name, entrez FichierNouveau (pour la commande Fichier|Nouveau) et appuyez sur Entrée pour enregistrer la modification.

Cliquez sur le bouton flèche vers le bas à côté du bouton Nouvelle Action pour créer une nouvelle action du gestionnaire d’actions.

Quand le bouton Supprimer est activé, vous pouvez retirer de la liste d’action des actions existantes.

Action1 étant sélectionné dans l’éditeur du gestionnaire d’actions, modifiez ses propriétés dans l’inspecteur d’objets.Caption est le nom de l’action, Category indique le type d’action, Hint est un conseil d’aide, ImageIndex permet de désigner une image de la liste d’images et Name permet de désigner l’action dans le code.



6 Vérifiez que Fichier est sélectionné dans la fenêtre Modification de Form1->ActionManager1. Cliquez sur la flèche vers le bas à côté du bouton Nouvelle Action et sélectionnez Nouvelle Action.

7 Dans l’inspecteur d’objets, définissez les propriétés suivantes :

• Après Caption, saisissez &Enregistrer.• Assurez-vous que Category est définie par Fichier.• Après Hint, saisissez Enregistrer le fichier.• Après ImageIndex, sélectionnez l’image 8.• Après Name, saisissez FichierEnregistrer (pour la commande Fichier|

Enregistrer).

8 Cliquez sur le bouton flèche vers le bas à côté du bouton Nouvelle Action et sélectionnez Nouvelle Action.


• Après Caption, saisissez &Index.• Après Category, saisissez Aide.• ImageIndex n’est pas nécessaire. Laissez la valeur par défaut.• Après Name, saisissez AideIndex (pour la commande Aide|Index).

10 Cliquez sur le bouton flèche vers le bas à côté du bouton Nouvelle Action et sélectionnez Nouvelle Action.


• Après Caption, saisissez &A propos.• Après Category, saisissez Aide.• ImageIndex n’est pas nécessaire. Laissez la valeur par défaut.• Après Name, saisissez AideApropos (pour la commande Aide|A propos).

12 Gardez à l’écran le dialogue du gestionnaire d’actions.

13 Enregistrez votre travail en cliquant sur Fichier|Tout enregistrer.

Ajout d’actions standard (Entreprise et Professionnel)

Vous allez ensuite ajouter dans le gestionnaire d’actions les actions standard (ouvrir, enregistrer sous, quitter, couper, copier, coller et rubriques d’aide).

1 L’éditeur du gestionnaire d’actions doit toujours être affiché. Si ce n’est pas le cas, double-cliquez sur le composant ActionManager pour l’ouvrir.

2 Cliquez sur la flèche vers le bas à côté du bouton Nouvelle Action et sélectionnez Nouvelle Action standard.

La boîte de dialogue Classes d’actions standard apparaît.

3 Accédez à la catégorie Edition et utilisez la touche Ctrl pour sélectionner TEditCut, TEditCopy et TEditPaste. Cliquez sur OK pour ajouter ces actions



à la nouvelle catégorie Edition dans la liste des catégories de la boîte de dialogue Modification de Form1->ActionManager1.


5 Accédez à la catégorie Fichier et sélectionnez TFileOpen, TFileSaveAs et TFileExit. Cliquez sur OK pour ajouter ces actions à la catégorie Fichier.


7 Accédez à la catégorie Aide et sélectionnez THelpContents. Cliquez sur OK pour ajouter cette action à la catégorie Aide.

Remarque La commande Aide|Rubriques d’aide personnalisée affiche un fichier d’aide montrant toujours l’onglet Sommaire de l’aide. La commande standard Aide|Rubriques d’aide ouvre le dernier onglet affiché de la page : Sommaire, Index ou Rechercher.

Vous venez d’ajouter toutes les actions standard dont a besoin votre application. Les propriétés des actions standard sont automatiquement initialisées, y compris l’indice de l’image. Vous pouvez changer l’indice de l’image afin d’afficher une autre image.

8 Si vous voulez, vous pouvez changer l’image des actions standard. Par exemple, sélectionnez l’action Fichier|Ouvrir dans le dialogue Modification de Form1->ActionManager1. Remplacez maintenant l’image par défaut par l’image 7 de la liste.

9 Choisissez le bouton Fermer pour fermer l’éditeur du gestionnaire d’actions.

10 Choisissez Fichier|Tout enregistrer pour enregistrer vos modifications.

Cliquez avec le bouton droit de la souris dans l’éditeur du gestionnaire d’actions et choisissez Nouvelle action standard.

Les actions standard disponibles sont affichées. Pour en choisir une, double-cliquez dessus, ou sélectionnez plusieurs actions et cliquez sur OK.



Ajout d’un menu (Entreprise et Professionnel)

Dans les deux sections suivantes, vous allez ajouter une barre de menus personnalisable et des bandes d’actions d’outils. La barre de menus de l’éditeur de texte contient trois menus déroulants (Fichier, Edition et Aide) ainsi que leurs commandes de menu. Avec l’éditeur du gestionnaire d’actions vous pouvez, en une seule étape, faire glisser chaque catégorie de menu et ses commandes dans la barre de menu.

1 Dans la page Supplément de la palette de composants, double-cliquez sur le composant ActionMainMenuBar pour l’ajouter à la fiche.

Une barre de menus vide apparaît en haut de la fiche.

2 Ouvrez le dialogue de personnalisation du gestionnaire d’actions s’il n’est pas déjà ouvert et sélectionnez Fichier dans la liste Catégories. Si les commandes du menu ne sont pas dans l’ordre souhaité, vous pouvez changer ce dernier en utilisant les boutons Vers le haut et Vers le bas ou les raccourcis Ctrl+↑ et Ctrl+↓.

3 Sélectionnez l’action Ouvrir et cliquez sur le bouton Vers le haut dans la barre d’outils de dialogue de personnalisation du gestionnaire d’actions afin que les commandes du menu Fichier soient dans l’ordre suivant : Nouveau, Ouvrir, Enregistrer, Enregistrer sous et Quitter.

4 Faites glisser la catégorie Fichier sur la barre de menus. Le menu Fichier et ses commandes de menu apparaissent dans la barre de menus.

Astuce Vous pouvez également positionner les commandes une fois qu’elles ont été ajoutées dans la barre des menus. Par exemple, cliquez sur Fichier dans la barre des menus afin de faire apparaître ses options, puis faites glisser Ouvrir au-dessus de Nouveau et inversement.

5 Depuis la liste Catégories du dialogue de personnalisation du gestionnaire d’actions, faites glisser Edition à droite de Fichier dans la barre de menus.

6 Depuis la liste Catégories du dialogue de personnalisation du gestionnaire d’actions, faites glisser Aide à droite de Edition dans la barre de menus.

7 Cliquez sur le menu Aide, pour voir ses options de menu. Déplacez la commande Rubriques d’aide au-dessus de la commande Index.

8 Appuyez sur Echap ou cliquez à nouveau sur le menu Aide pour le refermer.


Vous pouvez maintenant ajouter une barre d’outils pour proposer un accès plus simple aux commandes.



Ajout d’une barre d’outils (Entreprise et Professionnel)

Les actions ayant été définies dans le dialogue de personnalisation du gestionnaire d’actions, vous pouvez ajouter des actions utilisées dans les menus à une barre d’outils (une bande d’action) qui achevée ressemble à une barre d’outils Microsoft Office 2000.

1 Dans la page Supplément de la palette de composants, double-cliquez sur le composant ActionToolBar afin de l’ajouter à la fiche.

Une barre d’outils bande d’actions vide apparaît en-dessous de la barre de menus.

Astuce Vous pouvez également ajouter une barre d’outils bande d’actions dans le dialogue de personnalisation du gestionnaire d’actions, en cliquant sur l’onglet Barres d’outils et en choisissant le bouton Nouvelle.

2 Si l’éditeur du gestionnaire d’actions n’est pas affiché, ouvrez-le et sélectionnez Fichier dans la liste Catégories. Dans la liste Actions, sélectionnez Nouveau, Ouvrir, Enregistrer et Quitter et faites glisser ces éléments dans la barre d’outils. Ils apparaissent automatiquement sous la forme de boutons, chacun ayant l’image qui lui a été attribuée.

3 Dans le dialogue de personnalisation du gestionnaire d’actions, faites glisser dans la barre d’outils la catégorie Edition. Toutes les commandes d’Edition doivent apparaître dans la barre d’outils.

Remarque Si vous faites glisser par erreur une commande dans la barre d’outils, vous pouvez l’en extraire. Vous pouvez également sélectionner l’élément dans l’arborescence des objets et utiliser la touche Suppr. Vous pouvez également repositionner les boutons en les faisant glisser vers la gauche ou vers la droite.


5 Appuyez sur F9 pour compiler et exécuter le projet.

Astuce Vous pouvez également exécuter le projet en cliquant sur le bouton Exécuter de la barre d’outils ou en choisissant Exécuter|Exécuter. Quand vous exécutez le projet, C++Builder ouvre le programme dans une fenêtre d’exécution semblable à celle que vous avez conçue dans la fiche.

Le programme dispose déjà d’un grand nombre de fonctionnalités. Si vous sélectionnez du texte, les boutons Couper, Copier et Coller fonctionnent. Les menus fonctionnent tous, même si beaucoup de commandes sont grisées. Pour activer certaines commandes, vous devrez écrire des gestionnaires d’événements.

6 Pour revenir en mode conception, cliquez sur le X dans le coin supérieur droit de l’application.

Pour continuer le tutoriel, passez à “Effacement de la zone de texte (toutes éditions)”, page 4-24.



Ajout d’une liste d’images et d’images (édition Personnelle)

Dans cette section, vous allez ajouter un composant ImageList à votre fiche et ajouter des images à cette liste. Sélectionnez le composant ImageList dans la palette de composants et cliquez sur la fiche pour ajouter un composant ImageList1.

Voici les images à utiliser pour chaque commande :

Remarque Sans importation de graphiques, ImageList utilise les images par défaut des actions standard.

Pour ajouter des images à la liste d’images :

1 Double-cliquez sur le composant ImageList de la fiche afin d’afficher l’éditeur de liste d’images.

2 Cliquez sur le bouton Ajouter.

3 Dans la boîte de dialogue Ajout d’images, allez dans le répertoire buttons fourni avec le logiciel. L’emplacement par défaut est C:\Program Files\Common Files\Borland Shared\Images\Buttons.

4 Double-cliquez sur filenew.bmp.

Quand un message vous demande si vous voulez séparer le bitmap en deux icônes distinctes, répondez Oui à chaque fois. Chaque icône contient une version active et une version grisée de l’image. Vous voyez alors deux images. Supprimez l’image grisée (la seconde).

5 Ajoutez les autres images :

• Cliquez sur Ajouter. Double-cliquez sur fileopen.bmp. Supprimez l’image grisée.

• Cliquez sur Ajouter. Double-cliquez sur filesave.bmp. Supprimez l’image grisée.

• Cliquez sur Ajouter. Double-cliquez sur doorshut.bmp. Supprimez l’image grisée.

• Cliquez sur Ajouter. Double-cliquez sur cut.bmp. Supprimez l’image grisée.

Commande Nom de l’image Propriété ImageIndex

Fichier|Nouveau Filenew.bmp 0

Fichier|Ouvrir Fileopen.bmp 1

Fichier|Enregistrer Filesave.bmp 2

Fichier|Quitter Doorshut.bmp 3

Edition|Couper Cut.bmp 4

Edition|Copier Copy.bmp 5

Edition|Coller Paste.bmp 6

Aide|Rubriques d’aide Help.bmp 7



• Cliquez sur Ajouter. Double-cliquez sur copy.bmp. Supprimez l’image grisée.

• Cliquez sur Ajouter. Double-cliquez sur paste.bmp. Supprimez l’image grisée.

Astuce Vous pouvez utiliser la touche Ctrl en cliquant sur les images pour en sélectionner plusieurs. Ensuite, revenez supprimer les images grisées.

Cliquez sur OK pour fermer l’éditeur de liste d’images.

Vous avez ajouté sept images à la liste d’images ; elles sont numérotées de 0 à 6, ce qui est cohérent avec la propriété ImageIndex de chacune des actions.

Remarque Si elles sont dans le désordre, vous pouvez utiliser le glisser-déplacer pour placer les images à la bonne position dans l’éditeur de liste d’images.

Vous pouvez maintenant ajouter un menu et une barre d’outils.

Ajout d’actions à la liste d’actions (édition Personnelle)

Vous avez déjà ajouté un composant ImageList à la fiche et ajouté des images à ImageList. Dans cette section, vous allez ajouter une liste d’actions et des actions.

1 Double-cliquez sur le composant ActionList de l’onglet Standard de la palette de composants. Le composant ActionList ajouté à la fiche est un composant non visuel, donc l’endroit où vous le placez n’a pas d’importance.



2 Le composant ActionList étant toujours sélectionné dans la fiche, initialisez sa propriété Images à ImageList1.

3 Double-cliquez sur le composant ActionList pour l’ouvrir.

La boîte de dialogue Modification de Form1->ActionList1 est affichée. On l’appelle aussi éditeur de liste d’actions.

4 Cliquez avec le bouton droit de la souris dans l’éditeur de listes d’actions et choisissez Nouvelle action.

Astuce Vous pouvez aussi cliquer sur la flèche vers le bas à côté du bouton Nouvelle Action et cliquer sur Nouvelle Action.

Cliquez sur la propriété Images, puis sur la flèche vers le bas à côté de Images. ImageList1 apparaît. Sélectionnez-le. Cela associe les images que vous allez ajouter à la liste d’images aux actions de la liste d’actions.

Cliquez avec le bouton droit de la souris dans l’éditeur de listes d’actions et choisissez Nouvelle action pour créer une action dans la liste d’actions.



5 Pour Action1, définissez les propriétés suivantes dans l’inspecteur d’objets :

• Pour Caption, saisissez &Nouveau. Remarquez comment la saisie d’un caractère & avant l’une des lettres fait de cette lettre un raccourci pour accéder à la commande.

• Pour Category, saisissez Fichier (cela regroupe les commandes de fichier en un seul emplacement).

• Pour Hint, saisissez Créer un fichier (c’est le conseil d’aide).• Pour ImageIndex, sélectionnez l’image associée (image 0 si vous avez ajouté

votre liste d’images dans l’ordre écrit plus haut).• Pour Name, entrez FichierNouveau (pour la commande Fichier|Nouveau) et

appuyez sur Entrée pour enregistrer la modification.

6 Cliquez avec le bouton droit de la souris dans l’éditeur de liste d’actions et choisissez Nouvelle action.


• Après Caption, saisissez &Enregistrer.• Vérifiez que Category indique Fichier.• Après Hint, saisissez Enregistrer le fichier.• Pour ImageIndex, sélectionnez l’image associée (image 2 si vous avez ajouté

vos images dans l’ordre écrit plus haut).• Après Name, saisissez FichierEnregistrer (pour la commande Fichier|

Enregistrer).



• Après Caption, saisissez &Index.• Après Category, saisissez Aide.• ImageIndex n’est pas nécessaire. Laissez la valeur par défaut.• Après Name, saisissez AideIndex (pour la commande Aide|Index).



• Après Caption, saisissez &A propos.• Après Category, saisissez Aide.• ImageIndex n’est pas nécessaire. Laissez la valeur par défaut.• Après Name, saisissez AideApropos (pour la commande Aide|A propos).

Laissez l’éditeur de liste d’actions à l’écran.

Ajout d’actions standard à la liste d’actions (édition Personnelle)

C++Builder propose plusieurs actions standard fréquemment utilisées dans les applications. Vous allez maintenant ajouter des actions standard (Couper, Copier et Coller) à la liste d’actions.



1 L’éditeur de liste d’actions doit être encore affiché. Si ce n’est pas le cas, double-cliquez sur le composant ActionList dans la fiche.

2 Cliquez avec le bouton droit de la souris dans l’éditeur de liste d’actions et cliquez sur Nouvelle action standard.

Astuce Vous pouvez aussi cliquer sur la flèche vers le bas à côté du bouton Nouvelle Action et cliquer sur Nouvelle Action standard.

3 Dans la boîte de dialogue Classes d’actions standard, accédez à la catégorie Edition et utilisez la touche Ctrl pour sélectionner TEditCut, TEditCopy, et TEditPaste. Cliquez sur OK pour ajouter ces actions à une nouvelle catégorie Edition dans l’éditeur de liste d’actions.


5 Accédez à la catégorie Fichier et sélectionnez TFileOpen, TFileSaveAs et TFileExit. Cliquez sur OK pour ajouter ces actions à la catégorie Fichier.


7 Accédez à la catégorie Aide et sélectionnez THelpContents. Cliquez sur OK pour ajouter cette action à la catégorie Aide.

Remarque La commande Aide|Rubriques d’aide personnalisée affiche un fichier d’aide montrant toujours l’onglet Sommaire de l’aide. La commande standard Aide|Rubriques d’aide ouvre le dernier onglet affiché de la page : Sommaire, Index ou Rechercher.

Cliquez avec le bouton droit de la souris dans l’éditeur de liste d’actions et choisissez Nouvelle action standard.Les actions standard disponibles sont affichées. Pour en choisir une, double-cliquez dessus.



Les propriétés des actions standard sont automatiquement initialisées. Mais, vous devez modifier la propriété indice de l’image pour associer les actions aux images livrées avec l’édition Personnelle.

8 Dans la liste Catégories de l’éditeur de liste d’actions, choisissez (Toutes les actions).

9 Les actions standard incluent des images par défaut. Remplacez maintenant les images par défaut par les images que vous avez ajoutées précédemment. Dans la liste d’actions, sélectionnez les actions suivantes une par une et changez leur propriété ImageIndex dans l’inspecteur d’objets :

• Sélectionnez EditCut1 et définissez sa propriété ImageIndex par 4.• Sélectionnez EditCopy1 et définissez sa propriété ImageIndex par 5.• Sélectionnez EditPaste1 et définissez sa propriété ImageIndex par 6.• Sélectionnez FileOpen1 et définissez sa propriété ImageIndex par 1.• Sélectionnez FileExit1 et définissez sa propriété ImageIndex par 3.

10 Cliquez sur le X pour fermer l’éditeur de liste d’actions.


Ajout d’un menu (édition Personnelle)

Dans cette section, vous allez ajouter une barre de menu principal contenant trois menus déroulants — Fichier, Edition et Aide — et vous ajouterez des éléments à chacun d’eux en utilisant les actions de la liste d’actions.

1 Depuis la page Standard de la palette de composants, déposez un composant MainMenu dans la fiche. L’endroit où vous le positionnez n’a pas d’importance.

2 Initialisez la propriété Images du menu principal à ImageList1 afin d’associer les images aux éléments de menu.

3 Double-cliquez sur le composant MainMenu pour afficher le concepteur de menus.



4 Pour définir le premier élément du menu de niveau supérieur dans le concepteur de menus, allez dans l’inspecteur d’objets, définissez la propriété Caption par &Fichier et appuyez sur Entrée.

5 Sélectionnez l’élément vide sous la commande Fichier que vous venez de créer.

6 Dans l’inspecteur d’objets, initialisez la propriété Action à FichierNouveau. Toutes les actions de la liste d’actions apparaissent là.

• Sélectionnez l’élément en dessous de Nouveau et définissez sa propriété Action par FileOpen1.

• Sélectionnez l’élément en dessous de Ouvrir et définissez sa propriété Action par FichierEnregistrer.

• Sélectionnez l’élément en dessous de Enregistrer et définissez sa propriété Action par FileSaveAs1.

• Sélectionnez l’élément en dessous de Enregistrer sous, entrez un tiret (-) après sa propriété Caption puis appuyez sur Entrée. Cela crée une barre de séparation dans le menu.

• Sélectionnez l’élément en dessous de la barre de séparation et définissez sa propriété Action par FileExit1.

Quand vous saisissez &Fichier puis sélectionnez le concepteur de menus, la commande de niveau supérieure Fichier est prête pour que vous ajoutiez le premier élément de menu.

Quand vous sélectionnez FichierNouveau dans la liste de la propriété Action, la commande Nouveau apparaît avec le bon libellé et le bon indice d’image.



7 Ensuite, créez le menu Edition :

• Sélectionnez l’élément à droite de la commande Fichier, définissez sa propriété Caption par &Edition puis appuyez sur Entrée.

• La focalisation est maintenant sur l’élément situé sous Edition ; définissez sa propriété Action par EditCut1.

• Sélectionnez l’élément en dessous de Couper et définissez sa propriété Action par EditCopy1.

• Sélectionnez l’élément en dessous de Copier et définissez sa propriété Action par EditPaste1.

8 Créez un menu Aide :

• Sélectionnez l’élément à droite de la commande Edition, définissez sa propriété Caption par &Aide puis appuyez sur Entrée.

• Sélectionnez l’élément en dessous de Aide et définissez sa propriété Action par HelpContents.

• Sélectionnez l’élément en dessous de Rubriques d’aide et définissez sa propriété Action par AideIndex.

• Sélectionnez l’élément en dessous de Index, entrez un tiret (-) après sa propriété Caption puis appuyez sur Entrée pour créer une barre de séparation dans le menu Aide.

• Sélectionnez l’élément en dessous de la barre de séparation et définissez sa propriété Action par AideApropos.

9 Cliquez sur le X pour fermer le concepteur de menus.

10 Choisissez Fichier|Tout enregistrer.


Remarque Si vous ne voyez pas la fiche, cliquez sur Voir|Fiches, sélectionnez Form1 et cliquez sur OK.



Ajout d’une barre d’outils (édition Personnelle)

Comme vous avez défini des actions dans une liste d’actions, vous pouvez ajouter à une barre d’outils certaines des actions utilisées dans les menus.

1 Dans la page Win32 de la palette de composants, double-cliquez sur le composant ToolBar pour l’ajouter à la fiche. Une barre d’outils vide est ajoutée sous le menu principal.

2 La barre d’outils étant sélectionnée, modifiez les propriétés suivantes dans l’inspecteur d’objets :

• Initialisez sa propriété Images à ImageList1.• Initialisez la propriété Indent de la barre d’outils à 4 (cela indente l’icône de

4 pixels de la gauche de la barre d’outils).• Initialisez ShowHint à true. (Conseil : Double-cliquez sur false pour changer

la valeur en true).

3 Pour ajouter des boutons à la barre d’outils, cliquez avec le bouton droit de la souris et choisissez quatre fois Nouveau bouton.

4 Pour ajouter une barre de séparation à la barre d’outils, cliquez avec le bouton droit de la souris et choisissez Nouveau séparateur.

5 Cliquez avec le bouton droit de la souris et choisissez Nouveau bouton encore trois fois.

Remarque Ne vous inquiétez pas si les images ne sont pas encore correctes. Les images correctes seront ajoutées quand vous affecterez des actions aux boutons.

6 Attribuez des actions de la liste d’actions au premier groupe de boutons.

• Sélectionnez le premier bouton et initialisez sa propriété Action à FichierNouveau.

• Sélectionnez le second bouton et initialisez sa propriété Action à FileOpen1.

Par défaut, l’objet barre d’outils est ajouté sous les menus. Pour ajouter des boutons ou des séparateurs, sélectionnez la barre d’outils, cliquez avec le bouton droit de la souris et choisissez Nouveau bouton ou Nouveau séparateur. Puis attribuez des actions de la liste d’actions.


E f f a c e m e n t d e l a z o n e d e t e x t e ( t o u t e s é d i t i o n s )

• Sélectionnez le troisième bouton et initialisez sa propriété Action à FichierEnregistrer.

• Sélectionnez le quatrième bouton et initialisez sa propriété Action à FileExit1.

7 Attribuez des actions au second groupe de boutons.

• Sélectionnez le cinquième bouton et initialisez sa propriété Action à EditCut1.• Sélectionnez le sixième bouton et initialisez sa propriété Action à EditCopy1.• Sélectionnez le dernier bouton et initialisez sa propriété Action à EditPaste1.


9 Appuyez sur F9 pour compiler et exécuter le projet.

Remarque Vous pouvez également exécuter le projet en cliquant sur le bouton Exécuter de la barre d’outils Débogage, ou en choisissant Exécuter dans le menu Exécuter.

Quand vous exécutez le projet, C++Builder ouvre le programme dans une fenêtre d’exécution semblable à celle que vous avez conçue dans la fiche. Les menus fonctionnent tous, même si beaucoup de commandes sont grisées. Les images apparaissent à côté des éléments de menu, associées par l’indice de l’image.

Votre éditeur de texte dispose déjà d’un grand nombre de fonctionnalités. Vous pouvez saisir du texte dans la zone de saisie. Si vous sélectionnez du texte, les boutons Couper, Copier et Coller fonctionnent.

10 Cliquez sur le X dans le coin supérieur droit pour fermer l’application et revenir en mode conception de la fiche.

Effacement de la zone de texte (toutes éditions)Important La suite de ce tutoriel est réalisable avec toutes les éditions.

Quand vous exécutez votre programme, le nom RichEdit1 apparaît dans la zone de texte. Vous pouvez retirer ce texte en utilisant l’éditeur de liste de chaînes. Si vous n’effacez pas le texte maintenant, le texte sera effacé lors de l’initialisation de la fiche principale à la dernière étape.

Quand vous appuyez sur F9 pour exécuter le projet, l’interface de l’application est affichée. Les menus, la zone de texte et la barre d’état apparaissent dans la fiche.

Pour revenir en mode conception, cliquez sur le X pour fermer la fiche.


E c r i t u r e d e g e s t i o n n a i r e s d ’ é v é n e m e n t s

Pour effacer la zone de texte :

1 Dans la fiche principale, cliquez sur le composant RichEdit1.

2 Dans l’inspecteur d’objets, à droite de la propriété Lines, double-cliquez sur la valeur (TStrings) afin d’afficher l’éditeur de liste de chaînes.

3 Dans l’éditeur de liste de chaînes, sélectionnez et supprimez le texte (RichEdit1), puis cliquez sur OK.

4 Enregistrez vos modifications et exécutez à nouveau le programme.

La zone de texte est maintenant vide quand la fiche principale est affichée.

Ecriture de gestionnaires d’événementsJusque là, vous avez développé votre application sans écrire la moindre ligne de code. En utilisant l’inspecteur d’objets pour définir la valeur des propriétés au moment de la conception, vous avez pleinement bénéficié des avantages de l’environnement RAD de C++Builder. Dans cette section, vous allez écrire des fonctions appelées gestionnaires d’événements qui répondent aux saisies des utilisateurs quand l’application s’exécute. Vous connecterez les gestionnaires d’événements aux éléments des menus et de la barre d’outils, afin que l’application exécute le code du gestionnaire quand un élément est sélectionné dans votre application.

Pour les actions non standard, vous devez créer des gestionnaires d’événements. Pour les actions standard comme les commandes Fichier|Quitter ou Edition|Coller, les événements sont déjà inclus dans le code. Néanmoins, pour certaines actions standard comme la commande Fichier|Enregistrer sous, vous pouvez écrire votre propre gestionnaire d’événement pour personnaliser la commande.

Comme tous les éléments de menu et les boutons de la barre d’outils sont centralisés dans l’éditeur du gestionnaire d’actions ou dans l’éditeur de liste d’actions, c’est là que vous allez créer les gestionnaires d’événements.

Important Si vous avez l’édition Personnelle de C++Builder, utilisez le composant ActionList au lieu du composant ActionManager dans les étapes suivantes.

Création d’un gestionnaire d’événement pour la commande Nouveau

Pour créer un gestionnaire d’événement pour la commande Nouveau :

1 Choisissez Voir|Unités et sélectionnez Unit1 pour afficher le code associé à Form1.

2 Vous devez d’abord déclarer un nom de fichier qui sera utilisé dans le gestionnaire d’événement. Ajoutez une propriété personnalisée pour le nom du fichier afin de la rendre accessible globalement. Ouvrez le fichier Unit1.h en cliquant avec le bouton droit de la souris dans le fichier Unit1.cpp dans l’éditeur de code et en choisissant Ouvrir le fichier source/en-tête



(ou en cliquant sur l’onglet Unit1.h dans l’éditeur de code. Dans le fichier en-tête, recherchez la section des déclarations publiques de la classe TForm1 et après la ligne suivante

public: // Déclarations de l’utilisateur

saisissez :

AnsiString NomFichier;

Votre écran doit avoir l’aspect suivant :

3 Appuyez sur F12 pour revenir à la fiche principale.

Astuce F12 est une bascule qui vous fait aller et venir entre une fiche et le code qui lui est associé. Vous pouvez aussi choisir Voir|Fiches et choisir Form1.

4 Double-cliquez sur le composant ActionManager ou ActionList pour l’ouvrir.

5 Double-cliquez sur l’action FichierNouveau.

Astuce Vous pouvez également double-cliquer sur l’action FichierNouveau dans l’arborescence d’objets.

Cette ligne définit NomFichier comme une chaîne accessible globalement par toutes les autres méthodes.



L’éditeur de code s’ouvre avec le curseur placé dans le gestionnaire d’événement.

6 Entrez les lignes suivantes, là où le curseur est positionné dans l’éditeur de code (entre { et }) :

RichEdit1->Clear();NomFichier = "sans titre.txt";StatusBar1->Panels->Items[0]->Text = NomFichier;

Une fois terminé, le gestionnaire d’événement doit avoir l’aspect suivant :


Remarque Vous pouvez redimensionner la partie code de la fenêtre pour réduire le défilement horizontal.

Commencez par double-cliquer sur l’objet liste d’actions ou gestionnaire d’actions pour afficher l’éditeur approprié.

Puis, double-cliquez sur l’action pour créer un gestionnaire d’événement vide dans lequel vous pouvez spécifier ce qui se produit quand l’utilisateur exécute la commande

Cette ligne efface la zone de texte quand vous créez un nouveau fichier.Cette ligne appelle le nouveau fichier “sans titre.txt”.Cette ligne place le nom du fichier dans la barre d’état.



Création d’un gestionnaire d’événement pour la commande Ouvrir

Pour ouvrir un fichier dans l’éditeur de texte, vous devez utiliser une boîte de dialogue standard Windows d’ouverture de fichier. Vous avez déjà ajouté une commande standard Fichier|Ouvrir dans l’éditeur du gestionnaire d’actions ou dans l’éditeur de liste d’actions, ce qui inclut automatiquement la boîte de dialogue. Cependant, il reste à personnaliser le gestionnaire d’événement de la commande.

1 Appuyez sur F12 pour localiser la fiche principale et double-cliquez sur le composant ActionManager ou ActionList pour le mettre au premier plan.

2 Sélectionnez l’action FileOpen1.

3 Dans l’inspecteur d’objets, cliquez sur le signe plus à gauche de Dialog pour développer ses propriétés. Dialog est un composant référencé qui crée la boîte de dialogue d’ouverture. C++Builder nomme par défaut la boîte de dialogue FileOpen1->OpenDialog. Quand la méthode Execute de OpenDialog1 est appelée, elle déclenche la boîte de dialogue standard d’ouverture de fichier.

4 Définissez la propriété DefaultExt par txt.

5 Double-cliquez dans la zone de texte à côté de Filter pour afficher l’éditeur de filtres.

• Dans la première ligne de la colonne Nom de filtre, entrez Fichiers texte (*.txt). Dans la colonne Filtrer, entrez *.txt.

• Dans la deuxième ligne, entrez Tous les fichiers (*.*) dans la colonne Nom de filtre et *.* dans la colonne Filtrer.

• Cliquez sur OK.

6 Définissez Title par Ouvrir fichier. Ces mots apparaissent en haut de la boîte de dialogue d’ouverture.

7 Cliquez sur l’onglet Evénements. Double-cliquez sur la zone à droite de l’événement OnAccept afin de faire apparaître FileOpen1Accept.

L’éditeur de code s’ouvre, le curseur étant positionné dans le gestionnaire d’événement.

8 Entrez les lignes suivantes, là où le curseur est positionné (entre { et }) :

RichEdit1->Lines->LoadFromFile (FileOpen1->Dialog->FileName);

Utilisez l’éditeur de filtres pour définir les filtres des actions FileOpen1.Dialog et FileSaveAs1.Dialog.



NomFichier = FileOpen1->Dialog->FileName;StatusBar1->Panels->Items[0]->Text = NomFichier;

Astuce Vous pouvez utiliser les outils d’audit de code décrits page 2-6 pour écrire plus rapidement votre code. Par exemple, après avoir tapé la flèche (->)après RichEdit1, la boîte de dialogue d’achèvement du code apparaît. Tapez un “l” pour que Lines : TStrings; apparaisse en haut de la boîte de dialogue. Appuyez sur Entrée ou double-cliquez dessus pour l’ajouter à votre code.

Une fois terminé, le gestionnaire d’événement FileOpen doit avoir l’aspect suivant :

C’est terminé pour la commande Fichier|Ouvrir et la boîte de dialogue d’ouverture.

Création d’un gestionnaire d’événement pour la commande Enregistrer

Pour créer un gestionnaire d’événement pour la commande Enregistrer :

1 Appuyez sur F12 pour afficher la fiche et double-cliquez sur le composant ActionManager ou ActionList.

2 Double-cliquez sur l’action FichierEnregistrer.


Astuce Vous pouvez également double-cliquer sur l’action FichierEnregistrer dans l’arborescence d’objets.

3 Entrez les lignes suivantes, là où le curseur est positionné (entre { et }) :

if (NomFichier == "sans titre.txt") FileSaveAs1->Execute();

else RichEdit1->Lines->SaveToFile(NomFichier);

Ce code indique à l’éditeur de code d’afficher une boîte de dialogue Enregistrer sous si le fichier n’a pas encore de nom afin que l’utilisateur

Cette ligne insère le texte du fichier spécifié.Cette ligne initialise le nom de fichier avec la valeur spécifiée dans la boîte de dialogue d’ouverture.Cette ligne place le nom du fichier dans la barre d’état.



puisse lui attribuer un nom. Sinon, le fichier est enregistré en utilisant le nom en cours. La boîte de dialogue Enregistrer sous est définie dans le gestionnaire d’événement de la commande Enregistrer sous. FileSaveAs1BeforeExecute est le nom automatiquement généré pour la commande Enregistrer sous.


C’est terminé pour la commande Fichier|Enregistrer.

Création d’un gestionnaire d’événement pour la commande Enregistrer sous

Quand la méthode Execute de SaveDialog est appelée, elle déclenche la boîte de dialogue standard d’enregistrement de fichier, Enregistrer sous. Pour créer un gestionnaire d’événement pour la commande Enregistrer sous :

1 Appuyez sur F12 pour afficher la fiche et double-cliquez sur le composant ActionManager ou ActionList.

2 Sélectionnez l’action FileSaveAs1.

3 Dans l’inspecteur d’objets, cliquez sur l’onglet Propriétés. Cliquez sur le signe plus à gauche de Dialog pour développer ses propriétés. Dialog fait référence au composant de la boîte de dialogue Enregistrer sous et affiche ses propriétés.

4 Initialisez DefaultExt à txt.

5 Double-cliquez dans la zone de texte à côté de Filter pour afficher l’éditeur de filtres. Dans l’éditeur de filtres, spécifiez les filtres pour les types de fichiers comme dans la boîte de dialogue d’ouverture.

• Dans la première ligne de la colonne Nom de filtre, entrez Fichiers texte (*.txt). Dans la colonne Filtrer, entrez *.txt.

• Dans la deuxième ligne, entrez Tous les fichiers (*.*) dans la colonne Nom de filtre et *.* dans la colonne Filtrer.

• Cliquez sur OK.

6 Initialisez Title à Enregistrer sous.

Si le fichier n’a pas de nom, affiche la boîte de dialogue Enregistrer sous.Sinon, enregistre le fichier nommé.



7 Cliquez sur l’onglet Evénements. Double-cliquez dans la zone de texte à côté de BeforeExecute afin que l’éditeur de code s’ouvre avec le curseur dans le gestionnaire d’événement FileSaveAs1BeforeExecute.

8 A droite de la position du curseur dans l’éditeur de code, saisissez la ligne suivante :

FileSaveAs1->Dialog->InitialDir = ExtractFilePath (NomFichier);

9 L’onglet Evénements doit encore être affiché. Double-cliquez dans la zone de texte à côté de l’événement OnAccept de sorte que FileSaveAs1Accept apparaisse dans l’éditeur de code.

10 A l’endroit même où le curseur est positionné, entrez les lignes suivantes :

NomFichier = FileSaveAs1->Dialog->FileName;RichEdit1->Lines->SaveToFile(Nomfichier);StatusBar1->Panels->Items[0]->Text = NomFichier;

Une fois terminé, le gestionnaire d’événement FileSaveAs doit avoir l’aspect suivant :


12 Pour voir ce que donne l’application à ce stade, appuyez sur F9.

Le répertoire par défaut est initialisé au dernier utilisé.Cette ligne initialise la propriété NomFichier de la fiche principale à la valeur spécifiée dans la boîte de dialogue Enregistrer sous.

Cette ligne enregistre le texte dans le fichier spécifié.Cette ligne place le nom du fichier dans le volet texte de la barre d’état.

L’application en cours d’exécution ressemble beaucoup à la fiche principale en conception. Remarquez que les objets non visuels n’apparaissent pas.

Vous pouvez fermer l’application de trois manières :

Cliquez sur le X.Choisissez Fichier|Quitter.Cliquer sur le bouton Quitter l’application dans la barre d’outils.


C r é a t i o n d ’ u n f i c h i e r d ’ a i d e

Si vous obtenez un message d’erreur en bas de l’éditeur de code, double-cliquez dessus pour vous positionner là où l’erreur s’est produite dans le code. Assurez-vous que vous avez bien suivi les étapes de ce tutoriel.


Création d’un fichier d’aideC’est une bonne idée de créer un fichier d’aide qui explique à l’utilisateur comment utiliser votre application. C++Builder propose l’utilitaire Microsoft Help Workshop dans le répertoire C:\Project Files\Borland\CBuilder6\Help\Tools, qui contient des informations sur la conception et la compilation d’un fichier d’aide Windows. Dans l’application exemple éditeur de texte, les utilisateurs peuvent choisir les commandes Aide|Rubriques d’aide et Aide|Index pour accéder à un fichier d’aide en affichant soit les rubriques d’aide, soit l’index de l’aide.

Vous avez créé précédemment les actions Rubriques d’aide et Index dans le gestionnaire d’actions ou la liste d’actions pour afficher, respectivement, l’onglet Sommaire et l’onglet Index d’un fichier d’aide compilé. Il est nécessaire d’affecter des valeurs de constantes aux paramètres d’aide et de créer des gestionnaires d’événements qui affichent ce que vous voulez.

Pour utiliser les commandes d’aide, vous avez besoin de créer et de compiler un fichier d’aide Windows. La création de fichiers d’aide sort du cadre de ce tutoriel. Vous pouvez utiliser un fichier exemple rtf (TextEditor.rtf), un fichier d’aide (TextEditor.hlp) et un fichier sommaire (TextEditor.cnt) :

1 Dans l’explorateur de Windows, depuis votre répertoire C:\Program Files\Borland\CBuilder6\Help, ouvrez B6X1.zip

2 Extrayez et enregistrez les fichiers .hlp et .cnt dans le répertoire de votre éditeur de texte, par défaut C:\Program Files\Borland\CBuilder6\Projects\TextEditor.

Remarque Vous pouvez aussi utiliser dans votre projet n’importe quel fichier .hlp ou .cnt (par exemple l’un des fichiers d’aide de C++Builder et son fichier .cnt associé). Il vous suffit juste de le copier dans le répertoire de votre projet et de les renommer TextEditor.hlp et TextEditor.cnt afin que l’application puisse les trouver.

Création d’un gestionnaire d’événement pour la commande Rubriques d’aide

Pour créer un gestionnaire d’événement pour la commande Rubriques d’aide :

1 Double-cliquez sur le composant ActionManager ou ActionList.

2 Double-cliquez sur l’action HelpContents1.


C r é a t i o n d ’ u n f i c h i e r d ’ a i d e


3 Juste après la position du curseur, entrez les lignes suivantes :

const static int ONGLET_AIDE = 15;const static int SOMMAIRE_ACTIF = -3;

Application->HelpCommand(ONGLET_AIDE, SOMMAIRE_ACTIF);

Ce code définit les valeurs des constantes utilisées comme paramètres de la méthode HelpCommand. ONGLET_AIDE est initialisée à 15 pour afficher la boîte de dialogue Aide et SOMMAIRE_ACTIF à -3 pour afficher l’onglet Sommaire de l’aide.


Remarque Pour obtenir des informations sur la méthode HelpCommand, placez le curseur à côté de HelpCommand dans l’éditeur et appuyez sur F1.

C’est tout pour la commande Aide|Rubriques d’aide.

Création d’un gestionnaire d’événement pour la commande Index de l’aide

Pour créer un gestionnaire d’événement pour la commande Index de l’aide :

1 Le gestionnaire d’actions ou l’éditeur de liste d’actions doit être encore affiché. Si ce n’est pas le cas, double-cliquez sur le composant ActionManager ou ActionList dans la fiche.

2 Double-cliquez sur l’action AideIndex.


3 Juste avant la position du curseur dans l’éditeur de code, entrez les lignes suivantes :

const static int ONGLET_AIDE = 15;const static int INDEX_ACTIF = -2;Application->HelpCommand(ONGLET_AIDE, INDEX_ACTIF);

Ces lignes définissent les paramètres commande et données de la méthode HelpCommand de TApplication.Cette ligne demande l’ouverture de la boîte de dialogue d’aide en affichant l’onglet Sommaire.


C r é a t i o n d ’ u n e b o î t e d e d i a l o g u e A p r o p o s

Ce code définit les valeurs de constantes utilisées comme paramètres de la méthode HelpCommand. ONGLET_AIDE est initialisée à 15 pour afficher la boîte de dialogue Aide et INDEX_ACTIF à -2 pour afficher l’onglet Index de l’aide.


C’est tout pour la commande Aide|Index.

Création d’une boîte de dialogue A proposDe nombreuses applications proposent une boîte de dialogue A propos qui affiche des informations sur le produit : son nom, la version, un logo ou d’autres informations légales comme le copyright.

Vous avez déjà défini une commande AideApropos dans l’éditeur du gestionnaire d’actions ou de liste d’actions.

Pour créer une boîte de dialogue A propos :

1 Choisissez Fichier|Nouveau|Autre pour afficher la boîte de dialogue Nouveaux éléments.

2 Cliquez sur l’onglet Fiches et double-cliquez sur l’icône Boîte A propos.

Ces lignes définissent les paramètres commande et données de la méthode HelpCommand de TApplication.

Cette ligne demande l’ouverture de la boîte de dialogue d’aide en affichant l’onglet Index.

La boîte de dialogue Nouveaux éléments est également appelée Référentiel d’objets.Quand vous créez un élément à partir d’un élément du référentiel, vous pouvez copier, hériter ou utiliser l’élément.

Copier (pris par défaut) crée une copie de l’élément dans votre projet. Hériter signifie que les modifications faites à l’objet dans le référentiel sont héritées par l’objet dans votre projet. Utiliser signifie que les modifications faites dans l’objet de votre projet sont appliquées à l’objet du référentiel.


C r é a t i o n d ’ u n e b o î t e d e d i a l o g u e A p r o p o s

Une fiche prédéfinie pour la boîte A propos apparaît.

3 Sélectionnez la fiche elle-même (cliquez sur la grille) et dans l’inspecteur d’objets, cliquez sur l’onglet Propriétés et changez sa propriété Caption en A propos de l’éditeur de texte.

4 Cliquez à nouveau sur la fiche (remarquez qu’elle s’appelle maintenant A propos de l’éditeur de texte). Pour changer chaque valeur sur la fiche, cliquez dessus pour la mettre en évidence et tapez la nouvelle valeur.

• Changez Product Name en Editeur de texte.• Changez Version en Version 1.0.• Changez Copyright en Copyright 2002.

5 Enregistrez la fiche A propos en choisissant Fichier|Enregistrer sous et en l’enregistrant sous le nom Apropos.cpp.

Dans l’éditeur de code de C++Builder, vous devez avoir plusieurs fichiers affichés : Unit1.cpp, Unit1.h, Apropos.cpp, et ActnRes (si vous disposez de l’édition Entreprise ou Professionnelle et avez utilisé l’éditeur du gestionnaire d’actions). Vous n’avez pas besoin de l’unité ActnRes, mais vous pouvez la laisser là.

6 Cliquez sur l’onglet Unit1.cpp et positionnez-vous au début de l’éditeur de code. Dans Unit1, ajoutez une instruction include pour l’unité Apropos. Choisissez Fichier|Inclure l’en-tête d’unité, puis sélectionnez Apropos

Le référentiel d’objets contient une boîte A propos standard que vous pouvez modifier à votre guise pour décrire votre application.


A c h è v e m e n t d e l ’ a p p l i c a t i o n

et cliquez sur OK. Remarquez que #include "Apropos.h" a été ajouté au début du fichier .cpp.

7 Appuyez sur F12 pour revenir en mode conception. Double-cliquez sur le composant ActionManager ou ActionList pour l’ouvrir.

8 Double-cliquez sur l’action Aide|A propos pour créer un gestionnaire d’événement. A droite de la position du curseur dans l’éditeur de code, saisissez la ligne suivante :

AboutBox->ShowModal();

Ce code ouvre la boîte de dialogue A propos quand l’utilisateur choisit Aide|A propos. ShowModal ouvre la fiche à l’état modal. Cela signifie que l’utilisateur ne peut rien faire à l’exécution tant que la fiche n’est pas fermée.


Achèvement de l’applicationL’application est presque terminée. Il reste cependant à spécifier certains éléments dans la fiche principale. Pour achever l’application :

1 Appuyez sur F12 pour vous positionner sur la fiche principale.

2 Sélectionnez la fiche. La focalisation doit se trouver sur la fiche, pas sur l’un de ses composants. Si ce n’est pas le cas, sélectionnez Form1 TForm1 dans la liste déroulante en haut de l’inspecteur d’objets.

Quand vous créez une nouvelle fiche dans l’application, vous devez l’ajouter à la fiche principale. Choisissez Fichier|Inclure l’en-tête d’unité et sélectionnez l’en-tête à ajouter.

Cliquez sur l’onglet pour afficher le fichier associé à l’unité. Si vous ouvrez d’autres fichiers alors que vous travaillez dans un projet, l’éditeur de code affiche des onglets supplémentaires.


A c h è v e m e n t d e l ’ a p p l i c a t i o n

3 Cliquez sur l’onglet Evénements et double-cliquez sur la zone à côté de OnCreate.

4 A l’endroit même où le curseur est positionné dans l’éditeur de code, entrez les lignes suivantes :

Application->HelpFile = ExtractFilePath(Application->ExeName) + "TextEditor.hlp";NomFichier = "sans titre.txt";StatusBar1->Panels->Items[0]->Text = NomFichier;RichEdit1->Clear();

Ce code initialise l’application : il associe un fichier d’aide, initialise la valeur de NomFichier à sans titre.txt, place le nom du fichier dans la barre d’état et efface la zone de texte.


6 Appuyez sur F9 pour exécuter l’application.

Félicitations ! Vous avez fini.

Vérifiez ici que la focalisation se trouve sur la fiche principale. Si ce n’est pas le cas, sélectionnez Form1 dans la liste déroulante.

Double-cliquez ici pour créer un gestionnaire d’événement pour l’événement OnCreate de la fiche.


T u t o r i e l : c r é a t i o n d ’ u n e a p p l i c a t i o n d e b a s e d e d o n n é e s C L X 5-1

C h a p i t r e

5Chapitre 5Tutoriel : création d’une application

de base de données CLXCe tutoriel vous guide dans la création d’une application multiplate-forme vous permettant de voir et de mettre à jour la base de données exemple employee. Les applications multiplates-formes utilisent CLX, la bibliothèque de composants pour le développement multiplates-formes de Borland. Conçues pour être compilées et exécutées sur différentes plates-formes, les applications CLX nécessitent un minimum de modifications entre les ports Windows et Linux. (Voir les dernières offres de produits Borland relatives au support du compilateur multiplate-forme.)

Remarque Ce tutoriel est écrit pour les éditions du produit qui incluent les composants pour bases de données. Il définit des accès aux bases de données qui exigent des fonctionnalités non disponibles dans l’édition Personnelle. De plus, vous devez avoir installé InterBase pour effectuer ce tutoriel avec succès.

Présentation de l’architecture des bases de donnéesDe prime abord, l’architecture d’une application de base de données peut paraître compliquée, mais, l’utilisation de plusieurs composants simplifie le développement et la maintenance des applications de bases de données réelles.

Les applications de bases de données se composent de trois parties principales : l’interface utilisateur, un ensemble de composants d’accès aux données et la base de données elle-même. Dans ce tutoriel, vous allez créer une application de base de données dbExpress. Les applications relatives aux autres bases de données présentent une architecture similaire.

L’interface utilisateur contient des contrôles orientés données, comme une grille, permettant aux utilisateurs de modifier et de valider les données de la base. Les composants d’accès aux données comprennent la source de données,


C r é a t i o n d ’ u n e n o u v e l l e a p p l i c a t i o n C L X

l’ensemble de données client, le fournisseur de données, un ensemble de données unidirectionnel et un composant connexion. La source de données relie l’interface utilisateur à un ensemble de données client. L’ensemble de données client est le cœur de l’application car il contient un ensemble d’enregistrements issus de la base de données sous-jacente et placés dans un tampon en mémoire. Le fournisseur transfère les données entre l’ensemble de données client et l’ensemble de données unidirectionnel, qui lit directement les données depuis la base de données. Enfin, le composant connexion établit la connexion à la base de données. Chaque type d’ensemble de données unidirectionnel utilise un type de composant connexion différent.

Pour plus d’informations sur le développement de bases de données, voir “Conception d’applications de bases de données” dans le Guide du développeur ou dans l’aide en ligne.

Création d’une nouvelle application CLXAvant de commencer le tutoriel, créez le dossier qui contiendra les fichiers source. Puis, créez et enregistrez un nouveau projet.

1 Créez un dossier appelé Tutoriel pour contenir les fichiers du projet que vous allez créer pendant votre travail au cours de ce tutoriel.

2 Commencez un nouveau projet CLX. Pour créer un nouveau projet multiplate-forme, choisissez Fichier|Nouveau|Application CLX.

3 Choisissez Fichier|Tout enregistrer pour enregistrer sur disque vos fichiers. Lorsque le dialogue d’enregistrement apparaît, naviguez jusqu’à votre dossier Tutoriel et enregistrez chaque fichier en utilisant le nom par défaut.


I n s t a l l a t i o n d e s c o m p o s a n t s d ’ a c c è s a u x d o n n é e s

Par la suite, vous pourrez enregistrer votre travail à tout moment en choisissant Fichier|Tout enregistrer. Si vous décidez de ne pas terminer le tutoriel en une fois, vous pourrez ouvrir la version enregistrée en choisissant Fichier|Réouvrir et en sélectionnant le tutoriel dans la liste.

Installation des composants d’accès aux donnéesLes composants d’accès aux données représentent à la fois les données (ensembles de données) et les composants qui connectent ces ensembles de données aux autres parties de votre application. Chacun de ces composants d’accès aux données pointe sur le composant immédiatement inférieur. Par exemple, la source de données pointe sur l’ensemble de données client, l’ensemble de données client pointe sur le fournisseur, et ainsi de suite. Donc, quand vous installez vos composants d’accès aux données, ajoutez-les dans l’ordre approprié.

Dans les sections suivantes, vous allez ajouter les composants de bases de données pour créer la connexion à la base, l’ensemble de données unidirectionnel, le fournisseur, l’ensemble de données client et la source de données. Ensuite, vous créerez l’interface utilisateur de l’application. Ces composants se trouvent sur les pages dbExpress, AccèsBD et ContrôleBD de la palette de composants.

Astuce Il est conseillé d’isoler l’interface utilisateur sur une fiche indépendante et de placer les composants d’accès aux données dans un module de données. Mais, pour simplifier ce tutoriel, vous placerez l’interface utilisateur et tous les composants sur la même fiche.

Installation de la connexion à la base de données

La page dbExpress contient un ensemble de composants qui permettent d’accéder rapidement aux serveurs de base de données SQL.

Vous devez ajouter un composant connexion qui vous permettra de vous connecter à une base de données. Le type du composant connexion dépendra du type de composant ensemble de données utilisé. Dans ce tutoriel, vous utiliserez les composants TSQLConnection et TSQLDataSet.

Pour ajouter un composant de connexion dbExpress :

1 Cliquez sur la page dbExpress de la palette des composants et double-cliquez sur le composant TSQLConnection pour le placer sur la fiche. Pour trouver le composant TSQLConnection, pointez sur chaque icône de la palette pendant un moment ; un conseil d’aide vous montrera le nom de chaque composant. Le composant est nommé SQLConnection1 par défaut.

Le composant TSQLConnection n’étant pas visuel, l’endroit où vous le placez n’a pas d’importance. Mais pour ce tutoriel, le plus simple est d’aligner les composants non visuels en haut de la fiche.



Astuce Pour afficher les libellés des composants que vous placez sur une fiche, choisissez Outils|Options d’environnement et cliquez sur Afficher les libellés des composants.

2 Dans l’inspecteur d’objets, définissez sa propriété ConnectionName par IBLocal (ce terme apparaît dans la liste déroulante).

3 Initialisez la propriété LoginPrompt à false. (Définir cette propriété par false évite une demande de connexion à chacun de vos accès à la base.)

4 Double-cliquez sur le composant TSQLConnection pour afficher l’éditeur de connexion.

Vous utiliserez l’éditeur de connexion afin de sélectionner une configuration de connexion pour le composant TSQLConnection ou pour modifier les connexions stockées dans le fichier dbxconnections.ini. Toutes les modifications effectuées dans le dialogue sont écrites dans ce fichier lorsque vous cliquez sur OK. De plus, lorsque vous cliquez sur OK, la connexion sélectionnée est attribuée comme valeur à la propriété ConnectionName du composant connexion SQL.

5 Dans l’éditeur de connexion, spécifiez le chemin d’accès sur votre système au fichier base de données employee.gdb. Dans ce tutoriel, vous vous connecterez à une base de données exemple InterBase, employee.gdb, fournie avec C++Builder. Par défaut, l’installation d’InterBase place employee.gdb dans C:\Program Files\Common Files\Borland Shared\Data.

6 Vérifiez que les champs Nom d’utilisateur et Mot de passe contiennent des valeurs acceptables. Si vous n’avez pas modifié les valeurs par défaut, vous n’avez pas besoin de modifier ces champs. Si l’accès à la base de données est sous le contrôle d’un autre administrateur, vous risquez d’avoir besoin d’un nom d’utilisateur et d’un mot de passe par avoir accès à la base de données.

7 Lorsque vous avez fini de vérifier et de modifier les champs, cliquez sur OK pour fermer l’éditeur de connexion et enregistrer vos modifications.



Ces modifications sont écrites dans le fichier dbxconnections.ini et la connexion sélectionnée est attribuée comme valeur à la propriété ConnectionName du composant connexion SQL.

Astuce Si vous avez besoin d’une assistance particulière lorsque vous utilisez l’éditeur de connexion, cliquez sur le bouton Aide.

8 Choisissez Fichier|Tout enregistrer pour enregistrer votre projet.

Installation de l’ensemble de données unidirectionnel

Une application de base de données type utilise un ensemble de données pour accéder aux informations de la base. Dans les applications dbExpress, on utilise un ensemble de données unidirectionnel. Un ensemble de données unidirectionnel lit les données de la base mais ne les met pas à jour.

Pour ajouter l’ensemble de données unidirectionnel :

1 A partir de l’onglet dbExpress, placez un TSQLDataSet en haut de la fiche.

2 Dans l’inspecteur d’objets, définissez sa propriété SQLConnection par SQLConnection1 (la connexion de base de données créée précédemment).

3 Définissez CommandText par “select * from SALES” pour spécifier la commande exécutée par l’ensemble de données. Vous pouvez soit taper l’instruction Select dans l’inspecteur d’objets, soit cliquer sur les points de suspension à droite de CommandText pour afficher l’éditeur de CommandText, dans lequel vous pouvez construire votre propre instruction de requête.

Astuce Si vous avez besoin d’une assistance particulière lorsque vous utilisez l’éditeur de CommandText, cliquez sur le bouton Aide.

4 Définissez Active par true pour ouvrir l’ensemble de données.

5 Choisissez Fichier|Tout enregistrer pour enregistrer le projet.

Installation du fournisseur, de l’ensemble de données client et de la source de données

La page AccèsBD contient des composants pouvant être utilisés avec n’importe quel mécanisme d’accès aux données, et pas seulement avec dbExpress.

Les composants fournisseur sont pour les ensembles de données client le moyen d’obtenir leurs données en provenance des autres ensembles de données. Le fournisseur reçoit les demandes de données issues de l’ensemble de données client, lit les données, crée des paquets de données et les renvoie à l’ensemble de données client. Si vous utilisez dbExpress, le fournisseur reçoit les mises à jour d’un ensemble de données client et les applique au serveur de la base de données.


C o n c e p t i o n d e l ’ i n t e r f a c e u t i l i s a t e u r

Pour ajouter le fournisseur :

1 A partir de la page AccèsBD, déposez un composant TDataSetProvider en haut de la fiche.

2 Dans l’inspecteur d’objets, définissez la propriété DataSet du fournisseur par SQLDataSet1.

L’ensemble de données client met ses données en mémoire tampon. Il met également en mémoire cache les mises à jour à envoyer à la base de données. Vous pouvez utiliser les ensembles de données client pour fournir des données aux contrôles orientés données de l’interface utilisateur à l’aide du composant source de données.

Pour ajouter l’ensemble de données client :

1 A partir de la page AccèsBD, déposez un composant TClientDataSet à droite du composant TDataSetProvider.

2 Définissez la propriété ProviderName par DataSetProvider1.

3 Définissez la propriété Active par true pour permettre la transmission des données à votre application.

Une source de données se connecte à l’ensemble de données client par des contrôles orientés données. Chaque contrôle orienté données doit être associé à un composant source de données afin de pouvoir afficher et manipuler des données. De même, tous les ensembles de données doivent être associés à un composant source de données afin que leurs données puissent être affichées et manipulées dans les contrôles orientés données d’une fiche.

Pour ajouter la source de données :

1 A partir de la page AccèsBD, déposez un composant TDataSource à droite du composant TClientDataSet.

2 Définissez la propriété DataSet de la source de données par ClientDataSet1.


Jusqu’ici vous avez ajouté à votre application son infrastructure de base de données non visuelle. Maintenant, vous devez concevoir son interface utilisateur.

Conception de l’interface utilisateurVous devez maintenant ajouter les contrôles visuels de l’application afin que les utilisateurs puissent voir, modifier et enregistrer les données. La page ContrôleBD fournit un jeu de contrôles orientés données qui fonctionnent avec les données d’une base et construisent une interface utilisateur. Vous allez afficher la base de données dans une grille et ajouter quelques commandes et une barre de navigation.



Création de la grille et de la barre de navigation

Pour créer l’interface de l’application :

1 Vous pouvez commencer par ajouter une grille à la fiche. A partir de la page ContrôleBD, déposez un composant TDBGrid sur la fiche.

2 Définissez les propriétés de DBGrid afin d’ancrer la grille. Cliquez sur le signe + proche de Anchors dans l’inspecteur d’objets afin d’afficher akLeft, akTop, akRight et akBottom ; définissez-les tous par true. La façon la plus simple est de double-cliquer sur false en face de chaque propriété dans l’inspecteur d’objets.

3 Alignez la grille et le bas de la fiche en définissant la propriété Align par alBottom. Vous pouvez aussi augmenter la taille de la grille en la faisant glisser ou en définissant sa propriété Height par 400.

4 Définissez la propriété DataSource de la grille par DataSource1. Lorsque vous faites cela, la grille se remplit de données issues de la base de données employee. Si la grille n’affiche pas de données, vérifiez que vous avez correctement défini les propriétés de tous les objets présents sur la fiche, comme expliqué par les instructions précédentes.

A ce stade, votre application doit ressembler à ceci :

Le contrôle DBGrid affiche les données en mode conception, pendant que vous travaillez dans l’EDI. Cela vous permet de vérifier que vous êtes bien connecté à la base de données. Vous ne pouvez pas, cependant, modifier les données pendant les phases de conception ; pour modifier les données de la table, vous devez exécuter l’application.

5 A partir de la page ContrôleBD, placez un contrôle TDBNavigator sur la fiche. Un navigateur dans une base de données est l’outil assurant le déplacement dans les données d’un ensemble de données (en utilisant les flèches suivante



et précédente, par exemple), comme l’exécution des diverses opérations sur les données.

6 Définissez la propriété DataSource de la barre de navigation par DataSource1 de façon à ce que le navigateur recherche les données dans l’ensemble de données client.

7 Définissez la propriété ShowHint de la barre de navigation par true. (Définir ShowHint par true permet de faire apparaître les conseils lorsque, au cours de l’exécution, le curseur est positionné sur n’importe lequel des éléments de la barre de navigation.)


9 Appuyez sur F9 pour compiler et exécuter le projet. Vous pouvez également exécuter le projet en cliquant sur le bouton Exécuter dans la barre d’outils du débogueur, ou en choisissant Exécuter dans le menu Exécuter.

Lorsque vous exécutez votre projet, le programme s’ouvre dans une fenêtre semblable à celle que vous avez dessinée sur la fiche. Vous pouvez tester la barre de navigation sur la base de données employee. Par exemple, vous pouvez aller d’enregistrement en enregistrement en utilisant les commandes fléchées, ajouter des enregistrements en utilisant la commande +, supprimer des enregistrements en utilisant la commande -.

Astuce Si une erreur se produit lorsque vous testez une version initiale de votre application, choisissez Exécuter|Réinitialiser le programme pour revenir à la vue conception.

Ajout du support pour un menu

Bien que votre programme possède un certain nombre de fonctionnalités, il lui manque encore la majorité des fonctions habituellement disponibles dans les applications à interface utilisateur graphique. Par exemple, la plupart des applications implémentent des menus et des boutons pour faciliter leur utilisation.



Dans cette section, vous allez ajouter une liste d’actions. Bien qu’il soit tout à fait possible de créer menus, barres d’outils et boutons sans liste d’actions, celles-ci simplifient le développement et la maintenance en centralisant les réponses aux commandes de l’utilisateur. (Notez que dans le cadre du développement pour Windows uniquement, vous pouvez aussi utiliser les bandes d’actions pour faciliter la création des barres d’outils et des menus.)

1 Si l’application s’exécute toujours, cliquez sur le X dans le coin supérieur droit, pour la fermer et revenir à la vue conception de la fiche.

2 A partir de la page Contrôles communs de la palette de composants, déposez un composant ImageList sur la fiche. Alignez-le à côté des composants non visuels. ImageList contiendra des icônes représentant des actions standard comme couper et coller.

3 A partir de la page Standard de la palette de composants, déposez un composant ActionList sur la fiche. Définissez la propriété Images de la liste d’actions par ImageList1.

4 Double-cliquez sur la liste d’actions pour afficher l’éditeur de liste d’actions.

5 Cliquez avec le bouton droit de la souris dans l’éditeur de liste d’actions et choisissez Nouvelle action standard. La boîte liste Actions standard apparaît.

6 Sélectionnez les actions suivantes : TEditCopy, TEditCut et TEditPaste. (Utilisez la touche Ctrl pour sélectionner plusieurs éléments.) Cliquez ensuite sur OK.

7 Cliquez avec le bouton droit de la souris dans l’éditeur de liste d’actions et choisissez Nouvelle action pour ajouter une action qui n’est pas fournie par défaut. Action1 est ajoutée par défaut. Dans l’inspecteur d’objets, définissez sa propriété Caption par Mise à jour immédiate !

La même action sera utilisée par un menu et un bouton. Par la suite, nous ajouterons un gestionnaire d’événement qui mettra à jour la base de données.

Cliquez avec le bouton droit de la souris dans l’éditeur et choisissez Nouvelle action standard pour afficher la boîte liste Actions standard.Sélectionnez les actions que vous voulez et cliquez sur OK. Appuyez sur Ctrl pour sélectionner plusieurs actions.

Vous avez ajouté des actions standard livrées avec le produit.Vous les utiliserez sur un menu.



8 Cliquez sur (pas de catégorie), cliquez avec le bouton droit de la souris et choisissez Nouvelle action pour ajouter une autre action. Action2 est ajoutée. Définissez sa propriété Caption par &Quitter.

9 Cliquez sur le X (dans le coin supérieur droit) pour fermer l’éditeur de liste d’actions.

Vous avez ajouté trois actions standard plus deux autres actions que nous connecterons plus tard à des gestionnaires d’événements.


Ajout d’un menu

Dans cette section, vous allez ajouter une barre de menu principal contenant deux menus déroulants — Fichier et Edition — et vous ajouterez des éléments à chacun d’eux en utilisant les actions de la liste d’actions.

1 A partir de la page Standard de la palette de composants, déposez un composant TMainMenu sur la fiche. Faites-le glisser à côté des autres composants non visuels.

2 Définissez la propriété Images du menu principal par ImageList1 afin d’associer la liste d’images aux éléments des menus.

3 Double-cliquez sur le composant menu pour afficher le concepteur de menus.

4 Tapez &Fichier pour définir la propriété Caption du premier élément de niveau supérieur et appuyez sur Entrée.

Quand vous tapez &Fichier et appuyez sur Entrée, la commande Fichier de niveau supérieur apparaît, prête pour l’ajout du premier élément de menu.Le et commercial avant un caractère active une touche accélératrice.



5 Sélectionnez l’élément de menu vierge sous le menu Fichier. Définissez la propriété Action de l’élément de menu vierge par Action2. L’élément de menu Quitter apparaît sous le menu Fichier.

6 Cliquez sur le deuxième élément de menu de niveau supérieur (à droite de Fichier). Définissez sa propriété Caption par &Edition et appuyez sur Entrée. Sélectionnez l’élément de menu vierge qui apparaît sous le menu Edition.

7 Dans l’inspecteur d’objets, définissez sa propriété Action par EditCut1 et appuyez sur Entrée. Le libellé de l’élément est défini automatiquement par Couper et le bitmap couper par défaut apparaît sur le menu.

8 Sélectionnez l’élément de menu vierge suivant (sous Couper) et définissez sa propriété Action par EditCopy1 (le bitmap copier par défaut apparaît sur le menu).

9 Sélectionnez l’élément de menu vierge suivant (sous Copier) et définissez sa propriété Action par EditPaste1 (le bitmap coller par défaut apparaît sur le menu).

10 Sélectionnez l’élément de menu vierge suivant (sous Coller) et définissez sa propriété Caption par un tiret (-) afin de créer une ligne de séparation dans le menu. Appuyez sur Entrée.

11 Sélectionnez l’élément de menu vierge suivant (sous la ligne de séparation ) et définissez sa propriété Action par Action1. L’élément de menu affiche Mise à jour immédiate !

12 Cliquez sur le X pour fermer le concepteur de menus.


14 Appuyez sur F9 ou sur Exécuter dans la barre d’outils pour exécuter votre programme et voir à quoi il ressemble.

Plusieurs commandes du menu Edition et la barre de navigation sont désormais opérationnelles. Couper et Copier seront estompées dans le menu Edition tant que vous ne sélectionnerez pas du texte dans la base de données. Vous pouvez


A f f i c h a g e d ’ u n t i t r e e t d ’ u n e i m a g e

utiliser la barre de navigation pour aller d’enregistrement en enregistrement dans la base, insérer un enregistrement ou supprimer un enregistrement. La commande Mise à jour ne fonctionne pas encore.

Fermez l’application lorsque vous êtes prêt à poursuivre.

Ajout d’un bouton

Cette section décrit comment ajouter à l’application un bouton Mise à jour immédiate. Ce bouton servira à appliquer toutes les modifications apportées par un utilisateur à la base de données, comme la modification, l’ajout ou la suppression d’enregistrements.

Pour ajouter un bouton :

1 A partir de la page Standard de la palette de composants, déposez un composant TButton sur la fiche. (Sélectionnez le composant et cliquez sur la fiche à proximité de la barre de navigation.)

2 Définissez la propriété Action du bouton par Action1.

L’intitulé du bouton est modifié en Mise à jour immédiate ! Lorsque vous exécuterez l’application, il restera estompé tant qu’un gestionnaire d’événement ne sera pas ajouté pour le faire fonctionner.

Affichage d’un titre et d’une imageVous pouvez ajouter le nom de votre société et une image pour donner à votre application un aspect plus professionnel :

1 A partir de la page Standard de la palette de composants, déposez un composant TLabel sur la fiche (nommé Label1 par défaut).

2 Dans l’inspecteur d’objets, modifiez la propriété Caption du libellé par World Corp ou un autre nom de société.

3 Changez la police du nom de la société en cliquant sur le propriété Font. Cliquez sur les points de suspension qui apparaissent à droite et, dans la boîte de dialogue des fontes, définissez la police par Helvetica Gras, 16 points. Cliquez sur OK.


A f f i c h a g e d ’ u n t i t r e e t d ’ u n e i m a g e

4 Positionnez le libellé dans le coin supérieur droit.

5 A partir de la page Supplément de la palette de composants, déposez un composant TImage à proximité du libellé (nommé Image1 par défaut).

6 Pour ajouter une image au composant Image1, cliquez sur la propriété Picture. Cliquez sur les points de suspension pour afficher l’éditeur d’images.

7 Dans l’éditeur d’images, choisissez Charger et naviguez jusqu’au fichier earth.ico (pour C++Builder, le chemin d’accès est Program Files\Common Files\Borland Shared\images\icons\earth.ico).

8 Double-cliquez sur earth.ico. Cliquez sur OK pour charger l’image et fermer l’éditeur d’images.

9 Donnez à la zone image par défaut la taille de l’image. Placez l’image près du libellé.

10 Pour aligner texte et image, sélectionnez les deux objets sur la fiche, cliquez avec le bouton droit et choisissez Aligner. Dans la boîte de dialogue Alignement, cliquez sur Bas, sous Vertical.


12 Appuyez sur F9 pour compiler et exécuter votre application.

Fermez l’application lorsque vous êtes prêt à poursuivre.

Vous pouvez changer la police du libellé en utilisant la propriété Font dans l’inspecteur d’objets. Cliquez sur les points de suspension pour afficher le dialogue standard des fontes.

Vous pouvez faire glisser le bord pour définir la largeur de Image, ou définir sa propriété Width dans l’inspecteur d’objets.


E c r i t u r e d ’ u n g e s t i o n n a i r e d ’ é v é n e m e n t s

Ecriture d’un gestionnaire d’événementsLa majorité des composants de la palette possèdent des événements, et beaucoup ont un événement par défaut. OnClick est un événement par défaut commun, qui est appelé chaque fois que l’on clique sur un composant, par exemple sur un TButton. Si vous sélectionnez un composant dans une fiche et cliquez sur l’onglet Evénements de l’inspecteur d’objets, vous verrez la liste des événements de ce composant.

Pour plus d’informations sur les événements et sur les gestionnaires d’événements, voir “Développement de l’interface utilisateur d’une application” dans le Guide du développeur ou dans l’aide en ligne.

Ecriture d’un gestionnaire d’événement pour la commande Mise à jour immédiate !

D’abord, vous allez écrire le gestionnaire d’événement pour la commande et le bouton Mise à jour immédiate ! :

1 Double-cliquez sur le composant ActionList pour afficher l’éditeur de liste d’actions.

2 Sélectionnez (pas de catégorie) pour voir Action1 et Action2.

3 Double-cliquez sur Action1. Dans l’éditeur de code, le squelette du gestionnaire d’événement apparaît :

void __fastcall TForm1::Action1Execute(TObject *Sender){

}

Exactement à la position du curseur (entre les accolades), tapez :

if(ClientDataSet1->State == dsEdit || ClientDataSet1->State == dsInsert) ClientDataSet1->Post();

ClientDataSet1->ApplyUpdates(-1);

Ce gestionnaire d’événement teste d’abord l’état dans lequel se trouve la base de données. Lorsque vous quittez un enregistrement modifié, celui-ci est automatiquement posté. Mais, si vous ne quittez pas l’enregistrement modifié, la base reste en mode édition ou en mode insertion. L’instruction if poste toute donnée éventuellement modifiée mais non transmise à l’ensemble de données client. L’instruction suivante applique à la base les mises à jour contenues dans l’ensemble de données client.

Remarque Les modifications apportées aux données ne sont pas automatiquement postées dans la base lorsque vous utilisez dbExpress. Il vous faut appeler la méthode ApplyUpdates pour écrire tous les enregistrements modifiés, insérés ou supprimés, depuis l’ensemble de données client vers la base de données.



Ecriture d’un gestionnaire d’événement pour la commande Quitter

Ensuite, nous allons écrire le gestionnaire d’événement pour la commande Quitter :

1 Double-cliquez sur le composant ActionList pour afficher l’éditeur de liste d’actions si ce n’est déjà fait.

2 Cliquez sur (pas de catégorie) pour voir Action2.

3 Double-cliquez sur Action2. L’éditeur de code affiche le squelette du gestionnaire d’événement :

void __fastcall TForm1::Action2Execute(TObject *Sender){

}


Close();

Ce gestionnaire d’événement fermera l’application lorsque la commande Fichier|Quitter du menu sera utilisée.

4 Fermez l’éditeur de liste d’actions.


Ecriture d’un gestionnaire d’événement pour fermer la fiche

Enfin, vous allez écrire un autre gestionnaire d’événement qui sera invoqué lorsque l’application se ferme. L’application peut être fermée soit en utilisant Fichier|Quitter, soit en cliquant sur le X du coin supérieur droit. De toute façon, le programme vérifie s’il y a des mises à jour en attente par rapport à la base de données et affiche éventuellement une fenêtre de message demandant à l’utilisateur ce qu’il souhaite en faire.

Vous pourriez placer ce code dans le gestionnaire de l’événement Quitter, mais les éventuelles modifications de la base seraient perdues dans les cas où l’utilisateur aurait choisi de fermer l’application avec le X.

1 Cliquez sur la fiche (et non sur un des objets qu’elle contient) pour la sélectionner.

2 Sélectionnez l’onglet Evénements de l’inspecteur d’objets pour voir les événements de la fiche.

3 Double-cliquez sur OnClose (ou tapez FormClose à côté de l’événement OnClose et cliquez dessus). Le squelette d’un gestionnaire de l’événement FormClose est écrit et affiché dans l’éditeur de code à la suite des autres gestionnaires d’événements.

void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action){}




TMessageButton Option; TMessageButtons msgButtons;

msgButtons << smbYes << smbNo << smbCancel;

Action = caFree; if(ClientDataSet1->State == dsEdit || ClientDataSet1->State == dsInsert) ClientDataSet1->Post(); if(ClientDataSet1->ChangeCount > 0) {

Option = Application->MessageBox("Il y a des mises à jour en attente. Voulez-vous les écrire dans la base ?", "Mises à jour en attente", msgButtons, smsWarning, smbYes, smbNo); if(Option == smbYes) ClientDataSet1->ApplyUpdates(-1); else if(Option == smbCancel) Action = caNone; }

Ce gestionnaire d’événement teste l’état de la base de données. Si des mises à jour sont en attente, elles sont postées dans l’ensemble de données client où le compteur de modifications est incrémenté. Puis, avant la fermeture de l’application, une boîte de message est affichée pour demander comment gérer ces modifications. Les réponses possibles sont Oui, Non ou Annuler. Répondre Oui applique les mises à jour à la base ; Non ferme l’application sans modifier la base ; Annuler annule la sortie sans annuler les modifications de la base de données et conserve l’application en exécution.

4 Vérifiez que l’ensemble de la procédure ressemble à ce qui suit :

void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action){

TMessageButton Option; TMessageButtons msgButtons;

msgButtons << smbYes << smbNo << smbCancel;

Action = caFree; if(ClientDataSet1->State == dsEdit || ClientDataSet1->State == dsInsert) ClientDataSet1->Post(); if(ClientDataSet1->ChangeCount > 0) {

Option = Application->MessageBox("Il y a des mises à jour en attente. Voulez-vous les écrire dans la base ?", "Mises à jour en attente", msgButtons, smsWarning, smbYes, smbNo); if(Option == smbYes) ClientDataSet1->ApplyUpdates(-1); else if(Option == smbCancel) Action = caNone; }}



5 Pour finir, choisissez Fichier|Tout enregistrer pour enregistrer le projet. Puis, appuyez sur F9 pour exécuter l’application.

Astuce Corrigez les erreurs en double-cliquant sur le message correspondant pour aller à la ligne de code concernée ou en appuyant sur F1 pour obtenir de l’aide sur le message.

Et voilà ! Vous pouvez essayer l’application et observer son fonctionnement. Lorsque vous voulez quitter le programme, vous pouvez utiliser la commande Fichier|Quitter désormais totalement fonctionnelle.



C h a p i t r e

6Chapitre 6Personnalisation du bureau

Ce chapitre explique quelques-unes des méthodes permettant de personnaliser l’EDI de C++Builder.

Organisation de votre espace de travailL’EDI dispose de nombreux outils supportant le développement, Avec autant d’outils, il est nécessaire d’organiser son espace de travail afin de travailler de la manière la plus efficace, notamment en agençant les menus et les barres d’outils, en combinant les fenêtres d’outils et en enregistrant le nouvel aspect du bureau.

Agencement des menus et des barres d’outils

Dans la fenêtre principale, vous pouvez réorganiser le menu, les barres d’outils et la palette de composants en cliquant sur la poignée située à leur gauche et en les faisant glisser jusqu’à un autre emplacement.

Fenêtre principale dans l’agencement par défaut.

Vous pouvez déplacer barres d’outils et menus au sein de la fenêtre principale. Cliquez sur la poignée (la double barre située à gauche) et faites-la glisser jusqu’à l’endroit voulu.

Fenêtre principale organisée différemment.


O r g a n i s a t i o n d e v o t r e e s p a c e d e t r a v a i l

Vous pouvez séparer des éléments de la fenêtre principale et les placer ailleurs sur l’écran ou les supprimer complètement du bureau. C’est utile lorsque vous avez une double configuration de moniteur.

Vous pouvez ajouter des outils aux barres d’outils, ou en supprimer, en choisissant Voir|Barres d’outils|Personnaliser. Cliquez sur la page Commandes, sélectionnez une catégorie, sélectionnez une commande et faites la glisser dans la barre d’outils où vous voulez la voir apparaître.

Pour plus d’informations...Voir “barres d’outils, personnaliser” dans l’index de l’aide en ligne.

Ancrage des fenêtres d’outils

Vous pouvez ouvrir et fermer les fenêtres d’outils individuellement et les agencer sur le bureau à votre convenance. Nombre d’entre elles peuvent également être ancrées à une autre pour faciliter leur manipulation. L’ancrage (qui signifie soit attacher les fenêtres les unes aux autres afin qu’elles se déplacent ensemble, soit combiner plusieurs fenêtres en un “classeur” à onglets unique) vous permet de gérer l’espace de l’écran avec efficacité tout en bénéficiant d’un accès rapide aux différents outils.

Dans le menu Voir, vous pouvez faire apparaître n’importe quelle fenêtre d’outil et l’ancrer directement à une autre. Par exemple, lorsque vous ouvrez pour la première fois C++Builder dans sa configuration par défaut, l’explorateur de classes est ancré à gauche de l’éditeur de code. Vous pouvez ajouter le gestionnaire de projet aux deux premiers et créer ainsi trois fenêtres ancrées ensemble.

Fenêtre principale organisée différemment.

Dans la page Commandes, sélectionnez une commande et faites la glisser dans une barre d’outils.Dans la page Options, cochez l’option Afficher les conseils pour que les conseils apparaissent pour les composants et les icônes de la barre d’outils.

P e r s o n n a l i s a t i o n d u b u r e a u 6-3


Pour ancrer une fenêtre, cliquez sur sa barre d’outils et faites-la glisser par dessus une autre fenêtre. Lorsque le cadre montrant l’emplacement de la première fenêtre devient un rectangle étroit et s’accroche à un coin de la seconde, relâchez la souris. Les deux fenêtres sont ancrées.

Vous pouvez également ancrer les outils entre eux et former une fenêtre à onglets.

Ici, le gestionnaire de projet et l’explorateur de code sont ancrés à l’éditeur de code.

Vous pouvez combiner, ou “ancrer” des fenêtres, soit avec les poignées, comme à gauche, soit avec les onglets.

Pour ancrer des fenêtres en utilisant les poignées, relâchez la souris lorsque le cadre de déplacement s’accroche au coin de l’autre fenêtre.



Pour désancrer une fenêtre, double-cliquez sur sa poignée ou sur son onglet.

Pour désactiver l’ancrage automatique, appuyez sur la touche Ctrl tout en déplaçant une fenêtre ou choisissez Outils|Options d’environnement, sélectionnez la page Préférences et enlevez la coche de l’option Ancrage automatique par glissement.

Pour plus d’informations...Voir “ancrage” dans l’index de l’aide.

Enregistrement des dispositions du bureau

Vous pouvez personnaliser et enregistrer les dispositions du bureau. La barre d’outils Bureau, dans l’EDI, offre une liste de sélection des dispositions de bureau disponibles et deux icônes facilitant la personnalisation du bureau.

Pour ancrer des fenêtres en utilisant un classeur, relâchez la souris avant que le cadre de déplacement s’accroche au coin de l’autre fenêtre.

Définir le bureau de débogage

Enregistrer le bureau en cours

Les dispositions de bureau nommées sont listées ici.


P e r s o n n a l i s a t i o n d e l a p a l e t t e d e c o m p o s a n t s

Agencez le bureau à votre convenance : affichez, redimensionnez et ancrez certaines fenêtres, et placez-les où vous voulez sur l’écran.

Cliquez sur l’icône Enregistrer le bureau en cours dans la barre d’outils Bureau ou choisissez Voir|Bureaux|Enregistrer le bureau, et entrez un nom pour la nouvelle disposition.

Pour plus d’informations...Voir “disposition du bureau” dans l’index de l’aide.

Personnalisation de la palette de composantsDans sa configuration par défaut, la palette de composants affiche de nombreux objets VCL utiles, regroupés de manière fonctionnelle en plusieurs pages à onglets. Vous pouvez personnaliser la palette de composants et :

• Cacher ou réorganiser des composants• Ajouter, supprimer, réorganiser ou renommer des pages• Créer des modèles de composants et les ajouter à la palette• Installer de nouveaux composants

Organisation de la palette de composants

Pour ajouter, supprimer, réorganiser ou renommer des pages, ou pour cacher ou réorganiser des composants, utilisez la boîte de dialogue Propriétés de la palette. Vous pouvez ouvrir cette boîte de dialogue de différentes façons :

• Choisissez Composant|Configurer la palette.• Choisissez Outils|Options d’environnement et cliquez sur l’onglet Palette.• Cliquez avec le bouton droit sur la palette de composants et sélectionnez

Propriétés.

Pour plus d’informations...Cliquer sur le bouton Aide de la boîte de dialogue Propriétés de la palette.

Création de modèles de composants

Les modèles de composants sont des groupes de composants que vous ajoutez à une fiche en une seule opération. Les modèles vous permettent de configurer des composants sur une fiche, puis de sauvegarder leur agencement, leurs propriétés

Entrez un nom pour la disposition de bureau à enregistrer et cliquez sur OK.



par défaut et leurs gestionnaires d’événements dans la palette de composants, afin de les réutiliser dans d’autres fiches.

Pour créer un modèle de composants, disposez simplement un ou plusieurs composants dans une fiche, définissez leurs propriétés dans l’inspecteur d’objets, puis sélectionnez-les tous en faisant glisser la souris autour d’eux. Choisissez ensuite Composant|Créer un modèle de composant. Lorsque s’ouvre la boîte de dialogue Informations sur le modèle de composant, vous pouvez choisir un nom pour le modèle, la page de la palette sur laquelle il doit apparaître et l’icône devant le représenter dans celle-ci.

Après avoir positionné le modèle sur une fiche, vous pouvez repositionner les composants indépendamment les uns des autres, réinitialiser leurs propriétés, et créer ou modifier des gestionnaires d’événements comme si vous aviez positionné chaque composant séparément.

Pour plus d’informations...Voir “modèles de composants” dans l’index de l’aide en ligne.

Installation de paquets de composants

Que vous écriviez vos propres composants personnalisés ou les obteniez d’un fournisseur extérieur, les composants doivent être compilés en un paquet avant de pouvoir être installés dans la palette de composants.

Un paquet est une DLL spéciale contenant du code partageable par les applications C++Builder, l’EDI, ou les deux. Les paquets d’exécution apportent les fonctionnalités lorsque l’utilisateur exécute une application. Les paquets de conception sont utilisés pour installer des composants dans l’EDI. Les paquets C++Builder ont l’extension .bpl.

Lorsque des composants de développeurs tiers sont déjà compilés en paquet, suivez les instructions de ce fournisseur ou choisissez Composant|Installer des paquets.



Pour plus d’informations...Voir “installation des composants” et “paquets” dans l’index de l’aide.

Utilisation des cadresUn cadre (TFrame) sert, comme une fiche, de conteneur à des composants que vous voulez réutiliser. Un cadre ressemble en fait plus à un composant personnalisé qu’à une fiche. Il est possible d’intégrer un cadre à la palette des composants afin de le réutiliser plus facilement. Les cadres peuvent être imbriqués dans une fiche, dans d’autres cadres ou dans d’autres objets conteneur. Une fois un cadre créé et enregistré, il continue à fonctionner comme une unité et hérite des modifications apportées aux composants qu’il contient (y compris des cadres). Quand un cadre est incorporé dans un autre cadre ou une fiche, il continue à hériter des modifications apportées au cadre dont il dérive.

Pour ouvrir un nouveau cadre, choisissez Fichier|Nouveau|Cadre.

Pour plus d’informations...Voir “cadres” et “TFrame” dans l’index de l’aide en ligne.

Ces composants sont pré-installés dans C++Builder. Lorsque vous installez de nouveaux composants provenant de fournisseurs tiers, leur paquet apparaît dans cette liste.Cliquez sur Composants pour voir les composants contenus dans le paquet.

Vous pouvez ajouter au cadre les composants visuels ou non visuels de votre choix. Une nouvelle unité est automatiquement ajoutée dans l’éditeur de code.


D é f i n i t i o n d e s o p t i o n s d e s p r o j e t s

Ajout de contrôles ActiveXVous pouvez ajouter des contrôles ActiveX à la palette de composants et les utiliser dans vos projets C++Builder. Choisissez Composant|Importer un contrôle ActiveX pour ouvrir la boîte de dialogue Importation d’ActiveX. Vous pouvez alors recenser de nouveaux contrôles ActiveX ou en sélectionner un déjà recensé en vue de son installation dans l’EDI. Lorsque vous installez un contrôle ActiveX, C++Builder crée et compile un fichier unité “enveloppe” pour ce contrôle.

Pour plus d’informations...Choisissez Composant|Importer un contrôle ActiveX et cliquez sur le bouton Aide.

Définition des options des projetsSi vous devez gérer les répertoires de votre projet ou spécifier les options de fiche, application, compilateur et lieur de votre projet, choisissez Projet|Options. Lorsque vous effectuez des modifications dans la boîte de dialogue Options du projet, elles n’affectent que le projet en cours ; vous pouvez cependant enregistrer vos sélections comme paramètres de fonctionnement par défaut des nouveaux projets.

Définition des options de projet par défaut

Pour enregistrer vos sélections comme paramètres de fonctionnement par défaut de tous les nouveaux projets, cochez Défaut, dans le coin inférieur gauche de la boîte de dialogue Options du projet. L’activation de la case Défaut écrit les paramètres en cours du dialogue dans le fichier d’options default.bpr, placé dans le répertoire Cbuilder6\Bin. Pour rendre à C++Builder ses paramètres par défaut d’origine, supprimez ou renommez le fichier default.bpr.

Spécification des modèles de projet et de fiches par défautLorsque vous choisissez Fichier|Nouveau|Application, un nouveau projet est ouvert dans l’EDI. C++Builder crée une nouvelle application avec une fiche vide, sauf si vous spécifiez un modèle de projet comme projet par défaut. Vous pouvez enregistrer vos propres projets en tant que modèles dans le référentiel d’objets dans la page Projets en choisissant Projet|Ajouter au référentiel (voir “Ajout de modèles au référentiel d’objets” à la page 6-9). Vous pouvez aussi utiliser l’un des modèles de projet du référentiel d’objets C++Builder (voir “Le référentiel d’objets” à la page 2-5).

Pour spécifier votre modèle de projet comme projet par défaut, choisissez Outils|Référentiel. Dans la boîte de dialogue Référentiel d’objets, sélectionnez Projets sous Pages. Si vous avez enregistré un projet en tant que modèle dans


S p é c i f i c a t i o n d e s m o d è l e s d e p r o j e t e t d e f i c h e s p a r d é f a u t

la page Projets, il apparaît dans la liste Objets. Sélectionnez le nom du modèle et cochez Nouveau projet, puis choisissez OK.

Lorsque vous avez spécifié un modèle de projet comme projet par défaut, C++Builder l’ouvre automatiquement chaque fois que vous choisissez Fichier|Nouveau|Application.

De la même façon que vous spécifiez un projet par défaut, vous pouvez spécifier une fiche principale par défaut et une nouvelle fiche par défaut en les choisissant dans la liste des modèles de fiches existant dans le référentiel d’objets. La nouvelle fiche par défaut est la fiche créée lorsque vous choisissez Fichier|Nouveau|Fiche pour ajouter une fiche supplémentaire à un projet ouvert. La fiche principale par défaut est la fiche créée lorsque vous ouvrez une nouvelle application. Si vous n’avez pas spécifié de fiche par défaut, C++Builder utilise une fiche vierge.

Vous pouvez toujours remplacer le projet ou les fiches par défaut en choisissant Fichier|Nouveau|Autre et en sélectionnant un modèle différent dans la boîte de dialogue Nouveaux éléments.

Pour plus d’informations...Voir “modèles, ajout au référentiel d’objets”, “projets, spécification des valeurs par défaut” et “fiches, spécification des valeurs par défaut” dans l’index de l’aide.

Ajout de modèles au référentiel d’objets

Vous pouvez ajouter vos propres objets au référentiel d’objets afin de les utiliser comme modèles que vous réutilisez ou partagez avec d’autres développeurs via un réseau. La réutilisation d’objets vous permet de concevoir des familles d’applications ayant une interface utilisateur et des fonctionnalités communes, ce qui réduit les temps de développement tout en améliorant la qualité.

Les pages du référentiel d’objets contiennent soit des modèles de projets, soit des modèles de fiches, soit les deux.

Pour définir un modèle de projet comme projet par défaut, sélectionnez un élément dans la liste des objets et cochez Nouveau projet.Pour définir un modèle de fiche comme fiche par défaut, sélectionnez un élément dans la liste des objets et cochez Nouvelle fiche ou Fiche principale.


D é f i n i t i o n d e s p r é f é r e n c e s p o u r l e s o u t i l s

Par exemple, pour ajouter un projet comme modèle dans le référentiel, commencez par enregistrer le projet, puis choisissez Projet|Ajouter au référentiel. Complétez alors la boîte de dialogue Ajout au référentiel.

A la prochaine ouverture de la boîte de dialogue Nouveaux éléments, votre modèle de projet apparaît dans la page Projets (ou dans la page spécifiée). Pour que votre modèle soit le modèle par défaut à la prochaine ouverture de C++Builder, voir “Spécification des modèles de projet et de fiches par défaut” à la page 6-8.

Pour plus d’informations...Voir “modèles, ajouter au référentiel d’objets” dans l’index de l’aide en ligne.

Définition des préférences pour les outilsVous pouvez contrôler un grand nombre des outils déterminant l’aspect et le comportement de l’EDI, comme le concepteur de fiche, l’inspecteur d’objets ou l’explorateur de code. Ces paramètres affectent non seulement le projet en cours mais aussi les projets que vous allez ouvrir et compiler. Pour modifier les paramètres de l’EDI pour tous les projets, choisissez Outils|Options d’environnement.

Pour plus d’informations...Voir “Options d’environnement, boîte de dialogue” dans l’index de l’aide en ligne ou cliquer sur le bouton Aide figurant sur l’une des pages de la boîte de dialogue Options d’environnement.

Personnalisation du concepteur de fiche

La page Concepteur de la boîte de dialogue Outils|Options d’environnement propose des options qui affectent le concepteur de fiche. Par exemple, vous pouvez activer ou désactiver la fonction “Aligner sur la grille”, qui aligne les composants avec la ligne de grille la plus proche ; vous pouvez également afficher ou masquer le nom, ou le l’intitulé, des composants non visuels placés dans les fiches.

Saisissez le titre, la description et l’auteur. Dans la liste Page, choisissez Projets pour que votre projet apparaisse dans la page Projets du référentiel d’objets.


D é f i n i t i o n d e s p r é f é r e n c e s p o u r l e s o u t i l s

Pour plus d’informations...Dans la boîte de dialogue Options d’environnement, cliquez sur le bouton Aide de la page Concepteur.

Personnalisation de l’éditeur de code

Vous souhaiterez sans doute personnaliser l’éditeur de code immédiatement. Plusieurs pages de la boîte de dialogue Outils|Options de l’éditeur proposent des options d’édition du code. Par exemple, vous pouvez choisir les équivalences des touches, les fontes, la largeur des marges, les couleurs, la mise en évidence syntaxique, les tabulations et les styles d’indentation.

Vous pouvez également configurer les outils d’audit de code, utilisables dans l’éditeur, sur la page Audit de code de la boîte de dialogue Propriétés de l’éditeur. Pour savoir comment utiliser ces outils, reportez-vous à “Audit de code” à la page 2-6.

Pour plus d’informations...Dans la boîte de dialogue Propriétés de l’éditeur, cliquez sur le bouton Aide figurant sur les pages Général, Affichage, Affectations de touches, Couleurs et Audit de code.


I n d e x I-1

AA propos (boîte de dialogue),

ajout 4-34achèvement du code 2-6actions standard, ajout à une

application 4-18actions, ajout à une

application 4-9, 4-11, 4-18ActiveX 3-14

installation des contrôles 6-8page de la palette 3-14

ADO (ActiveX Data Objects) 3-11

affectation des touches 6-11affichage des images 5-12aide en ligne, fichiers 1-4aide, conseils 4-4Aide, F1 1-4ajout

composants à une fiche 4-20ajout d’éléments au référentiel

d’objets 2-5ajout de composants à une

fiche 4-3ancrage des fenêtres 6-2–6-4applications

compilation et débogage 4-14, 4-24

création 3-10applications de bases de

donnéesaccès 5-3–5-5

arborescence d’objets 2-4audit de code 2-6audit de symbole dans

conseil 2-7

Bbarres d’outils 2-2–2-3

ajout à une application 4-14, 4-23

configuration 6-1organisation 6-1

base de données exemple 5-1–5-17

bases de donnéesaccès 3-11explorateur 3-12

BDE (Borland Database Engine) 3-11

administrateur 3-12alias 3-12

bibliothèques de classes 3-6bibliothèques de liaison

dynamique 3-13bibliothèques de types 3-14bitmaps, ajout à une

application 4-7, 4-15boîtes de dialogue

modèles 2-5.BPR, fichiers 4-2bureau, organisation 6-1–6-5

CC++Builder

personnalisation 6-1–6-11programmation 3-1

cadres 6-7classes, définition 4-4clic droit

menus 2-3CLX

applications, création 3-10définition 3-6

codevisualisation et

modification 2-6COM 3-14compilation des

programmes 4-24, 5-8composants

agencement dans la palette 6-5

ajout à une fiche 3-2, 4-4bibliothèque de classes

CLX 3-7définition 4-3définition des propriétés 3-4,

4-2installation 3-13, 6-6modèles 6-5personnalisation 3-13, 6-5

concepteur de fichepersonnalisation 6-10utilisation 2-4

conseils d’aide 4-4contexte

accès aux menus 2-3

contrôlesbase de données 3-12orientés données 3-12

contrôles, ajout à une fiche 4-3conventions typographiques 1-6

DDB2 3-11dbExpress 3-11débogage des programmes 3-7–

3-8, 4-14débogueur intégré 3-7défaut

modèles de projet et de fiches 6-8

options de projet 6-8définition des propriétés 3-4,

4-2, 4-10, 4-12, 4-18démarrage de C++Builder 2-1déploiement des

programmes 3-8.dfm, fichiers 4-1Diagramme, page 2-8dictionnaire de données 3-13DLL 3-13documentation

imprimée 1-6recherche 1-3

donnéesmodules 3-2

Eécriture du code 3-5EDI

définition 1-1organisation 6-1personnalisation 6-1–6-11

éditeur de bibliothèque de types 3-14

éditeur de codecombinaison avec d’autres

fenêtres 6-2personnalisation 6-11utilisation 2-6

éditeur de texte, tutoriel 4-1–4-37

éditeur du gestionnaire d’actions 4-9–4-12

éditeurs de méthodes de saisie (IME) 3-9

Index

I-2 P r i s e e n m a i n

éditions de C++Builder 3-9enregistrement

dispositions du bureau 6-4projets 4-2

en-têtes d’unités, fichiers 4-1environnement de

développement intégré (EDI) 2-1

personnalisation 6-1–6-11équivalents clavier 2-3erreurs, messages 4-32évaluation d’expression dans

conseil 2-7événements 5-14–5-17exécutables 3-8Exécuter, bouton 5-8exécution d’une

application 4-14exécution des application 4-24,

5-8expert DLL ressource 3-9experts 3-14experts (référentiel d’objets) 2-5explorateur de classe 2-9

utilisation 2-9explorateur SQL 3-12

Ffenêtres à onglets, configuration

de l’EDI 6-3fenêtres d’outils

ancrage 6-2fenêtres, combinaison 6-2fermeture d’une fiche 4-3fiches

ajout de composants 3-2, 4-3dans le référentiel

d’objets 2-5fermeture 4-3fichiers 2-9principales 4-2, 6-9spécification de la fiche par

défaut 6-9fiches, fichiers

définition 4-1fichiers

enregistrement 4-2fiche 4-1projet 4-1unités 4-1

fichiers d’aide, ajout à une application 4-32

fichiers en-tête 4-1

fichiers fichevisualisation du code 2-9

fichiers projet 4-2noms par défaut 4-1

Ggestionnaire de projet 2-9–2-10gestionnaires d’événements 3-5,

5-14–5-17création 4-25–4-32

graphiques, affichage 5-12groupes de projets 2-10GUI, création 3-2, 4-2

Iimages

affichage 5-12images, ajout à une

application 4-7, 4-15Informix 3-11inspecteur d’objets 3-6

présentation 3-4référence de composants en

ligne 3-5utilisation 3-4, 4-2

installation des composants personnalisés 6-6

InterBase 3-11, 3-12interfaces utilisateur,

création 3-2, 4-2, 4-3internationalisation des

applications 3-9

Jjeux de caractères étendus 3-9

Llistes A faire 2-10localisation des applications 3-9

MMainMenu, composant 5-10makefiles 4-2menus

ajout à une application 4-20configuration 6-1contextuels 2-3dans C++Builder 2-3organisation 2-2–2-3, 6-1

messages d’erreur 4-32

modèlesajout au référentiel

d’objets 6-9spécification comme

défaut 6-8modèles de code 2-6modèles de composants

création 6-5Modification de

StatusBar1.Panels, boîte de dialogue 4-5

module base de données 3-12modules de données 2-5, 3-2multiplate-forme

développement d’applications pour 3-10

Nnewsgroups 1-6nouveautés 1-3Nouveaux éléments, boîte de

dialogueenregistrement des

modèles 6-8–6-9, 6-10utilisation 2-5, 4-34

Oobjets, définition 3-6ODBC 3-11options

projets 6-8Options d’environnement, boîte

de dialogue 6-10Options de l’éditeur, boîte de

dialogue 6-11Options du projet, boîte de

dialogue 6-8Oracle 3-11outils de traduction 3-9

Ppage diagramme 2-8palette de composants

définition 2-3personnalisation 6-5–6-7utilisation 3-2

Panel, composant 5-12paquets 3-8, 3-9

définition 6-6Paradox 3-11paramètres du code 2-6.pas, fichiers 4-1

I n d e x I-3

personnalisationconcepteur de fiche 6-10EDI 6-1–6-11éditeur de code 6-11palette de composants 2-2

programmation 3-1programme exemple 4-1–4-37,

5-1–5-17programmes

applications CLX 3-10compilation et

débogage 4-14, 4-24projets

ajout d’éléments 2-5création 3-1définition des options par

défaut 6-8enregistrement 4-2gestion 2-9–2-10spécification comme projet

par défaut 6-8types 3-9–3-13

propriétésdéfinition 3-4

propriétés, définition 4-2, 4-10, 4-12, 4-18

Rraccourcis clavier 2-3référentiel d’objets

ajout des modèles 6-8définition 2-5utilisation 2-5, 3-1

relations parent-enfant 2-4

Sserveurs SQL 3-11services de support 1-6site Web de Borland 1-6SQL 3-11

explorateur 3-12SQL Links 3-11SQL Server 3-11support pour développeurs 1-6support technique 1-6Sybase 3-11

Ttutoriel 4-1–4-37, 5-1–5-17types

bibliothèques 3-14

Uunités, fichiers 4-1, 6-8

VVCL

composants 2-3utilisation 3-6

vue de conception, fermeture des fiches 4-3

WWeb, site Borland 1-6

X.xfm, fichiers 2-9

I-4 P r i s e e n m a i n

Documents

Intro Cpp Builder Borland[1]