Sommaire: Cours Delphi Partie I composants non-visuels

Introduction
I – Qu’est-ce qu’un composant exactement ?
I-A – Définition
I-B – Héritage de TPersistent
I-C – Héritage de TComponent
I-D – Possession et composition
I-E – Réutilisation des composants
I-F – Différences entre développement de composants et d’applications
I-G – Conclusion
II – Création d’un composant non-visuel d’exemple
II-A – Choix du composant à développer
II-B – Le paquet de nos composants
II-C – Le code de base de tout composant
II-D – Sur quoi se base le fonctionnement de notre composant ?
II-E – Fonctionnement de base
II-E-1 – Théorie
II-E-2 – Mise en pratique
II-F – Propriétés dans l’inspecteur d’objet
II-G – Événements
II-G-1 – Théorie
II-G-2 – Mise en pratique
II-H – Valeurs par défaut des propriétés
II-H-1 – Comment Delphi enregistre-t-il les fiches
II-H-2 – Spécificateurs de stockage
II-I – Une dernière retouche
II-J – Code complet de l’unité SelDirDlg
III – Test du composant en le créant dynamiquement
IV – Installer le composant dans la palette de Delphi
IV-A – Un paquet de conception
IV-B – La procédure Register
IV-C – La routine RegisterComponents
IV-D – Recensement du TSelectDirDialog
IV-E – Code complet de l’unité RegComposTuto
IV-F – Installation du paquet
IV-G – Une icône pour le composant
V – Conclusion
VI – Liens utiles
VII – Remerciements

Extrait du cours Delphi

Introduction

Cours Delphi
Pour commencer, nous allons découvrir comment créer des composants non-visuels. Ces composants n’apparaissent qu’en mode design sous forme de petit carré avec une icône. Un exemple très utilisé de composant non-visuels est le TMainMenu.
Certains se diront, en apprenant que l’on va commencer par les composants non-visuels, que cette partie va être très ennuyeuse et auront envie de passer directement à la suivante.
À ceux-là, je répondrai que les composants non-visuels sont aussi utiles que les composants visuels, et qu’ils facilitent souvent des tâches d’une grande complexité. Vous pouvez prendre à titre d’exemple la bibliothèque Indy, dont tous les composants sont non-visuels. Cette bibliothèque est une suite de composants encapsulant des API réseaux.

I – Qu’est-ce qu’un composant exactement ?

Cours Delphi
Premièrement, il semble important de faire le point sur ce sujet.
I-A – Définition
Un composant, au sens où on l’entend généralement, est un objet (au sens commun du terme, et non au sens de la POO) que l’on peut placer sur une fiche Delphi. En théorie, un composant est un descendant (direct ou non) de la classe de base TComponent.
TComponent descend de la classe TPersistent, elle-même descendante de TObject.
I-B – Héritage de TPersistent
TPersistent encapsule le comportement commun à tous les objets pouvant être affectés à d’autres objets et pouvant lire ou écrire leurs propriétés dans un fichier de fiche (fichier .dfm ou .xfm). Cela signifie que les descendants de cette classe seront capables de se recopier via la méthode Assign et également de s’enregistrer dans un flux (stream). Bien entendu, pour que ces capacités soient supportées, il faut implémenter certaines choses.
I-C – Héritage de TComponent
La classe TComponent est l’ancêtre partagé de chaque composant de la VCL. TComponent implémente directement l’une de ces capacités, à savoir le fait qu’il peut être enregistré dans un flux. Nous pouvons remercier Borland de cela, car sinon nous devrions effectuer un travail considérable à chaque fois que l’on créerait un nouveau composant !
Ainsi, tout composant enregistre automatiquement toutes ses propriétés déclarées published (nous verrons plus loin ce que cela signifie ; pour l’instant, contentez-vous de savoir que c’est une directive au même titre que public).
I-D – Possession et composition
TComponent apporte également d’autres fonctionnalités, telles que le fait que tout descendant de TComponent possède un propriétaire (owner) qui se chargera de le détruire lorsque lui-même sera détruit.
On peut effectuer ici un parallèle avec les Lego : il existe des blocs de base avec lesquels on peut en créer de plus complexes.
On retrouve ici la notion de composition de UML. Le propriétaire désigne la relation particulière entre un composant maître et plusieurs objets le constituant. Le propriétaire étant responsable de la libération des parties qui le composent. Les composants ont donc une existence dépendante du composé.
Exemple : Une fenêtre Windows est composée de menus, d’ascenseurs, de boutons… Si la fenêtre est détruite alors tous les composants (menus, ascenseurs, boutons…) sont également détruits.
Chaque objet peut être propriétaire de 0 ou n autres objets. Par contre, il est impossible de créer un cycle de prossession : si, à partir d’un objet donné, on remonte chaque fois à son propriétaire, on ne pourra jamais retrouver le premier objet.

I-E – Réutilisation des composants
Le principal atout de la POO est la réutilisation du code.
Les composants n’échappent pas à cette règle, aussi peut-on, à partir d’un composant, l’améliorer facilement en dérivant un nouveau composant de celui-ci.
I-F – Différences entre développement de composants et d’applications
Extrait de la documentation de Delphi 6 sur les classes et composants
Comme les composants sont des classes, les créateurs de composants manipulent les objets à un niveau différent de celui des développeurs d’applications. La création de nouveaux composants nécessite de dériver de nouvelles classes.
Brièvement, il existe deux différences principales entre la création des composants et leur utilisation dans des applications. Pour la création de composants, vous avez accès à des parties de la classe qui sont inaccessibles aux programmeurs d’applications. Vous ajoutez de nouvelles parties (des propriétés, par exemple) aux composants.
A cause de ces différences, il faut prendre en compte un plus grand nombre de conventions, et réfléchir à la manière dont les développeurs d’applications vont utiliser les composants.
I-G – Conclusion
Bref, les composants permettent à tous les développeurs d’augmenter les possibilités de Delphi, et donc de simplifier le développement d’applications.
Vous savez désormais ce qu’est un composant au sens premier du terme. Nous allons maintenant entrer dans le vif du sujet : la création de votre premier composant !

II – Création d’un composant non-visuel d’exemple
Le meilleur moyen d’apprendre à faire quelque chose, c’est de le faire ! Donc nous allons voir pas à pas comment créer un composant non-visuel.
II-A – Choix du composant à développer
J’ai décidé de réaliser avec vous un composant du nom de TSelectDirDialog.
Vous devriez connaître le composant TOpenDialog, qui permet de sélectionner un fichier à ouvrir. Notre TSelectDirDialog fera plus ou moins de même mais permettra de sélectionner un dossier plutôt qu’un fichier.
Bien entendu nous ne dessinerons pas la fenêtre correspondante : nous utiliserons les APIs de Windows pour utiliser cette boîte classique, tout comme le fait le composant TOpenDialog.
Ce composant permettra donc d’aborder les points suivants :
• Les propriétés affichées dans l’inspecteur d’objet
• La création d’événements
• L’encapsulation des APIs Windows par un composant
• L’installation du composant dans la palette de Delphi
• L’association d’une icône au composant
Voilà un beau programme non ? Alors allons-y !

Cours Delphi
II-B – Le paquet de nos composants
Dans les deux premières versions de Delphi, les composants étaient tous compilés dans une seule et même librairie appelée CmpLib32.bpl. Cette DLL contenait le code de tous les composants installés et il était difficile d’en décharger.
Delphi 3 a apporté les paquets. Désormais, tous les composants seraient compilés dans des paquets. Cela a permis de simplifier énormément le chargement des composants utiles, ce qui devenait presque indispensable au vu des nombreux composants disponibles sur Internet (notamment l’incontournable JVCL).

………

Si le lien ne fonctionne pas correctement, veuillez nous contacter (mentionner le lien dans votre message)
Cours Delphi Partie I: Composants non-visuels (260 KO) (Cours PDF)