Le composant visuel est en fait une classe. Pour écrire une classe, vous pouvez l'écrire directement dans le fichier *.pas. Mais pour écrire des contrôles, vous devez utiliser des packages. Sélectionnez Nouveau dans le menu Fichier pour créer un nouveau package. Il s'agit du package utilisé pour stocker et installer le contrôle. Cliquez ensuite sur le bouton Ajouter dans la fenêtre Package pour ajouter un composant (Unité).
Sélectionnez Nouveau composant en haut de la boîte de dialogue contextuelle. Comme il est impossible de programmer vous-même toutes les propriétés, méthodes et événements d'un contrôle, vous devez sélectionner la classe ancêtre (ou « classe parent » ou « classe de base »), puis ajouter vos propres propriétés, méthodes et événements à cela. Sélectionnez la classe d'ancêtre requise dans la liste déroulante après le type d'ancêtre. Puisque l’écriture de contrôles visuels nécessite un dessin, TGraphicControl est sélectionné comme classe ancêtre. Entrez ensuite le nom du nouveau contrôle (classe) dans la zone Nom de classe, commençant généralement par « T ». La page Palette est utilisée pour sélectionner le nom de la page de contrôle du nouveau contrôle dans la fenêtre Delphi, tel que "Standard". Vous pouvez le choisir vous-même. Ajoutez le chemin et le nom de fichier du nouveau fichier de contrôle dans Unit File Name et cliquez sur le bouton OK. De nouveaux contrôles sont ajoutés. Il est maintenant temps d'écrire le code du contrôle.
Ce qui suit prend comme exemple l'écriture d'une barre de défilement permettant de personnaliser les images pour illustrer la méthode d'écriture des contrôles visuels.
Suivez la méthode ci-dessus, sélectionnez TGraphicControl comme classe ancêtre et le nom du nouveau contrôle est TPigHorizontalScroller. Après avoir sélectionné le chemin et le nom du fichier, cliquez sur le bouton OK pour commencer à écrire du code.
Chaque contrôle sera créé (Créer) et supprimé (Détruire), il faudra donc écrire ces deux processus en premier. Pour chaque procédure du contrôle, elle doit d’abord être définie puis écrite ultérieurement. Il existe trois types de processus ou de propriétés définis : 1. Ceux définis après PRivate sont utilisés en interne par le contrôle et ne peuvent pas être vus par les personnes qui utilisent le contrôle. 2. Ceux définis après protected sont généralement invisibles et ne peuvent être utilisés par d'autres que lorsque ; d'autres utilisent le contrôle. Le contrôle n'est visible que lors de l'écriture d'autres contrôles en tant que classe ancêtre ; 3. Ceux définis après public ne peuvent être appelés que par d'autres dans le programme. 4. Ceux définis après publication peuvent être vus dans la fenêtre des propriétés (Objet ; Inspecteur). Étant donné que le processus de création et de suppression est non seulement exécuté automatiquement lors de la création du contrôle lors du processus de programmation, mais peut également être appelé lorsque le contrôle est créé dynamiquement lors de l'exécution du programme, il est défini après public (1). (Le numéro de série indique la position du code de la sous-étape dans le programme source ci-joint, le même ci-dessous) Peut-être que vous ne savez toujours pas ce qui doit être compilé dans ces deux processus et comment le compiler. Nous en parlerons ci-dessous.
Ajoutons d'abord quelques propriétés à ce contrôle. Nous définissons une propriété Max pour définir ou lire la valeur maximale de la barre de défilement. Comme les attributs ne sont généralement pas utilisés directement dans les programmes, une variable doit être définie pour correspondre à l'attribut et sa valeur peut être modifiée ou lue. Comme il n'est utilisé qu'à l'intérieur du contrôle, nous le définissons après private (2). (Généralement, les variables associées aux attributs commencent par "F", comme FMax) Après avoir défini les variables, définissez les attributs. Cette propriété doit être visible dans la fenêtre Inspecteur d'objets, alors définissez-la et publiez-la (3). La syntaxe définie est :
property <nom de la propriété>:<type> read <variable correspondante lors de la lecture de cette propriété> write <variable ou procédure correspondante lors de l'écriture de cette propriété>
D'autres variables et attributs sont également définis de la même manière (tels que la valeur minimale minimale, la valeur actuelle de la valeur, etc.). Ensuite, nous définissons plusieurs propriétés et variables pour définir l'image de la barre de défilement (la variable image étant spéciale, nous en parlerons séparément). Nous définissons LeftButtonUpPicture (image du bouton gauche), LeftButtonDownPicture (image appuyée sur le bouton gauche), etc. comme types TBitmap (les variables correspondantes doivent être définies).
Vous avez dû remarquer que dans le programme source ci-joint, lors de la définition de ces attributs, la variable correspondant à l'attribut lu après lecture est F..., mais la variable correspondant à l'attribut spécifié après écriture n'est pas une Variable, mais quelque chose comme Set ... Il s'agit d'un processus personnalisé. Le processus en tant que fonction est défini comme :
procédure <nom de la procédure>(Valeur : <type de valeur de l'attribut en cours de définition>)
Étant donné que d'autres choses doivent être faites lors de l'écriture de ce type d'attribut, vous ne pouvez pas simplement utiliser une variable pour le gérer, vous devez utiliser un processus pour le gérer. Ce processus est généralement défini après protégé. Dans ce type de procédure, une instruction telle que ⑷ est utilisée pour attribuer une valeur à une variable de type TBitmap. Ceci est adopté car les variables de ce type ne peuvent pas se voir attribuer directement une valeur.
Après avoir défini les propriétés de ces variables de type TBitmap, vous devez écrire du code dans le processus de création et de destruction mentionné ci-dessus. Parce que TBitmap est également une classe, elle doit être créée pendant le processus de création (5) et doit être libérée (gratuitement) pendant le processus de destruction (6). L'instruction héritée mentionnée en ⑺ ici est utilisée pour indiquer que le processus est hérité de la classe ancêtre. (Cela ne doit pas être abandonné).
Parce que nous écrivons un contrôle visuel, nous devons dessiner des images sur le contrôle. La classe ancêtre de notre contrôle, TGraphicControl, encapsule un objet Canvas (canvas), et nous pouvons l'utiliser directement pour dessiner des images. Si vous n'êtes pas encore familier avec l'utilisation de Canvas, c'est une bonne idée de trouver un livre et de le lire.
La prochaine chose à faire est de faire un dessin. Comment dessiner des images sur le contrôle ? Il existe un événement Paint dans la classe ancêtre TGraphicControl, qui est automatiquement déclenché lorsque le contrôle doit être redessiné. Ce qu'il nous reste à faire maintenant, c'est d'écrire un programme pour cet événement. Définissez d’abord un objet Canvas après l’avoir protégé. Puisqu'il existe déjà dans la classe ancêtre, il n'est pas nécessaire d'ajouter d'explication⑻. Nous utiliserons cet objet pour dessiner l'image. Ensuite, vous devez définir un processus Paint et écrire le code pour dessiner le contrôle. Définissez le processus Paint d'abord après public. Puisqu'il est déclenché par la classe ancêtre au lieu d'être appelé par l'utilisateur, le remplacement doit être ajouté par la suite, sinon le contrôle ne deviendra pas un contrôle visuel car le processus Paint ne sera jamais appelé. Ensuite, nous écrirons le code du processus Paint⑽.
Le T_Height et d'autres variables du processus Paint du programme source joint à cet article sont utilisés pour enregistrer la taille des boutons, des curseurs, etc. dans la barre de défilement. Cette partie du programme n'est pas très différente du programme des applications ordinaires. La plupart d'entre eux sont destinés à fonctionner sur la toile, je pense que tout le monde le comprendra en un coup d'œil. Il convient de noter le jugement suivant sur la variable FAutoSize. FAutoSize est une variable booléenne associée à l'attribut AutoSize du contrôle. Elle est utilisée pour définir si la taille du contrôle change avec la taille de l'image. A noter que dans le code du champ, les propriétés ne sont généralement pas appelées directement, mais les variables correspondantes sont utilisées.
À ce stade du programme, vous avez enfin fait une apparition pour votre nouveau contrôle, mais il ne peut pas encore défiler. Écrivons maintenant les événements de souris qui nous permettront de le manipuler. La définition du processus d'événement de souris est très similaire au processus Paint, sauf que les descriptions des paramètres doivent être ajoutées à la fin. Les événements de souris sont divisés en trois types : MouseDown, MouseMove et MouseUp Override doivent être ajoutés après la définition. Ensuite, écrivez son code derrière. Remarque : L'événement de souris ici est Mouse..., pas l'habituel OnMouse.... Mais à quoi sert la définition en ⒀ ? Les définitions d'événements ici sont toutes destinées aux utilisateurs, c'est-à-dire que lorsque le contrôle est utilisé, il sera affiché sur la page Événement dans l'inspecteur d'objets.
Le code de ces événements de souris est également très simple : il détermine les coordonnées de la souris, dessine l'image correspondante sur le canevas, etc., et déclenche en même temps l'événement correspondant. Il convient de noter que lorsque vous appelez un événement personnalisé, vous devez d'abord utiliser une instruction telle que ⒁ pour déterminer si l'utilisateur a écrit du code pour l'événement. C'est très important, sinon une erreur se produira.
Tout le monde a remarqué que les événements qui viennent d'être appelés sont tous personnalisés et que la méthode définie est également très simple. Elle est similaire à la définition de propriétés, sauf que le type est TNotifyEvent.
TNotifyEvent est l'événement par défaut, défini comme :
TNotifyEvent = procédure (Expéditeur : TObject)
Si vous souhaitez définir une autre forme d'événement, vous devez faire ceci : écrivez-le d'abord puis tapez
<nom du type d'événement> = procédure(<paramètre>:<type>)
Par exemple:
TCustomEvent = procédure(a: Integer; b:String);
Définissez-le ensuite après public :
<nom de l'événement> :<nom du type d'événement>
Par exemple:
AnEvent : TCustomEvent ;
Après avoir lu ceci, vous devriez comprendre toute la procédure. Si des erreurs de compilation ou d'exécution surviennent, veuillez vérifier les points suivants :
1. Existe-t-il des instructions héritées dans les processus de création et de destruction ?
2. Les variables de type TBitmap ont-elles été créées et libérées ?
3. Y a-t-il un nom de contrôle avant le processus, par exemple : TPigHorizontalScroller.MoseMove
Comment déterminer si la souris entre ou sort du contrôle :
Définissez le processus suivant :
procédure MouseEnter(var Msg: TMessage); message CM_MOUSEENTER;
procédure MouseLeave(var Msg: TMessage); message CM_MOUSELEAVE;