Ecriture de Composant Delphi - John COLIBRI.

• résumé : exemple complet de création de composant simple, avec propriétés, éditeur de propriété, éditeur de composant
  
• mots clé : Ecriture de composant - Package - DesignIde - DesignIntf - DesignEditors
  
• logiciel utilisé : Windows XP personnel, Delphi 6.0
  
• matériel utilisé : Pentium 2.800 Mhz, 512 Meg de mémoire, 250 Giga disque dur
  
• champ d'application : Delphi 5, Delphi 6, Delphi 7, Delphi 2005, Delphi 2006, Delphi 2007 sur Windows
  
• niveau : développeur Delphi
  
• plan :
  
  • Ecriture de Composant Delphi
    
  • Création d'un composant Delphi
    
  • Quelques Commentaires
    
  • Télécharger le code source Delphi
    

1 - Ecriture de Composant Delphi

Notre composant permet de charger un fichier ASCII, et rechercher un mot dans ce texte, en visualisant en rouge les occurences du mot cherché.

Ce n'est pas le composant le plus révolutionnaire qui soit, et nous n'allons pas utiliser les algorithmes les plus pointus et les possibilités les plus subtiles de Delphi.

En réalité, notre objectif est tout autre: nous allons essentiellement nous attacher à montrer les manipulations à employer et l'organisation du développement d'un composant non trivial.

2 - Création d'un composant Delphi

2.1 - Les Etapes

• tout d'abord nous utilisons une application Delphi usuelle pour mettre en place la fonctionnalité de base. Dans notre cas, charger un fichier ASCII et effectuer des recherches dans une String
  
• ensuite nous séparons les fonctionnalités visées dans dans une CLASS d'une UNIT séparée. L'objet correspondant sera créé par le projet de test dans un événement OnClick
  
• finalement nous utilisons un Package qui contiendra notre composant, et ses fichiers annexes (éditeurs de propriétés et de composant)
  

2.2 - La fonctionnalité de base

Notre tForm principale comporte pratiquement tous les éléments du futur composant: un tRichEdit pour le texte, un tEdit pour la chaîne à rechercher, des boutons pour chercher le suivant etc.

Le click d'un bouton charge un texte d'essai (le fichier .PAS):

Et le clic sur le tButton de recherche ">" effectue le coloriage de toutes les occurences du texte cherché. La recherche est effectuée par un algorithme très naif (recherche du premier caractère puis vérification des suivants) avec création d'un sélection (tRichEdit.SelStart et tRichEdit.SelLength) puis modification des attributs de cette sélection (tRichEdit.SelAttributes):

Voici une vue de notre application p_01_search_memo_design:

Cette étape préliminaire nous a permis

• de mettre en place les parties de notre composants
  
• de tester certains fonctionnalités (la recherche, le coloriage)
  

2.3 - La séparation dans une CLASS

Notre CLASS est définie par:

Les nouveautés sont:

• set_panel_color: colorie le tPanel (rouge lorsqu'il n'y a plus d'occurences)
  
• f_memo_line_of_index: calcule le numéro de ligne en fonction de l'indice
  
• set_memo_top_line_index: assure le positionnement de la chaîne trouvée en haut du tRichEdit
  
• handle_richedit_keypress: gestion de la frappe clavier pour détecter une nouvelle recherche
  
• handle_memo_and_find_edit_keydown et _m_did_hit_control: détection de la touche Ctrl pour la répétition de la recherche par frappe de Ctrl-L
  
• handle_next_click: traitement du click sur le bouton "suivant"
  
• Text (et set_text): définition du texte de base
  
• SearchText (et set_search_text): définition de la chaîne à rechercher
  

et:

• la création de chaque composant se fait en fournissant le "propriétaire" qui assurera sa destruction. Pour tSearchMemo, ce sera le tPanel de la Forme principale, et pour tous les autres sous-composants, c'est tSearchMemo le propriétaire
  
• l'affichage dans une fenêtre fille (avec clipping) est spécifiée par Parent, qui est tSearchMemo pour le tPanel et le tRichEdit, et le tPanel pour les composants placés sur ce tPanel
  

et le chargement du texte est effectué par:

Voici l'image de l'application p_02_search_memo_test:

2.4 - Notez que:

• tout n'a pas encore été mis en place. En particulier, les éléments que nous avons placés dans les éditeurs de propriétés ne sont pas encore présent
  
• tout ne fonctionne pas comme pour un véritable composant. Par exemple:
  
  • nous n'avons pas pu utiliser tRichEdit.HideSelection
    
  • notre composant descent actuellement de tPanel (d'où la bordure un peu trop épaisse) alors que le futur composant descendra de tWinControl
    

2.5 - La création du composant

2.5.1 - Un composant simple

• placer le composant dans une UNIT
  
• cette UNIT doit contenir une procedure Register, qui indique dans quelle page de la Palette le composant doit être placé:

  procedure Register;   begin     RegisterComponents('my_page', [t_my_component]);   end;

  Notez que Register doit avoir un R majuscule (la mécanique d'enregistrement étant sensible à la casse pour cette procédure)

• incorporer le code de l'UNITé dans une .DLL ayant un format particulier, appelée Package.

  Nous avons déjà présenté un article sur les Packages Delphi. Mais nous détaillerons à nouveau ici les étapes utilisées pour la création de composants.

  Notre Package sera créé en utilisant l'Editeur de Package. Et cet Editeur permet

  • de compiler le Package
    
  • d'exécuter la procédure Register, ce qui en fait place le composant sur la Palette
    

2.5.2 - Création du Package

	sélectionnez "File | New | Other"
	Delphi présente plusieurs fichiers:
	cliquez "Package" (encerclé en rouge)
	Delphi crée un nouveau Package
	sélectionnez "File | Save as" et renommez le Package pk_search_memo_simple
	à titre de vérification, vous pouvez compiler en cliquant "compile"
	le répertoire contient (en Delphi 6) les fichiers .DPK, .RES, .DCU, .DOF et .CFG. Les fichiers .DCP et .BPL sont dans le répertoire   C:\Program Files\Borland\Delphi6\Projects\Bpl et sont ainsi visible par l'IDE Delphi
	chargez dans Delphi l'UNITé qui contient tSearchMemo, ajoutez la procédure Register: unit u_c_search_memo_simple;   interface     uses         Classes // tShiftState         , Graphics         , Controls // tMouseButton         , StdCtrls // tEdit         , ComCtrls // tRichEdit         , ExtCtrls // tPanel         ;      type tSearchMemo_simple=               Class(tPanel)                 Private                   m_c_panel: tPanel;                   // -- ...ooo...                 Public                   constructor Create(p_c_owner: tComponent); Override;                   Destructor Destroy; Override;                 Published                   Property Text: String write set_text;                   Property SearchText: String write set_search_text;               end; // tSearchMemo_simple    procedure Register;   implementation     Uses Windows, Messages, SysUtils        ;     procedure Register;       begin         RegisterComponents('ip', [tSearchMemo_simple]);       end; // Register     // -- tSearchMemo_simple     constructor tSearchMemo_simple.Create(p_c_owner: tComponent);     // -- ...ooo... Puis sauvegardez sous u_c_search_memo_simple.pas (dans le même répertoire que le .DPK)
	sélectionnez l'Editeur de Package, vérifiez que c'est bien Contains qui est sélectionné, et cliquez sur "Add"
	l'onglet de chargement de fichier est affiché:
	cliquez "Browse"
	un dialogue de chargement est affiché
	sélectionnez u_c_search_memo_simple.pas et cliquez "Ouvrir", "Ok"
	l'unité du composant est intégrée dans les fichiers contenus dans le Package:
	cliquez sur "Compile"
	le compilateur nous signale que nous devons ajouter certaines unités au Package:
	cliquez "Ok"
	vcl.dcp a été ajouté à la clause Requires:
	cliquez "Compile"
	cliquez "Install"
	un dialogue nous informe des composants installés:
	cliquez "Ok"

• la Palette contient une nouvelle page "ip" qui contient notre composant tSearchMemo_simple (l'icône est celle d'un tPanel, car c'est actuellement l'ancêtre de notre composant):

  

  Nous pouvons donc déposer ce composant dans n'importe quelle tForm.

• et si nous affichons "Component | Install Packages"

  

  Delphi ouvre un dialogue de gestion des composants, qui contient bien notre Package. Si nous sélectionnons cette ligne et cliquons sur "Components", nous pouvons afficher tous les composants de ce Package:

  

• finalement nous pouvons aussi utiliser l'outil de réorganisation de la Palette, en sélectionnant "Component | Configure Palette", puis notre page "ip":

  
  

• nous créons une UNITé qui contient
  
  • la CLASS du composant
    
  • une procédure Register
    
• nous incorporons l'UNITé à un Package, qui est compilé et installé
  

2.6 - Gestion du Composant final

2.6.1 - Unité d'enregistrement

Cette UNITé contient un nom contenant "reg" ou "register", et est simplement ajoutée au Package en utilisant le bouton "Add" de l'Editeur de Package

2.6.2 - Editeurs de Propriété et Editeur de Composant

Si nous créons une propriété pour laquelle il n'existe pas d'Editeur pré-défini, nous pouvons en créer un, ce que nous ferons ci-dessous.

Un problème d'organisation des fichiers se pose alors. En effet, depuis Delphi 6, Borland interdit le déploiement de fichiers utilisant des Editeurs de Package. Cette mesure visait essentiellement à éviter la création trop facile de clones de Delphi. Et par conséquent les UNITés qui seront dans l'.EXE final ne peuvent pas dans leur clauses USES contenir des unités telles que DesignIntf ou DesignEditors.

La solution est simple: il suffit de

• placer les Editeurs dans des UNITés séparées dont la clause USES contient DesignIntf ou DesignEditors
  
• ces Editeurs sont enregistrés par une UNITé d'enregistrement séparée
  
• les UNITés contenant les composants sont ainsi vierge de toute référence aux éditeurs
  

et:

• les éléments faisant appels aux UNITés "design" (au trait rouge sur notre schéma) sont utilisés pour placer le composant et ses éditeurs sur la Palette et dans l'Inspecteur d'Objet
  
• les UNITés contenant nos composant (en trait noir) peuvent être incorporées à n'importe quel .EXE livrable au clients
  

2.7 - Clause Requires des Packages

Nous avons déjà vu plus haut que le Compilateur analysait automatiquement les UNITés dont notre composant a besoin, et qu'il nous proposait d'ajouter les Packages nécessaires.

Les noms placés dans Requires sont des fichiers .DCP (Delphi Component Package, qui est une .DLL Windows).

Comme les formats internes des fichiers binaires change en général entre chaque version Delphi, il faut modifier manuellement le nom des fichiers de la clause Requires et recompiler.

Depuis Delphi 6, cette recompilation a été simplifiée:

• les .DCP de Requires contient des noms génériques
  
• nous pouvons demander à l'Editeur de Package d'ajouter un suffixe de version pour trouver le fichier .BPL.

  Pour cela

  	ouvrez l'Editeur de Package, sélectionnez "Options | Description"
  	Delphi présente les paramètres du Package
  	tapez la version de Delphi, "60" dans notre cas:

  Dans ces conditions:

  • la clause Requires contient le nom des .DCP sans le suffixe. Par exemple
      designide.dcp
    
  • le Package qui est utilisé sera celui correspondant à la version de Delphi. Dans notre cas:
      designide60.bpl
    
  Notez d'ailleurs que dans notre cas, "designide.dcp" n'a pas été suggéré automatiquement par le Compilateur: il a fallu l'ajouter nous-mêmes en utilisant le bouton "Add" (ou en tapant la ligne dans le .DPK)
  

Pour forcer un Package à être un Package de conception, séléctionnez "Editeur de Package | Options | Description" et cliquez "Design Time Only" ou "Design Time and Runtime:

Notez que:

• en général nous incluons dans le nom du Package "design" ou "dsgn" pour que le type du Package soit évident
  
• si vous souhaitiez en plus que le code du Package puisse être séparé du fichier .Exe, il faut créer un second Package (dont le nom contiendrait "run"), et qui ne devra contenir AUCUNE UNITé avec DesignIntf ou DesignEditors.
  

2.7.1 - Utilisation d'un Groupe Delphi

Pour cela, il suffit

• d'utiliser "File | New | Other" et dans l'onglet "New", "Project Group"
  
• d'ajouter l'Editeur de Package et notre Projet au groupe
  

2.8 - Le Composant tSearchMemo

2.8.1 - Création du Groupe Delphi

	créez un répertoire qui contiendra essentiellement notre projet de démonstration, et nommez-le, par exemple, "05_search_memo_demo\"
	sélectionnez "File | New | Other" et dans l'onglet "New" sélectionnez "Project Group"
	Delphi crée un nouveau groupe et l'affiche dans le gestionnaire de projet
	créez un nouveau projet par "File | New Application" et sauvegardez le dans le nouveau répertoire en le renommant, par example, p_05_search_memo_demo
	le projet est ajouté au groupe

2.8.2 - Le Package

	créez un nouveau répertoire qui contiendra tous les fichiers du composant, par exemple "04_component\"
	sélectionnez "File | New | Other"
	Delphi présente les nouveaux fichiers
	cliquez "Package"
	Delphi crée un nouveau Package
	sélectionnez "File | Save as" et renommez le Package pk_search_memo_design dans le répertoire du composant
	dans l'Editeur de Package, sélectionnez "Options | Description"
	Delphi présente les paramètres du Package
	tapez la version de Delphi, "60" dans notre cas et vérifiez que soit "DesignTimeOnly" soit "DesignTime and Runtime" sont bien sélectionnés
	cliquez "Ok"

sélectionnez le gestionnaire de projet, sélectionnez le groupe, et par "clic droit | ajouter projet existant", ajoutez le Package au groupe

• le projet pourra être compilé en sélectionnant le projet, puis "clic droit | compile"
  
• le Package pourra être compilé en sélectionnant le package, puis "click droit | compile", ou "install" pour installer le composant

  
  

2.8.3 - Création de l'Unité d'Enregistrement:

	créez une UNITé u_register_search_memo et placez-y la procédure Register
	ajoutez l'UNITé sans Register au Package, en utilisant l'Editeur de Package ("Add | Browse "...) Nous avons aussi renommé la CLASSE, modifié son ancêtre en remplaçant tPanel par tWinControl, et renommé l'UNITé u_c_search_memo type TSearchMemo= Class(tWinControl)                     Private                       m_c_panel: tPanel;                       // -- ...ooo...  Ceci ne changer rien au reste de la CLASSe
	ajoutez l'UNITé d'enregistrement an Package
	compilez et installez le Package
	le nouveau composant est installé sur la Palette

2.8.4 - Editeur de Propriété

• nous recherchons "text"
  
• nous considérons comme des mots les suites de lettres
  
• dans le texte suivant

    Property text: String write settext;

  la première occurence " text:" est considérée comme un mot isolé, alors que la seconde "settext" fait partie d'un mot
  

Nous allons créer un Editeur qui accepte la syntaxe simplifiée suivante:

donc en gros la même chose que Pascal, moins les guillemets et les virgules (et avec un problème pour définir l'espace, que nous avons glissé sous le tapis dans notre exemple simple)

Pour faciliter la saisie, nous allons proposer à l'utilisateur plusieurs combinaisons possibles. Par exemple:

Notre éditeur

• sera un descendant de tStringProperty
  
• utilisera l'attribut paValueList, qui permet d'afficher nos exemples dans une ComboBox DropDown. Cette valeur sera fournie par la fonction GetAttributes
  
• les valeurs proposées sont ajoutées par la procédure GetValues
  

Par conséquent:

	tapez cet éditeur dans une unité
	ajoutez l'unité au Package

Notre CLASSe comportera une propriété correspondant à la chaîne de l'Editeur, et lorsque l'utilisateur tapera la valeur dans l'Inspecteur d'Objet, cette chaîne sera fournie à la méthode set_word_character_string qui analysera la chaîne et construira l'ensemble de caractères correspondant.

Voici les parties du composant concernées par cet éditeur:

La fonction f_string_to_set_of_char qui convertit la chaîne en un Set of Char est dans le .Zip téléchargeable, et cet ensemble de caractères est utilisé pour détester si les caractères qui précèdent et suivent une occurence sont ou non dans cet ensemble.

2.8.5 - Un Editeur de Composant

Nous avons choisi un simple dialogue de recherche, mais nous aurions pu ajouter au dialogue d'autres paramètres (recherche vers l'avant, vers l'arrière, en tenant compte de la casse ou non). En fait, c'est la nature du composant et de ses propriétés qui détermine si un éditeur de composant est utile ou non. Notre exemple est un peu artificiel, mais montre comment procéder.

Notre Editeur de Composant est donc un dialogue comportant une tDirectoryListBox, une tFileListBox et deux boutons "Ok" et "Cancel". Le choix d'un fichier, et le clic sur "Ok" initialise les propriétés Path et FileName de notre composant, et charge le fichier dans le tRichEdit.

Voici les propriétés ajoutées à notre composant:

et voici le texte de l'éditeur de composant:

et:

• la clause USES importe l'unité du composant, car il faudra pouvoir accéder à l'instance du composant qui sera sur la tForm
  
• la CLASSe qui contient le dialogue est purement statique (aucune méthode)
  
• la CLASSe de l'éditeur comporte 3 méthode:
  
  • GetVerbCount qui indique combien de sous-menu il faut ajouter au menu contextuel
    
  • GetVerb qui fournit le texte du sous-menu
    
  • ExecuteVerb qui récupère les valeurs du dialogue et transfert ces valeurs dans les propriétés du composant. Ce transfert est effectué en surtypant la propriété Component de l'éditeur de propriété
    

2.8.6 - Mise à jour de Register

	ajoutez aux USES de u_c_register_search_memo les UNITés contenant les éditeurs
	enregistrez les deux éditeurs dans la procédure Register

Il faut mettre à jour le Package:

	sélectionnez l'Editeur de Package
	sélectionnez Contains, puis "clic droit | Add" et ajoutez u_f_search_memo_editor
	sélectionnez Requires, puis "clic droit | Add" et tapez     DesignIde.Dcp
	compilez en cliquant "Compile"

Pour voir l'éditeur en action

	sélectionnez la tForm
	ajoutez un tPanel qui contiendra notre tSearchMemo (nous avons aussi mis sur notre tForm un tPanel à gauche et un tMemo en bas)
	sélectionnez dans l'onglet "ip" le tSearchMemo et posez le sur le tPanel
	le composant est affiché:
	le clic droit souris sur le composant affiche le menu contextuel avec au début notre sous-menu "Load Search Memo..."
	cliquez ce sous-menu (ou cliquez deux fois sur SearchMenu1 directement)
	le dialogue de chargement apparaît:
	sélectionnez un fichier ASCII, par exemple u_c_search_memo et cliquez "Ok"
	le texte de l'unité est chargé:

2.8.7 - Le composant à l'exécution

3 - Quelques Commentaires

Quelques remarques:

• Pour un composant sans éditeur de propriété, c'est relativement simple.

  Si vous décidez d'ajouter un éditeur de propriété, les restrictions de déploiement Delphi nécessitent une séparation des UNITés.

  Vous rencontrerez d'ailleurs cet obstacle des Package pour la conception et pour l'exécution chaque fois que vous essayez d'installer des librairies récupérées sur le Web ou achetées à des fournisseurs. Dans le meilleur des cas, vous trouverez plusieurs séries de Packages correspondant aux différentes versions de Delphi, ainsi qu'une séparation entre les composants sensibles aux données ou non. Et dans le pire des cas, vous aurez des sources pour une version de Delphi qui n'est pas la vôtre, et il faudra alors adapter les Packages à votre version

• Sur ce site, nous avons pour tous les projets proposés surtout utilisé des CLASSes, et les objets correspondants ont été créés dynamiquement par l'utilisateur de la CLASSe (en général le projet principal). Cette technique offre les avantages suivants:
  • nous évitons l'installation sur la Palette (qui doit être effectuée à chaque nouvelle version Delphi, ou sur chaque nouvelle machine)
    
  • la CLASSe fait partie du projet, et peut être modifiée à volonté, en communiquant directement avec les autres UNITés.
    
  Les inconvénients sont les suivants:
  • la CLASSe n'a pas besoin d'être aussi bien encapsulée, car elle communique plus facilement avec le projet. Une partie des fonctionnnalités peut être assurée par les autres CLASSes ou par le projet principal
    
  • de ce fait, la réutilisation de la CLASSe sera plus laborieuse
    
  Si nous créons un composant à partir d'une CLASSe, il faut donc s'assurer qu'elle est complètement autonome et cohérente. Prenons notre exemple: pour charger le texte du tRichEdit, nous avons commencé par ajouter la propriété Text. Puis nous avons ajouté les propriétés Path et FileName avec la procédure load_from_file. Mais il faudrait que notre implémentation (qui n'est pas complète) soit plus cohérente: si le composant a des propriétés de nom de fichier, il faudrait pouvoir les utiliser à l'exécution (alors que nous ne les avons employées que pendant la conception)

  Notre exemple de "tSearchMemo" n'est dans ce domaine, pas un modèle du genre. Nous l'avons uniquement utilisé pour illustrer les manipulations à effectuer.

• si votre seul objectif est uniquement de regrouper quelques composants, une autre solution est d'utiliser des tFrames. Ces tFrames permettent de créer des sortes de "morceaux de tFormes" réutilisables

• si vous décidez de placer le composant sur la Palette, les manipulations à effectuer ont été présentées en détail.

  Mais beaucoup plus important, cependant, il faut souligner que nous avons pratiquement escamoté la discussion principale et beaucoup plus importante à nos yeux concernant le choix du type de composants, et les difficultés qui surviennent pour écrire le code des différents types de composants.

  Certes ce n'était pas notre objectif en rédigeant cet article, mais soyez conscients que l'écriture de composant nécessite une bonne connaissance

  • des techniques objets en général
    
  • des spécificités Windows (les librairies Windows)
    
  • de Delphi et de son fonctionnement interne (les traitements en mode conception, les flux, les messages internes, le mécanisme de liaison aux données)
    
  • l'organisation de la VCL (pour les composants dont nous souhaitons hériter, et pour les éditeurs de propriété et de composants)
    

• la Formation Programmation Objet Delphi pour les personnes souhaitant consolider leurs techniques programmation objet
  
• la Formation Ecriture de Composants Delphi pour les personnes qui souhaitent créer et placer leurs composants sur la Palette
  

4 - Télécharger le code source Delphi

• 01_search_memo_design.zip : le premier essai de recherche (24 K)
  
• 02_search_memo_test.zip : l'encapsulation de la recherche dans une CLASS (23 K)
  
• 03_search_memo_simple_component.zip : le package simple (sans éditeurs) (5 K)
  
• 04_search_memo_component.zip : le package avec les éditeurs (9 K)
  05_search_memo_demo.zip : le projet utilisant le composant (24 K)
  

Ce .ZIP qui comprend:

• le .DPR, la forme principale, les formes annexes eventuelles
  
• les fichiers de paramètres (le schéma et le batch de création)
  
• dans chaque .ZIP, toutes les librairies nécessaires à chaque projet (chaque .ZIP est autonaume)
  

• créez un répertoire n'importe où sur votre machine
  
• placez le .ZIP dans ce répertoire
  
• dézippez et les sous-répertoires nécessaires seront créés
  
• compilez et exécutez
  

Comme d'habitude:

• nous vous remercions de nous signaler toute erreur, inexactitude ou problème de téléchargement en envoyant un e-mail à jcolibri@jcolibri.com. Les corrections qui en résulteront pourront aider les prochains lecteurs
  
• tous vos commentaires, remarques, questions, critiques, suggestion d'article, ou mentions d'autres sources sur le même sujet seront de même les bienvenus à jcolibri@jcolibri.com.
  
• plus simplement, vous pouvez taper (anonymement ou en fournissant votre e-mail pour une réponse) vos commentaires ci-dessus et nous les envoyer en cliquant "envoyer" :

  Nom :
  E-mail :
  Commentaires * :

• et si vous avez apprécié cet article, faites connaître notre site, ajoutez un lien dans vos listes de liens ou citez-nous dans vos réponses sur les messageries. C'est très simple: plus nous aurons de visiteurs et de références Google, plus nous écrirons d'articles.
  

5 - L'auteur