Intro CPP Builder Borland

Prise en main
Borland ®
C++Builder 6™
pour 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 6E2R0102
0203040506-9 8 7 6 5 4 3 2 1
PDF
Table des matières
Chapitre 1 Types de projets. . . . . . . . . . . . . . . . . . . 3-9
Applications CLX . . . . . . . . . . . . . . . 3-10
Introduction 1-1 Applications serveur Web . . . . . . . . . . 3-10
Qu’est-ce que C++Builder ? . . . . . . . . . . . 1-1
Applications de bases de données . . . . . 3-11
Enregistrement de C++Builder. . . . . . . . . . 1-2
Administrateur BDE. . . . . . . . . . . . 3-12
Où trouver des informations ? . . . . . . . . . . 1-3
Explorateur SQL
Aide en ligne . . . . . . . . . . . . . . . . . . 1-4
(explorateur de base de données) . . . 3-12
Aide F1 . . . . . . . . . . . . . . . . . . . . . 1-4
Module base de données . . . . . . . . . 3-12
Documentation imprimée . . . . . . . . . . . . 1-6
Dictionnaire de données . . . . . . . . . 3-13
Services de support développeur . . . . . . . . 1-6
Composants personnalisés . . . . . . . . . . 3-13
Conventions typographiques. . . . . . . . . . . 1-6
DLL . . . . . . . . . . . . . . . . . . . . . . . 3-13
Chapitre 2 COM et ActiveX. . . . . . . . . . . . . . . . 3-14
Bibliothèques de types . . . . . . . . . . 3-14
Parcours rapide
de l’environnement 2-1 Chapitre 4
Démarrage de C++Builder . . . . . . . . . . . . 2-1 Tutoriel : création
L’EDI . . . . . . . . . . . . . . . . . . . . . . . . 2-1
Menus et barres d’outils . . . . . . . . . . . . . 2-2
d’un éditeur de texte 4-1
Démarrage d’une nouvelle application . . . . . 4-1
Le concepteur de fiche, la palette de composants
Définition des valeurs d’une propriété . . . . . 4-2
et l’inspecteur d’objets . . . . . . . . . . . . . 2-3
Ajout de composants à la fiche . . . . . . . . . . 4-3
L’arborescence d’objets . . . . . . . . . . . . . . 2-4
Ajout du support pour un menu
Le référentiel d’objets . . . . . . . . . . . . . . . 2-5
et une barre d’outils . . . . . . . . . . . . . . . 4-6
L’éditeur de code . . . . . . . . . . . . . . . . . 2-6
Différences entre l’éditeur du gestionnaire
Audit de code . . . . . . . . . . . . . . . . 2-6
d’actions et l’éditeur de liste d’actions . . . 4-7
Navigation dans le code . . . . . . . . . . 2-7
Ajout d’images aux menus et à la barre
La page Diagramme . . . . . . . . . . . . . . 2-8
d’outils (Entreprise et Professionnel) . . . . 4-7
Visualisation du code des fiches . . . . . . . 2-9
Ajout d’actions au gestionnaire d’actions
L’explorateur de classe . . . . . . . . . . . . . . 2-9
(Entreprise et Professionnel) . . . . . . . . . 4-9
Le gestionnaire de projet . . . . . . . . . . . . . 2-9
Ajout d’actions standard
Liste A faire . . . . . . . . . . . . . . . . . . . . 2-10
(Entreprise et Professionnel) . . . . . . . . 4-11
Chapitre 3 Ajout d’un menu
(Entreprise et Professionnel) . . . . . . . . 4-13
Programmation avec C++Builder 3-1 Ajout d’une barre d’outils
Création d’un projet . . . . . . . . . . . . . . . . 3-1 (Entreprise et Professionnel) . . . . . . . . 4-14
Ajout de modules de données . . . . . . . . 3-2 Ajout d’une liste d’images et d’images
Construction de l’interface utilisateur . . . . . 3-2 (édition Personnelle) . . . . . . . . . . . . 4-15
Positionnement des composants Ajout d’actions à la liste d’actions
sur une fiche . . . . . . . . . . . . . . . . . 3-2 (édition Personnelle) . . . . . . . . . . . . 4-16
Définition des propriétés des composants . 3-4 Ajout d’actions standard à la liste d’actions
Ecriture du code . . . . . . . . . . . . . . . . . . 3-5 (édition Personnelle) . . . . . . . . . . . . 4-18
Ecriture des gestionnaires d’événements . . 3-5 Ajout d’un menu (édition Personnelle) . . 4-20
Utilisation des bibliothèques VCL et CLX . 3-6 Ajout d’une barre d’outils
Compilation et débogage des projets . . . . . . 3-7 (édition Personnelle) . . . . . . . . . . . . 4-23
Déploiement des applications . . . . . . . . . . 3-8 Effacement de la zone de texte
Internationalisation d’applications . . . . . . . 3-9 (toutes éditions) . . . . . . . . . . . . . . . . . 4-24
i
Ecriture de gestionnaires d’événements . . . . 4-25 Ajout du support pour un menu . . . . . . . 5-8
Création d’un gestionnaire d’événement Ajout d’un menu . . . . . . . . . . . . . . . 5-10
pour la commande Nouveau . . . . . . . . 4-25 Ajout d’un bouton . . . . . . . . . . . . . . 5-12
Création d’un gestionnaire d’événement Affichage d’un titre et d’une image . . . . . . 5-12
pour la commande Ouvrir . . . . . . . . . 4-28 Ecriture d’un gestionnaire d’événements . . . 5-14
Création d’un gestionnaire d’événement Ecriture d’un gestionnaire d’événement pour
pour la commande Enregistrer . . . . . . . 4-29 la commande Mise à jour immédiate ! . . 5-14
Création d’un gestionnaire d’événement Ecriture d’un gestionnaire d’événement
pour la commande Enregistrer sous . . . . 4-30 pour la commande Quitter. . . . . . . . . 5-15
Création d’un fichier d’aide . . . . . . . . . . . 4-32 Ecriture d’un gestionnaire d’événement
Création d’un gestionnaire d’événement pour fermer la fiche . . . . . . . . . . . . . 5-15
pour la commande Rubriques d’aide . . . 4-32
Création d’un gestionnaire d’événement Chapitre 6
pour la commande Index de l’aide . . . . 4-33 Personnalisation du bureau 6-1
Création d’une boîte de dialogue A propos . . 4-34 Organisation de votre espace de travail . . . . . 6-1
Achèvement de l’application . . . . . . . . . . . 4-36 Agencement des menus
et des barres d’outils . . . . . . . . . . . . . 6-1
Chapitre 5 Ancrage des fenêtres d’outils . . . . . . . . . 6-2
Tutoriel : création d’une application Enregistrement des dispositions du bureau . 6-4
de base de données CLX 5-1 Personnalisation de la palette de composants . 6-5
Présentation de l’architecture Organisation de la palette de composants . . 6-5
des bases de données . . . . . . . . . . . . . . 5-1 Création de modèles de composants . . . . . 6-5
Création d’une nouvelle application CLX . . . 5-2 Installation de paquets de composants. . . . 6-6
Installation des composants Utilisation des cadres . . . . . . . . . . . . 6-7
d’accès aux données . . . . . . . . . . . . . . . 5-3 Ajout de contrôles ActiveX. . . . . . . . . 6-8
Installation de la connexion Définition des options des projets . . . . . . . . 6-8
à la base de données . . . . . . . . . . . . . 5-3 Définition des options de projet par défaut . 6-8
Installation de l’ensemble de données Spécification des modèles de projet
unidirectionnel . . . . . . . . . . . . . . . . 5-5 et de fiches par défaut . . . . . . . . . . . . . . 6-8
Installation du fournisseur, Ajout de modèles au référentiel d’objets. . . 6-9
de l’ensemble de données client Définition des préférences pour les outils . . . 6-10
et de la source de données . . . . . . . . . 5-5 Personnalisation du concepteur de fiche. . 6-10
Conception de l’interface utilisateur . . . . . . 5-6 Personnalisation de l’éditeur de code . . . 6-11
Création de la grille
et de la barre de navigation. . . . . . . . . 5-7 Index I-1
ii
Chapitre
1
Introduction
Chapitre 1
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.
Introduction 1-1
Enregistrement de C++Builder
Enregistrement de C++Builder
C++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.
1-2 Prise en main

Où trouver des informations ?
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.

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.
Introduction 1-3
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.
1-4 Prise en main

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.
Introduction 1-5
Documentation imprimé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ée
Ce 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éveloppeur

Borland 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 typographiques
Ce 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.”
1-6 Prise en main

Chapitre
Parcours rapide de l’environnement

Chapitre 2
2
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++Builder
Vous 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’EDI
Lorsque 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.
Parcours rapide de l’environnement 2-1

Menus et barres d’outils
La vue arborescente de l’objet affiche une représentation

hiérarchique des relations parent-enfant des composants.
Palette de composants
prêts à être utilisés dans
votre application.
Editeur de code
permettant de visualiser
et de modifier le code.
Concepteur de fiche contenant

une fiche vierge pour démarrer la
conception de l’interface
utilisateur de votre application.
Une application peut inclure
plusieurs fiches.
L’inspecteur d’objets est utilisé pour changer L’explorateur de code montre les classes, variables
les propriétés des objets et sélectionner les et routines de votre unité et vous permet de naviguer
gestionnaires d’événements. rapidement.
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’outils

La 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.
Fenêtre principale dans son agencement par défaut.
2-2 Prise en main

Le concepteur de fiche, la palette de composants et l’inspecteur d’objets
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.
Barre d’outils Standard Barre d’outils Voir Barre d’outils Bureaux
Retirer
Ouvrir un fichier Voir une Basculer Nom de la disposition Enregistrer
Nouveau Enregistrer un projet du projet unité fiche/unité du bureau enregistré le bureau
Ouvrir Tout Ajouter un Voir une Nouvelle Définir le bureau

enregistrer fichier au projet fiche fiche de débogage
Barre d’outils Déboguer Barre d’outils Internet Pour connaître la fonction d’un bouton,
pointez dessus pendant un court
Liste des projets Pas à pas Nouvelle application Nouveau module de moment pour qu’un message s’affiche
exécutables approfondi WebSnap données WebSnap
Vous pouvez aussi utiliser le menu
contextuel pour cacher les barres
d’outils. Pour afficher une barre
d’outils cachée, choisissez Voir|
Exécuter Pas à pas Nouveau module de Editeur Barres d’outils et cochez la barre
Suspendre page WebSnap externe d’outils voulue.
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.

L’arborescence d’objets
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.
Cliquez ici pour visualiser
Pages de la palette de composants, regroupées par fonctions les autres pages.
Composants
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.

Voir “palette de composants” dans l’index de l’aide.
L’arborescence d’objets
L’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.
2-4 Prise en main

Le référentiel d’objets

Voir “arborescence d’objets” dans l’index de l’aide.
Le 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.
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.
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.
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.
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.

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

L’éditeur de code
A 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.
L’ajout de composants
à la fiche est répercuté
dans le code.
Code
généré.
Audit de code
Les 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.
2-6 Prise en main

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

Outil Fonctionnement de l’outil
Evaluation d’expression Lors d’un arrêt pendant le débogage, pointez sur une variable
dans conseil pour afficher sa valeur courante.
Audit de symbole Pendant l’édition du code, pointez sur un identificateur
dans conseil quelconque pour afficher sa déclaration.
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.

Voir “Audit de code” dans l’index de l’aide en ligne.
Navigation dans le code

Quand 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.
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.
Pour personnaliser l’environnement de l’éditeur de code, voir “Personnalisation

de l’éditeur de code” à la page 6-11.

Voir “éditeur de code” dans l’index de l’aide en ligne.

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.
Depuis l’arborescence des objets, Pour voir d’autres diagrammes nommés du projet
faites glisser les icônes des en cours, choisissez dans la liste déroulante.
composants dans la page
Entrez le nom et la description de votre
Diagramme.
diagramme.
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.
Vous pouvez attribuer un nom et une description à votre diagramme,

l’enregistrer et l’imprimer une fois qu’il est complet.

Voir “page diagramme” dans l’index de l’aide en ligne.
2-8 Prise en main

L’explorateur de classe
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.

Voir “fichiers fiche” dans l’index de l’aide en ligne.
L’explorateur de classe
A 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.

Voir “explorateur de classe” dans l’index de l’aide en ligne.
Le gestionnaire de projet
Lorsque 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

Liste A faire
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.

Voir “gestionnaire de projet” dans l’index de l’aide en ligne.
Liste A faire
Les 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.
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.

Voir “liste A faire” dans l’index de l’aide en ligne.
2-10 Prise en main

Chapitre
Programmation avec C++Builder

Chapitre 3
3
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 projet

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

Voir “projets” dans l’index de l’aide en ligne.
Programmation avec C++Builder 3-1

Construction de l’interface utilisateur
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.
Double-cliquez sur un composant

non visuel de la palette de
composants pour le placer dans le
module de données.
Lorsque vous rouvrez un module de données existant, C++Builder affiche

ses composants.

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

Avec 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.
3-2 Prise en main

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

sur la fiche.
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.
Vous pouvez aussi réorganiser la palette
et lui ajouter de nouvelles pages.
Choisissez Options d’environnement,
puis la page Palette.

Voir “palette des composants” dans l’index de l’aide en ligne.

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.
Utilisez cette liste déroulante Vous pouvez sélectionner

pour sélectionner un objet. Ici, un composant, ou objet, sur
Button1 est sélectionné et ses la fiche en cliquant dessus.
propriétés sont affichées.
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 aussi cliquer sur le signe plus pour
ouvrir une liste de détails.
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.
Double-cliquez ici pour
changer la valeur True
en False.
Cliquez sur les points

de suspension pour
afficher l’éditeur de
cette propriété.
Cliquez sur la flèche vers le bas pour faire votre choix

parmi les valeurs valides de la propriété.
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.
3-4 Prise en main

Ecriture du code
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.
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.

Voir “inspecteur d’objets” dans l’index de l’aide en ligne.
Ecriture du code
La 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.

Ecriture du code
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.
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.
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.

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.
TObject
Exception TStream TPersistent TComObject TInterface
TGraphicsObject TGraphic TComponent TCollection TStrings

La plupart des
composants visuels
TApplication TDataSet TMenu TControl TCommonDialog TField dérivent de TWinControl
et dans la CLX de
TWidgetControl.
TGraphicControl TWinControl
TScrollingWinControl TCustomControl
TCustomForm
3-6 Prise en main

Compilation et débogage des projets
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.

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 projets

Aprè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éploiement des applications
Vous pouvez commencer une session de débogage dans l’EDI en choisissant

Exécuter|Exécuter ou en appuyant sur F9.
Choisissez une des

commandes de débogage
dans le menu Exécuter.
Certaines commandes sont Bouton Exécuter
aussi accessibles dans la
barre
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 simplifier l’utilisation,

vous pouvez combiner
plusieurs fenêtres de
débogage.
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.

Voir “débogage” et “utilisation du débogueur intégré” dans l’index de l’aide.
Déploiement des applications

Vous 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
3-8 Prise en main

Internationalisation d’applications
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.

Voir “déploiement” dans l’index de l’aide en ligne.
Internationalisation d’applications
C++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.

Voir “applications internationales” dans l’index de l’aide en ligne.
Types de projets
Toutes 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.

Types de projets

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 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
3-10 Prise en main

Types de projets
WebSnap. Vous pouvez ajouter les composants de la page WebSnap de la palette

des composants.
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.
Vous pouvez également
accéder au module de Décidez si vous souhaitez un
données d’application module de données ou un
WebSnap en choisissant module de page qui affiche votre
Voir|Barres d’outils| page HTML.
Internet, et en cliquant sur
l’icône Nouvelle application
WebSnap.

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

Types de projets
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.

Voir “Applications de bases de données” dans l’index de l’aide en ligne.
Administrateur BDE
Utilisez 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.

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.

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

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

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.
3-12 Prise en main

Types de projets
Dictionnaire de données
Le 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.

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.

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.

Voir “DLL” dans l’index de l’aide en ligne.

Types de projets
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.

Voir “COM” et “ActiveX” dans l’index de l’aide en ligne.
Bibliothèques de types
Les 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.

Voir “bibliothèque de types” dans l’index de l’aide en ligne.
3-14 Prise en main

Chapitre
Tutoriel : création
Chapitre 4
4
d’un éditeur de texte
Ce 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 application

Avant 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.
Tutoriel : création d’un éditeur de texte 4-1

Définition des valeurs d’une proprié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.
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.
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.
4-2 Prise en main

Ajout de composants à la fiche
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.
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.
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.

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

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.
4-4 Prise en main

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.
Zone de saisie
Barre d’état
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.
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.

Ajout du support pour un menu et une barre d’outils
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.

Pour 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

Dans
la barre
Menu Commande 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 Non Stocke un fichier sous un nouveau nom (vous permet
sous é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-papiers
Edition Coller Oui Insère le texte contenu dans le Presse-papiers.
Aide Rubriques Non Affiche l’écran de sommaire qui vous permet d’accéder
d’aide 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.
4-6 Prise en main

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 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.
Les propriétés ImageIndex des actions standard et de l’ImageList1 que nous

avons ajoutées incluent :
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
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.
4-8 Prise en main

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.
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.
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 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.
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.
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.
4-10 Prise en main

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

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.
4-12 Prise en main

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.
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.
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.
4-14 Prise en main

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

• 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.
4-16 Prise en main

2 Le composant ActionList étant toujours sélectionné dans la fiche, initialisez sa

propriété Images à ImageList1.
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.
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.
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.
Astuce Vous pouvez aussi cliquer sur la flèche vers le bas à côté du bouton Nouvelle
Action et cliquer sur Nouvelle Action.

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 Name, saisissez AideIndex (pour la commande Aide|Index).
• Après Caption, saisissez &A propos.
• 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.
4-18 Prise en main

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

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.

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-20 Prise en main

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

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.
de l’application.
Remarque Si vous ne voyez pas la fiche, cliquez sur Voir|Fiches, sélectionnez Form1 et
cliquez sur OK.
4-22 Prise en main

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

Effacement de la zone de texte (toutes éditions)
• 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 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.
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.
4-24 Prise en main

Ecriture de gestionnaires d’événements
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.

Jusque 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 :
Cette ligne définit

NomFichier comme
une chaîne accessible
globalement par toutes
les autres méthodes.
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.
4-26 Prise en main

L’éditeur de code s’ouvre avec le curseur placé dans le gestionnaire

d’événement.
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
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 :
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.

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

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.
Utilisez l’éditeur de filtres

pour définir les filtres des
actions FileOpen1.Dialog et
FileSaveAs1.Dialog.
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);
4-28 Prise en main

NomFichier = FileOpen1->Dialog->FileName;
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 :
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.
C’est terminé pour la commande Fichier|Ouvrir et la boîte de dialogue

d’ouverture.

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.
d’événement.
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

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.
Si le fichier n’a pas de

nom, affiche la boîte de
dialogue Enregistrer sous.
Sinon, enregistre le fichier
nommé.
C’est terminé pour la commande Fichier|Enregistrer.

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.
4-30 Prise en main

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);
Une fois terminé, le gestionnaire d’événement FileSaveAs doit avoir l’aspect

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

12 Pour voir ce que donne l’application à ce stade, appuyez sur F9.
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.

Création d’un fichier d’aide
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.
de l’application.

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

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.
4-32 Prise en main


d’événement.
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.
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.
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.
d’événement.
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);

Création d’une boîte de dialogue A propos
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.
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.
C’est tout pour la commande Aide|Index.

De 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.
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.
4-34 Prise en main

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.
contient une boîte
A propos standard que
vous pouvez modifier
à votre guise pour décrire
votre application.
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

Achèvement de l’application
et cliquez sur OK. Remarquez que #include "Apropos.h" a été ajouté au début
du fichier .cpp.
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.
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.
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.
L’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.
4-36 Prise en main

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

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

4-38 Prise en main
Chapitre
Tutoriel : création d’une application

Chapitre 5
5
de base de données CLX
Ce 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ées

De 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,
Tutoriel : création d’une application de base de données CLX 5-1

Création d’une nouvelle application CLX
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 CLX

Avant 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.
5-2 Prise en main

Installation des composants d’accès aux données
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.

Les 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.
5-4 Prise en main

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.

Conception de l’interface utilisateur
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.

Vous 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.
5-6 Prise en main

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.
5-8 Prise en main

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

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.
Vous avez ajouté des actions

standard livrées avec le produit.
Vous les utiliserez sur un menu.

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.

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.
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-10 Prise en main

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

Affichage d’un titre et d’une image
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 :
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.

Vous pouvez ajouter le nom de votre société et une image pour donner à votre
application un aspect plus professionnel :
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.
5-12 Prise en main

Vous pouvez changer

la police du libellé en
utilisant la propriété Font
Cliquez sur les points de
suspension pour afficher
le dialogue standard
des fontes.
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é.
Vous pouvez faire glisser
le bord pour définir la
largeur de Image, ou
définir sa propriété Width
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.

Ecriture d’un gestionnaire d’événements

La 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.
5-14 Prise en main

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->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)
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->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)
else
if(Option == smbCancel)
Action = caNone;
}
}
5-16 Prise en main

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.

5-18 Prise en main
Chapitre
Personnalisation du bureau
Chapitre 6
6
Ce chapitre explique quelques-unes des méthodes permettant de personnaliser
l’EDI de C++Builder.
Organisation de votre espace de travail

L’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.
6-1 Prise en main

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.
Fenêtre principale
organisée
différemment.
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.
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.

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.
6-2 Prise en main

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 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.
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.
Vous pouvez également ancrer les outils entre eux et former une fenêtre
à onglets.
Personnalisation du bureau 6-3

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

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.
Enregistrer le bureau en cours
Les dispositions de bureau Définir le bureau

nommées sont listées ici. de débogage
6-4 Prise en main

Personnalisation de la palette de composants
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.
Entrez un nom pour la disposition de

bureau à enregistrer et cliquez sur OK.

Voir “disposition du bureau” dans l’index de l’aide.

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

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

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.

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.
6-6 Prise en main

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.

Voir “installation des composants” et “paquets” dans l’index de l’aide.
Utilisation des cadres

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

Voir “cadres” et “TFrame” dans l’index de l’aide en ligne.

Définition des options des projets
Ajout de contrôles ActiveX

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

Choisissez Composant|Importer un contrôle ActiveX et cliquez sur le bouton
Aide.
Définition des options des projets

Si 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éfaut

Lorsque 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
6-8 Prise en main

Spécification des modèles de projet et de fiches par défaut
la page Projets, il apparaît dans la liste Objets. Sélectionnez le nom du modèle et

cochez Nouveau projet, puis choisissez OK.
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.
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.

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

Définition des préférences pour les outils
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.
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.
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.

Voir “modèles, ajouter au référentiel d’objets” dans l’index de l’aide en ligne.

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

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.
6-10 Prise en main


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.

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.

6-12 Prise en main
Index
A BDE (Borland Database
Engine) 3-11
contrôles
base de données 3-12
A propos (boîte de dialogue), administrateur 3-12 orientés données 3-12
ajout 4-34 alias 3-12 contrôles, ajout à une fiche 4-3
achèvement du code 2-6 bibliothèques de classes 3-6 conventions typographiques 1-6
actions standard, ajout à une bibliothèques de liaison
application 4-18 dynamique 3-13 D
actions, ajout à une bibliothèques de types 3-14
application 4-9, 4-11, 4-18 DB2 3-11
bitmaps, ajout à une
dbExpress 3-11
ActiveX 3-14 application 4-7, 4-15
installation des contrôles 6-8 débogage des programmes 3-7–
boîtes de dialogue
page de la palette 3-14 3-8, 4-14
modèles 2-5
ADO (ActiveX Data débogueur intégré 3-7
.BPR, fichiers 4-2
défaut
Objects) 3-11 bureau, organisation 6-1–6-5
affectation des touches 6-11 modèles de projet et de
affichage des images 5-12 C fiches 6-8
aide en ligne, fichiers 1-4 options de projet 6-8
aide, conseils 4-4 C++Builder définition des propriétés 3-4,
Aide, F1 1-4 personnalisation 6-1–6-11 4-2, 4-10, 4-12, 4-18
ajout programmation 3-1 démarrage de C++Builder 2-1
composants à une fiche 4-20 cadres 6-7 déploiement des
ajout d’éléments au référentiel classes, définition 4-4 programmes 3-8
d’objets 2-5 clic droit .dfm, fichiers 4-1
ajout de composants à une menus 2-3 Diagramme, page 2-8
fiche 4-3 CLX dictionnaire de données 3-13
ancrage des fenêtres 6-2–6-4 applications, création 3-10 DLL 3-13
applications définition 3-6 documentation
compilation et code imprimée 1-6
débogage 4-14, 4-24 visualisation et recherche 1-3
création 3-10 modification 2-6 données
applications de bases de COM 3-14 modules 3-2
données compilation des
accès 5-3–5-5 programmes 4-24, 5-8 E
arborescence d’objets 2-4 composants
écriture du code 3-5
audit de code 2-6 agencement dans la
EDI
audit de symbole dans palette 6-5
définition 1-1
conseil 2-7 ajout à une fiche 3-2, 4-4
organisation 6-1
bibliothèque de classes
personnalisation 6-1–6-11
B CLX 3-7
définition 4-3
éditeur de bibliothèque de
barres d’outils 2-2–2-3 types 3-14
définition des propriétés 3-4,
ajout à une application 4-14, éditeur de code
4-2
combinaison avec d’autres
4-23 installation 3-13, 6-6
configuration 6-1 fenêtres 6-2
modèles 6-5
personnalisation 6-11
organisation 6-1 personnalisation 3-13, 6-5
base de données exemple 5-1– utilisation 2-6
concepteur de fiche
5-17 éditeur de texte, tutoriel 4-1–
personnalisation 6-10
bases de données 4-37
utilisation 2-4
accès 3-11 éditeur du gestionnaire
conseils d’aide 4-4
explorateur 3-12 d’actions 4-9–4-12
contexte
éditeurs de méthodes de saisie
accès aux menus 2-3
(IME) 3-9
Index I-1
éditions de C++Builder 3-9 fichiers fiche modèles
enregistrement visualisation du code 2-9 ajout au référentiel
dispositions du bureau 6-4 fichiers projet 4-2 d’objets 6-9
projets 4-2 noms par défaut 4-1 spécification comme
en-têtes d’unités, fichiers 4-1 défaut 6-8
environnement de G modèles de code 2-6
développement intégré modèles de composants
gestionnaire de projet 2-9–2-10
(EDI) 2-1 création 6-5
gestionnaires d’événements 3-5,
personnalisation 6-1–6-11 Modification de
5-14–5-17
équivalents clavier 2-3 StatusBar1.Panels, boîte de
création 4-25–4-32
erreurs, messages 4-32 dialogue 4-5
graphiques, affichage 5-12
évaluation d’expression dans module base de données 3-12
groupes de projets 2-10
conseil 2-7 modules de données 2-5, 3-2
GUI, création 3-2, 4-2
événements 5-14–5-17 multiplate-forme
exécutables 3-8 développement
Exécuter, bouton 5-8
I d’applications pour 3-10
exécution d’une images
application 4-14 affichage 5-12 N
exécution des application 4-24, images, ajout à une
newsgroups 1-6
5-8 application 4-7, 4-15
nouveautés 1-3
expert DLL ressource 3-9 Informix 3-11
Nouveaux éléments, boîte de
experts 3-14 inspecteur d’objets 3-6
dialogue
experts (référentiel d’objets) 2-5 présentation 3-4
enregistrement des
explorateur de classe 2-9 référence de composants en
modèles 6-8–6-9, 6-10
utilisation 2-9 ligne 3-5
utilisation 2-5, 4-34
explorateur SQL 3-12 utilisation 3-4, 4-2
installation des composants O
F personnalisés 6-6
InterBase 3-11, 3-12 objets, définition 3-6
fenêtres à onglets, configuration
interfaces utilisateur, ODBC 3-11
de l’EDI 6-3
création 3-2, 4-2, 4-3 options
fenêtres d’outils
internationalisation des projets 6-8
ancrage 6-2
applications 3-9 Options d’environnement, boîte
fenêtres, combinaison 6-2
de dialogue 6-10
fermeture d’une fiche 4-3
fiches
J Options de l’éditeur, boîte de
dialogue 6-11
ajout de composants 3-2, 4-3 jeux de caractères étendus 3-9
Options du projet, boîte de
dans le référentiel
dialogue 6-8
d’objets 2-5 L Oracle 3-11
fermeture 4-3
listes A faire 2-10 outils de traduction 3-9
fichiers 2-9
principales 4-2, 6-9 localisation des applications 3-9
spécification de la fiche par
P
défaut 6-9 M page diagramme 2-8
fiches, fichiers MainMenu, composant 5-10 palette de composants
définition 4-1 makefiles 4-2 définition 2-3
fichiers menus personnalisation 6-5–6-7
enregistrement 4-2 ajout à une application 4-20 utilisation 3-2
fiche 4-1 configuration 6-1 Panel, composant 5-12
projet 4-1 contextuels 2-3 paquets 3-8, 3-9
unités 4-1 dans C++Builder 2-3 définition 6-6
fichiers d’aide, ajout à une organisation 2-2–2-3, 6-1 Paradox 3-11
application 4-32 messages d’erreur 4-32 paramètres du code 2-6
fichiers en-tête 4-1 .pas, fichiers 4-1
I-2 Prise en main

personnalisation propriétés, définition 4-2, 4-10, T
concepteur de fiche 6-10 4-12, 4-18
EDI 6-1–6-11 tutoriel 4-1–4-37, 5-1–5-17
éditeur de code 6-11 R types
palette de composants 2-2 bibliothèques 3-14
raccourcis clavier 2-3
programmation 3-1
programme exemple 4-1–4-37,
référentiel d’objets
ajout des modèles 6-8
U
5-1–5-17
définition 2-5 unités, fichiers 4-1, 6-8
programmes
utilisation 2-5, 3-1
applications CLX 3-10
compilation et
relations parent-enfant 2-4 V
débogage 4-14, 4-24 VCL
projets
S composants 2-3
ajout d’éléments 2-5 serveurs SQL 3-11 utilisation 3-6
création 3-1 services de support 1-6 vue de conception, fermeture
définition des options par site Web de Borland 1-6 des fiches 4-3
défaut 6-8 SQL 3-11
enregistrement 4-2 explorateur 3-12 W
gestion 2-9–2-10 SQL Links 3-11
spécification comme projet Web, site Borland 1-6
SQL Server 3-11
par défaut 6-8 support pour développeurs 1-6
types 3-9–3-13 support technique 1-6
X
propriétés Sybase 3-11 .xfm, fichiers 2-9
définition 3-4
Index I-3
I-4 Prise en main

Intro CPP Builder Borland

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Intro CPP Builder Borland

Загружено:

Авторское право:

Доступные форматы

Prise en main

Ce manuel, Prise en main, présente l’environnement de développement

Qu’est-ce que C++Builder ?

1-2 Prise en main

La deuxième option (enregistrement et activation par téléphone ou navigateur)

Où trouver des informations ?

1-4 Prise en main

Appuyez sur F1 au niveau d’un mot clé ou

Appuyez sur F1 au niveau

Services de support développeur

1-6 Prise en main

Parcours rapide de l’environnement

Parcours rapide de l’environnement 2-1

La vue arborescente de l’objet affiche une représentation

Concepteur de fiche contenant

Le modèle de développement C++Builder repose sur des outils bidirectionnels.

Menus et barres d’outils

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

2-2 Prise en main

Les barres d’outils de C++Builder permettent un accès rapide aux opérations

Ouvrir Tout Ajouter un Voir une Nouvelle Définir le bureau

De nombreuses opérations possèdent des équivalents clavier ainsi que des

Pour plus d’informations...

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

Parcours rapide de l’environnement 2-3

Chaque composant possède des attributs spécifiques (propriétés, événements

Pour plus d’informations...

2-4 Prise en main

Pour plus d’informations...

Pour modifier ou supprimer des objets dans le référentiel d’objets, choisissez

Vous pouvez ajouter,

Cliquez sur les flèches pour

Pour ajouter des modèles de projet ou de fiche au référentiel d’objets, voir

Pour plus d’informations...

Parcours rapide de l’environnement 2-5

Tableau 2.1 Les outils d’audit de code

2-6 Prise en main

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

Pour activer ou désactiver ces outils, choisissez Outils|Options de l’éditeur

Pour plus d’informations...

Navigation dans le code

Utilisez l’éditeur comme

Appuyez sur Ctrl et pointez sur

Pour personnaliser l’environnement de l’éditeur de code, voir “Personnalisation

Pour plus d’informations...

Parcours rapide de l’environnement 2-7

Utilisez les boutons de la barre d’outils

Vous pouvez attribuer un nom et une description à votre diagramme,

Pour plus d’informations...

2-8 Prise en main

Visualisation du code des fiches

Pour plus d’informations...

Pour plus d’informations...

Parcours rapide de l’environnement 2-9

bibliothèque, dans un outil de gestion des projets appelé le gestionnaire de

Vous pouvez utiliser le gestionnaire de projet pour combiner et afficher des

Pour plus d’informations...

Cliquez avec le bouton droit sur une liste

Cliquez ici lorsque vous en avez terminé

Pour plus d’informations...

2-10 Prise en main

Programmation avec C++Builder

Création d’un projet