Le composant visuel est en fait une classe. Mais pour écrire un contrôle, vous devez utiliser un package. Sélectionnez New dans le menu Fichier et créez un nouveau package. Cliquez ensuite sur le bouton Ajouter dans la fenêtre Package pour ajouter un composant (unité).
Sélectionnez un nouveau composant en haut de la boîte de dialogue contextuelle. Étant donné que tous les attributs, méthodes et événements d'un contrôle ne peuvent pas être composés d'eux-mêmes, vous devez sélectionner la classe d'ancêtre (ou "classe parent" ou "classe de base"), puis ajouter vos propres attributs, méthodes et événements. . Sélectionnez la classe des ancêtres souhaitée dans la boîte déroulante après le type d'ancêtre. Puisque vous devez dessiner une image en écrivant un contrôle visuel, TgraphicControl est sélectionné comme classe d'ancêtre. Entrez ensuite le nom du nouveau contrôle (classe) dans la zone de nom de classe, qui commence généralement par "T". La page de 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", qui peut être pris par vous-même. Ajoutez le chemin d'accès et le nom du fichier du nouveau fichier de contrôle dans le nom du fichier unitaire et cliquez sur le bouton OK. De nouveaux contrôles sont ajoutés. Vous pouvez maintenant écrire du code pour ce contrôle.
Ce qui suit est un exemple d'écriture d'une barre de défilement qui peut personnaliser l'image pour illustrer comment écrire un contrôle visuel.
Suivez la méthode ci-dessus, sélectionnez TgraphicControl comme classe d'ancêtre et le nom du nouveau contrôle est tpighorizontalscroller (barre de défilement horizontal de porc). Après avoir sélectionné le chemin du fichier et le nom du fichier, cliquez sur le bouton OK pour commencer à écrire le code.
Chaque contrôle sera créé et supprimé, vous devez donc d'abord écrire ces deux processus. Pour chaque processus du contrôle, il doit être défini d'abord puis écrit plus tard. Il existe trois types de processus ou d'attributs qui sont définis:
1. Le défini après privé est utilisé en interne pour le contrôle, et la personne qui utilise le contrôle ne peut pas la voir;
2. Ce qui est défini après protégé est généralement invisible et ne peut être vu que lorsque d'autres utilisent le contrôle comme classe d'ancêtre pour écrire d'autres contrôles;
3. Seuls d'autres peuvent être appelés dans le programme après le public;
4. Le défini après la publication peut être vu dans la fenêtre de la propriété (inspecteur d'objet). Étant donné que le processus de création et de suppression n'est pas seulement exécuté automatiquement lorsque le contrôle est créé pendant le processus de programmation, il peut également être appelé lorsque le contrôle est créé dynamiquement pendant l'exécution du programme, il est donc défini après le public. (Ce numéro de séquence indique l'emplacement du code dans le programme source joint, le même ci-dessous) Maintenant, peut-être que je ne sais pas quoi écrire dans ces deux processus et comment le modifier. 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. Étant donné que les attributs ne sont pas utilisés directement dans les programmes, vous devez définir une variable qui correspond à l'attribut, tout en modifiant ou en lisant sa valeur. Puisqu'il n'est utilisé qu'à l'intérieur du contrôle, nous le définissons après ⑵ ⑵. (Généralement, les variables associées aux attributs commencent par "F", comme FMAX) après la définition de la variable, définissez les attributs. Cette propriété doit être visible dans la fenêtre de l'inspecteur d'objet, alors définissez-la et publiez-la après ⑶. La syntaxe définie est:
Propriété <Nom de la propriété>: <ype> Lire <variable de réaction Lors de la lecture de cette propriété> Écrivez <variable de réponse ou processus lors de la rédaction de cette propriété>
D'autres variables et attributs sont également définis de manière similaire (comme la valeur minimale min, la valeur de courant de valeur, etc.). Ci-dessous, nous définissons plusieurs attributs et variables pour définir l'image de la barre de défilement (parce que les variables d'image sont spéciales, je vais en parler séparément). Nous définissons le buttonupicture de gauche (image du bouton de gauche), LeftButTondownPicture (bouton gauche appuyez sur l'image) et ainsi de suite comme type tbitmap (doit définir la variable correspondante).
Tout le monde doit avoir remarqué que dans le programme source ci-joint, lors de la définition de ces propriétés, la variable correspondante lors de la lecture des propriétés spécifiées après la lecture est F ..., et la variable correspondante lors de l'écriture des propriétés spécifiées après écriture n'est pas des variables, mais quelque chose comme Set…, c'est un processus personnalisé. Le processus comme cette fonction est définie comme:
Procédure <Nom du processus> (valeur: <type de valeur de la propriété SET>)
Parce que d'autres choses doivent être faites lors de la rédaction des attributs de cette classe, il ne peut pas être traité avec une seule variable, mais doit être traité avec un processus. Ce processus est généralement défini après protégé. Dans ce processus de classe, une instruction telle que celle-ci à ⑷ est utilisée pour attribuer des valeurs à une variable de type tbitmap, qui est adoptée car les variables de ce type ne peuvent pas être attribuées directement.
Après avoir défini les propriétés de ces variables de type tbitmap, le code doit être écrit dans le processus de création et de détruire mentionné ci-dessus. Étant donné que Tbitmap est également une classe, il doit être créé dans le processus de création ⑸ et libre doit être libéré pendant le processus de destruction. La déclaration héritée mentionnée ici est utilisée pour indiquer que le processus est hérité de la classe des ancêtres. (Cela ne doit pas être abandonné).
Parce que nous écrivons des contrôles visuels, nous devons dessiner des images sur les commandes. La classe des ancêtres de notre contrôle, TgraphicControl, résume un objet en toile, que nous pouvons utiliser directement pour dessiner des images. Si vous n'êtes pas familier avec l'utilisation de Canvas, il est préférable de trouver un livre pour le lire.
Le travail suivant consiste à dessiner des images. Comment dessiner des images sur le contrôle? Il y a un événement de peinture dans la classe d'ancêtre TgraphicControl, qui déclenchera automatiquement lorsque le contrôle doit être repeint. Ce que nous devons faire maintenant, c'est rédiger un programme pour cet événement. Tout d'abord, définissez un objet en toile après protégé. Comme il est déjà dans la classe des ancêtres, il n'est pas nécessaire d'ajouter une explication. Nous utiliserons cet objet pour dessiner. Ensuite, vous devez définir un processus de peinture et écrire le code pour dessiner le contrôle. Définissez d'abord le processus de peinture en public. Puisqu'il est déclenché par la classe des ancêtres, et non par l'utilisateur, la remplacement doit être ajoutée par la suite, sinon le contrôle ne deviendra pas un contrôle visuel car la procédure de peinture ne sera jamais appelée. Écrivons le code du processus de peinture⑽.
Les variables telles que T_Height dans le processus de peinture du programme source attaché à cet article sont utilisées pour économiser la taille des boutons, des curseurs, etc. dans la barre de défilement. , dont la plupart sont corrects, je crois que tout le monde comprendra le fonctionnement de la toile en un coup d'œil. Il convient de noter que le jugement suivant sur la variable Fautosize⑾
FautoSize est une variable booléenne associée à la propriété Autosize du contrôle. Notez que dans le code de contrôle, l'attribut n'est pas appelé directement, mais la variable correspondante est utilisée.
Une fois que le programme a été compilé ici, même si j'ai finalement fait un aperçu de mon nouveau contrôle, il ne peut pas faire défiler. Maintenant, écrivons l'événement de la souris afin que nous puissions le manipuler. La définition du processus d'événement de la souris est très similaire au processus de peinture, sauf que les descriptions des paramètres doivent être ajoutées plus tard.
Les événements de souris sont divisés en Mousedown, Mousemove et Mouseup, et une remplacement doit être ajoutée après la définition. Écrivez ensuite son code plus tard. Remarque: L'événement de la souris ici est la souris…, pas le OnMouse habituel…. Mais à quoi sert la définition dans ⒀? Les définitions de l'événement ici sont toutes les utilisateurs à utiliser, c'est-à-dire que lors de l'utilisation de ce contrôle, ils seront affichés dans la page de l'événement dans l'inspecteur d'objets.
Le code de ces événements de souris est également très simple. Il convient de noter que lorsque vous appelez un événement personnalisé, vous devez d'abord utiliser une telle instruction sur ⒁ pour déterminer si l'utilisateur a un code écrit pour l'événement. Ceci est très important, sinon une erreur se produira dans l'appel.
Tout le monde a remarqué que les événements appelés maintenant sont tous personnalisés, et la méthode de définition est très simple, ce qui est similaire à l'attribut de définition, mais tnotifyEvent lorsqu'il est tapé.
TnotifyEvent est l'événement par défaut, qui est défini comme:
TnotifyEvent = procédure (expéditeur: tobject)
Si vous souhaitez définir une autre forme d'événement, vous devez le faire: écrivez-le d'abord en type puis
<Nom du type d'événement> = Procédure (<Camètre>: <ype>)
Par exemple:
Tcustomevent = procédure (a: entier; b: chaîne);
Puis après la définition publique:
<Nom de l'événement>: <Nom du type d'événement>
Par exemple:
Anevent: tcustomevent;
Après les lire, vous devez comprendre l'ensemble du programme. S'il y a une erreur dans la compilation ou l'opération, veuillez vérifier les points suivants:
1. S'il existe des déclarations héréditaires dans le processus de création et de détruire;
2. Que les variables du type tbitmap créent et libres soient créées ou gratuites;
3. Y a-t-il un nom de contrôle avant le processus, par exemple: tpighizontalscroller.mosemove
Comment déterminer si la souris entre ou quitte le contrôle:
Définissez le processus suivant:
Procédure MouseEnter (var msg: tMessage);
Procédure Mouseleave (var msg: tmessage);
Écrivez simplement le code ci-dessous!
Cette méthode est très utile pour écrire des boutons à trois états!