Utiliser les interfaces sous Delphi. Fonctionnalités de travail avec les interfaces dans Delphi. Éléments d'interface standards
L'article a été rédigé sur la base des résultats d'analyses de programmes rédigés par de jeunes développeurs de notre groupe.
Nous organisons correctement la séquence des composants de commutation
De nombreux utilisateurs, en particulier ceux qui travaillaient auparavant sous DOS, ont l'habitude de basculer entre les champs de saisie non pas avec la souris, mais en utilisant le clavier avec la touche Tab. De plus, c'est beaucoup plus rapide que de sélectionner chaque champ avec la souris. Par conséquent, l’ordre des composants de commutation doit être défini correctement. Cela s'applique à la fois aux composants à l'intérieur de tous les composants du conteneur (panneaux, GroupBox, etc.) et aux composants du conteneur eux-mêmes, s'il y en a plusieurs sur le formulaire.
L'ordre de commutation des composants à l'intérieur du conteneur est spécifié par la propriété TabOrder. Le premier composant à devenir actif est celui dont TabOrder est égal à 0, le second à 1, etc., jusqu'à ce que tous les composants soient énumérés. De plus, le composant possède une propriété TabStop, qui indique si le composant recevra le focus lorsqu'il sera basculé avec la touche Tab. Si vous devez interdire le passage à un composant, définissez son TabStop = false. Dans ce cas, vous ne pouvez basculer vers ce composant qu'à l'aide de la souris.
Il existe des cas où des utilisateurs habitués à basculer avec une certaine clé dans un programme, par habitude, continuent de l'utiliser dans d'autres. Cela arrive souvent avec les utilisateurs de 1C, où la touche Entrée peut être utilisée pour naviguer dans les champs de saisie. Eh bien, nous leur donnerons une telle opportunité dans nos programmes s'ils le demandent. Définissez la propriété KeyPreview du formulaire sur true et écrivez un gestionnaire d'événements OnKeyPress :
Procédure TForm1.FormKeyPress(Sender : TObject; var Key : Char);
commencer
si ord(key)=vk_Return alors
Form1.SelectNext(PriemForm.ActiveControl, vrai, vrai);
fin;
Ce gestionnaire permet de naviguer dans les éléments du formulaire lorsque la touche Entrée est enfoncée. Il est à noter que cette méthode ne fonctionnera pas avec les boutons, car... appuyer sur Entrée sur un bouton provoque un clic sur celui-ci, tandis qu'appuyer sur Tab donne le focus d'entrée au composant suivant dans la séquence de bascule.
Boutons par défaut
Tous les mêmes utilisateurs s'habituent rapidement au fait que dans les boîtes de dialogue d'application, vous pouvez généralement confirmer votre choix avec la touche Entrée et annuler avec la touche Échap. Ne les décevons pas dans nos programmes, d'autant plus que c'est très simple à faire. Pour un bouton qui répond à Entrée, définissez la propriété Default sur true. Pour le bouton qui répond à Esc, définissez la propriété Cancel sur true. C'est tout.
Oui ou non
Tous Boîtes de dialogue, demandant des actions à l'utilisateur, doit comporter au moins deux boutons : confirmation de l'action et refus de l'action (Oui/Non, Enregistrer/Annuler, etc.). L'action peut être annulée en fermant la fenêtre avec le bouton [X] dans le titre de la fenêtre. C'est inacceptable s'il n'y a qu'un seul bouton pour confirmer l'action, et pour la refuser, il faut fermer la fenêtre avec le bouton [X] dans le titre, ou il n'y a aucune possibilité de refus du tout. Cela déroute l'utilisateur, soulevant une question logique : comment refuser ?
N’oubliez pas non plus ce qui a été dit ci-dessus dans le paragraphe « Boutons par défaut ».
Toutes les boîtes de dialogue doivent s'ouvrir au centre de l'écran
Centrés, pas là où ils ont été créés en mode conception. Premièrement, il est plus visuel et, deuxièmement, il élimine automatiquement le problème des différentes résolutions d'écran pour différents utilisateurs.
Une exception est faite si la boîte de dialogue n'est pas modale et qu'en raison du travail de l'utilisateur dans cette fenêtre, des modifications se produisent immédiatement dans la fenêtre principale (par exemple, filtrer un ensemble de données, redessiner des graphiques, etc.).
La taille des fenêtres ne doit pas dépasser la taille de l'écran
Dans aucun cas. C'est une honte lorsqu'une partie de la fenêtre dépasse de l'écran. Cette exigence ne dépend pas de la résolution de l’écran de l’utilisateur, c’est-à-dire des excuses telles que « Laissez-les définir une résolution plus élevée » ne fonctionnent pas.
Redimensionnement correct des éléments de fenêtre
Les éléments de la fenêtre doivent être redimensionnés ou déplacés correctement lorsque la fenêtre est redimensionnée, lorsque la fenêtre est agrandie et lorsque la fenêtre est restaurée après la maximisation.
Tout est toujours visible
La réduction de la taille de la fenêtre ne doit pas entraîner la disparition des éléments de la fenêtre et, de préférence, ne doit pas conduire à l'apparition de barres de défilement (défileurs) de la fenêtre elle-même. Vous pouvez limiter les tailles minimales des fenêtres afin que tous les éléments soient visibles et accessibles. S'il n'est pas possible de placer les composants de manière à ce qu'ils soient tous visibles dans la fenêtre, vous pouvez utiliser des signets (tels que PageControl) pour diviser les composants en groupes. Nous n’ignorons pas non plus les excuses concernant la résolution de l’écran.
Des indices partout, des indices toujours
Pour les boutons, en particulier sur les barres d'outils (telles que ToolBar), des astuces doivent être spécifiées afin qu'il soit toujours clair pourquoi tel ou tel bouton est nécessaire.
Spectre de couleurs
Vous ne devez pas peindre les composants du formulaire dans toutes les couleurs de l’arc-en-ciel. Cela fatigue les yeux et détourne l'attention de l'utilisateur. Ça n'a pas l'air "cool". La mise en évidence est utilisée lorsqu'il est nécessaire d'attirer l'attention de l'utilisateur sur un élément spécifique ou une partie spécifique de la fenêtre. Par exemple, coloriez les enregistrements contenant des erreurs en rouge clair ou, à l'inverse, enregistrez les enregistrements qui ont été vérifiés avec succès en vert clair.
Conclusion
Il existe une très bonne méthode qui permet de trouver des failles dans le programme en général et dans l'interface en particulier. C'est simple : imaginez-vous à la place de l'utilisateur et pendant une demi-heure essayez de travailler comme il travaille. C'est encore mieux si votre utilisateur est à portée (par exemple, s'il travaille dans la même organisation). Dans ce cas, asseyez-vous à côté de lui, ou mieux encore, à sa place, et essayez de faire son travail. Saisir des données, les modifier, afficher des rapports, etc. Si vous ne savez pas comment procéder correctement, demandez à votre utilisateur. N'effectuez pas seulement une ou deux opérations du même type, comme en mode débogage, mais 20 à 30, voire plus, opérations différentes, dans des ordres différents. Oubliez de saisir quelque chose ou saisissez-le de manière incorrecte et voyez comment le programme y réagit. Vous verrez rapidement les faiblesses de votre programme.
L'auteur de l'article a automatisé le travail du comité d'admission de l'université et, au cours de la première année d'introduction du programme, il a passé 3 à 4 heures par jour au sein du comité d'admission, enregistrant les candidats, en remplissant leurs données personnelles et en leur donnant rapports d'examens. Et pour le reste temps de travail erreurs et lacunes corrigées. Croyez-moi, l'année prochaine, il n'y aura pratiquement aucun problème. La même chose s'est produite lors de l'introduction du module personnel.
Gardez donc à l’esprit l’expérience utilisateur. Rendez-leur facile et agréable de travailler avec vos programmes.
Un et le plus forces environnement Programmation Delphi est son architecture ouverte, grâce à laquelle Delphi permet une sorte de métaprogrammation, permettant de « programmer l’environnement de programmation ». Cette approche traduit Delphi en produits de haute qualité nouveau niveau systèmes de développement d'applications et vous permet d'intégrer des outils supplémentaires dans ce produit qui prennent en charge presque toutes les étapes de création systèmes d'application. Un si large éventail de possibilités s'ouvre grâce au concept d'interfaces dites ouvertes implémentées dans Delphi, qui constituent le lien entre l'IDE (Integrated Development Environment) et les outils externes.
Cet article est dédié aux interfaces ouvertes de Delphi et donne un aperçu des fonctionnalités qu'elles offrent. Delphi définit six interfaces ouvertes : l'interface outil, l'interface de conception, l'interface expert, l'interface de fichier, l'interface d'édition et l'interface de contrôle de version. Il est peu probable que dans le cadre de cet article nous puissions aborder et illustrer en détail les capacités de chacun d'eux. Les textes sources Delphi vous aideront à mieux comprendre les problèmes considérés, heureusement, les développeurs leur ont fourni des commentaires détaillés. Les déclarations des classes représentant les interfaces publiques sont contenues dans les modules correspondants dans le répertoire...\Delphi\Source\ToolsAPI. La Design Interface (module DsgnIntf.pas) fournit des outils pour créer des éditeurs de propriétés et des éditeurs de composants.
Les éditeurs de propriétés et de composants sont un sujet digne d'une discussion séparée, rappelons donc simplement que l'éditeur de propriétés contrôle le comportement de l'inspecteur d'objets lorsqu'il tente de modifier la valeur de la propriété correspondante, et que l'éditeur de composants est activé lorsque double-cliquez bouton gauche de la souris sur l'image du composant placé sur le formulaire. L'interface de contrôle de version (module VCSIntf.pas) est destinée à créer des systèmes de contrôle de version. Depuis la version 2.0, Delphi prend en charge le système de contrôle de version intégré Intersolv PVCS, donc dans la plupart des cas il n'est pas nécessaire de développer votre propre système. Pour cette raison, nous omettrons également de prendre en compte l’interface de contrôle de version. L'interface de fichiers (module FileIntf.pas) permet de remplacer le système de fichiers de travail de l'EDI, ce qui permet de choisir votre propre méthode de stockage des fichiers (dans les champs Mémo du serveur de base de données par exemple). Edit Interface (module EditIntf.pas) donne accès au tampon de texte source, qui vous permet d'analyser et de générer du code, de déterminer et de modifier la position du curseur dans la fenêtre de l'éditeur de code, et également de contrôler la mise en évidence syntaxique du texte source.
Les classes spéciales fournissent des interfaces aux composants placés sur le formulaire (définition du type de composant, obtention de références aux composants parents et enfants, accès aux propriétés, transfert de focus, suppression, etc.), au formulaire lui-même et au fichier de ressources du projet. Edit Interface permet également d'identifier les notificateurs dits modulaires qui déterminent la réaction à des événements tels que la modification du texte source d'un module, la modification d'un formulaire, le renommage d'un composant, l'enregistrement, le renommage ou la suppression d'un module, la modification d'un fichier de ressources de projet, etc. L'interface d'outil (module ToolIntf. pas) fournit aux développeurs un moyen d'obtenir informations générales sur l'état de l'EDI et effectuer des actions telles que l'ouverture, la sauvegarde et la fermeture de projets et de fichiers individuels, la création d'un module, l'obtention d'informations sur le projet en cours (nombre de modules et de formulaires, leurs noms, etc.), l'enregistrement système de fichiers, organisation des interfaces vers les modules individuels, etc. En plus des notificateurs modulaires, Tool Interface définit des notificateurs complémentaires qui notifient des événements tels que l'ouverture/la fermeture de fichiers et de projets, le chargement et l'enregistrement d'un fichier de projet de bureau, l'ajout/l'exclusion de modules de projet, l'installation/désinstallation de packages, la compilation d'un projet et in Contrairement aux notificateurs modulaires, les notificateurs complémentaires vous permettent d'annuler l'exécution de certains événements.
De plus, l'interface outil fournit un moyen d'accéder au menu principal de l'IDE Delphi, vous permettant d'y intégrer des éléments supplémentaires. L'interface expert (module ExtIntf.pas) constitue la base de la création d'experts - des modules logiciels intégrés à l'EDI pour étendre ses fonctionnalités. Un exemple d'expert est l'assistant de formulaire de base de données Delphi, qui génère un formulaire permettant d'afficher et de modifier le contenu d'une table de base de données. Après avoir défini la classe d'experts, nous devons nous assurer que Delphi « apprend » à connaître notre expert. Pour ce faire, vous devez l'enregistrer en appelant la procédure RegisterLibraryExpert, en lui passant une instance de la classe expert en paramètre. À titre d'illustration, créons un simple expert dans le style esStandard qui, lorsque vous sélectionnez l'élément de menu Delphi correspondant, affiche un message indiquant qu'il est en cours d'exécution. Comme vous pouvez le voir dans le tableau ci-dessus, le style esStandard nécessite le remplacement de six méthodes :
Pour que l'expert soit « mis en action », vous devez sélectionner l'élément de menu Composant/Installer le composant..., sélectionner le module contenant l'expert (dans notre cas exmpl_01.pas) dans la boîte de dialogue Parcourir, cliquer sur OK et après avoir compilé le package dclusr30.dpk Dans le menu principal Delphi, dans la section Aide, l'élément Simple Expert 1 doit apparaître, une fois sélectionné, le message d'information « Standard Expert démarré ! » apparaît. La raison pour laquelle Delphi place l'élément de menu expert dans la section Aide reste un mystère. Si vous n'aimez pas le fait que l'élément de menu apparaisse là où Delphi veut, et non où vous le souhaitez, l'option suivante est possible : créer un expert dans le style du complément, ce qui élimine la création automatique de l'élément de menu, et ajoutez l'élément de menu « manuellement » à l'aide de l'interface de l'outil. Cela vous permettra de définir l'emplacement du nouvel élément dans le menu principal de manière arbitraire.
Pour ajouter un élément de menu, utilisez la classe TIToolServices - la base de l'interface outil - et les classes TIMainMenuIntf, TIMenuItemIntf, qui implémentent des interfaces avec le menu principal de l'EDI et ses éléments. Une instance de la classe ToolServices TIToolServices est créée par l'EDI lui-même lors de son initialisation. Veuillez noter que la responsabilité de la publication des interfaces du menu principal Delphi et de ses éléments incombe entièrement au développeur. En chemin, compliquons un peu la charge fonctionnelle de l'expert : lorsque vous activez son élément de menu, il délivrera un certificat sur le nom du projet ouvert dans ce moment dans l'environnement : Dans cet exemple, la place centrale est occupée par la fonction AddIDEMenuItem, qui ajoute un élément de menu au menu principal de l'IDE Delphi. En paramètres, il reçoit le texte du nouvel élément de menu, son identifiant, l'identifiant de l'élément devant lequel le nouvel élément est inséré, la représentation symbolique de la touche qui, avec la touche Ctrl, peut être utilisée pour accès rapideà un nouvel élément, et un gestionnaire d'événements correspondant à la sélection d'un nouvel élément. Nous avons ajouté un nouvel élément de menu dans la section Affichage avant l'élément Montres.
Faisons maintenant connaissance avec les notifiants. Définissons un notificateur complémentaire qui suit la fermeture/ouverture des projets et ajuste le champ stockant le nom du projet actif en conséquence (nous omettrons l'implémentation des méthodes qui n'ont pas subi de modifications par rapport à l'exemple précédent par souci de concision) : implémentons le notificateur, nous avons défini la classe TAddInNotifier, qui est un descendant de TIAddInNotifier, et remplacé la méthode FileNotification. L’EDI appellera cette méthode chaque fois qu’un événement se produit auquel le notificateur de complément peut répondre (chacun de ces événements est indiqué par une constante correspondante de type TFileNotification). Le champ Expert de la classe TAddInNotifier est utilisé pour retour avec un expert (méthode TAddInNotifier.FileNotification). Dans le destructeur de l'expert, le notifiant n'est pas enregistré et le notifiant est détruit. Illustrons maintenant l'utilisation des notificateurs modulaires. Créons un expert du complément qui émet des messages sur chaque acte de sauvegarde d'un fichier de projet (par souci de brièveté, nous ne présentons pas la mise en œuvre de méthodes qui nous sont déjà familières) : Dans cet exemple, l'expert du complément surveille les événements correspondant à l’ouverture/fermeture des projets.
Chaque fois qu'un projet est ouvert, un notificateur modulaire correspondant au fichier du projet est enregistré. En termes d'implémentation, les notificateurs modulaires sont similaires aux notificateurs complémentaires : nous définissons la classe TModuleNotifier, qui est un descendant de TIModuleNotifier, et remplaçons ses méthodes Notify et ComponentRenamed. L'IDE appelle la méthode Notify lorsque certains événements liés à ce module se produisent ; Dans le cadre de cette méthode, la réaction à un événement particulier est déterminée. La méthode ComponentRenamed est appelée lorsque le nom d'un composant sur le formulaire de module est modifié. Veuillez noter que nous n'utilisons pas cette méthode, mais nous devons la remplacer, sinon lorsque le nom du composant change, une méthode abstraite de la classe de base sera appelée, ce qui entraînera des conséquences imprévisibles.
L'enregistrement d'un notificateur modulaire est un processus légèrement plus complexe que l'enregistrement d'un notificateur complémentaire : nous obtenons d'abord l'interface du module (TIModuleInterface), puis enregistrons le notificateur à l'aide de l'interface du module. Lorsque le projet est fermé, le notificateur modulaire est désenregistré (encore une fois en utilisant TIModuleInterface) et le notificateur est détruit. En conclusion, nous montrerons comment déterminer la position du curseur dans la fenêtre de l’éditeur de code. Créons un expert qui, lors de la sélection de l'élément de menu approprié, afficherait un message contenant le nom du fichier actif et la position du curseur dans celui-ci (l'implémentation uniquement des méthodes essentielles pour cet exemple est affichée) : Pour déterminer la position du curseur, nous devons obtenir la séquence d'interfaces suivante : interface modulaire (TIModuleInterface) ; interface de l'éditeur de code (TIEditorInterface) ; interface de présentation du module dans la fenêtre de l'éditeur (TIEditView).
Si, lors de la sélection d'un élément du menu expert, le fichier texte source (*.pas) est actif, un message s'affiche contenant le nom du fichier actif et la position actuelle du curseur dans celui-ci. Si le fichier actif n'est pas un fichier pas, le message n'est pas émis. Pour obtenir le nom du fichier actif, utilisez la méthode GetCurrentFile de la classe TIToolServices. Ceci conclut notre réflexion sur les moyens d'utiliser les interfaces ouvertes. Le CD-ROM contient le code source de tous les exemples donnés. Le CD-ROM contient également un exemple plus complexe et détaillé, contenant un complément expert qui permet à l'utilisateur de mettre en signet le texte source des modules Delphi. Un bref guide d'installation et d'utilisation de Bookmarks Expert est contenu dans le fichier bkmrks97.htm. Ainsi, cet article donne un aperçu général des interfaces ouvertes et fournit des exemples de leur utilisation. Répétons-le encore une fois : grâce à la disponibilité des codes sources pour les interfaces ouvertes, vous pouvez facilement comprendre les détails qui vous intéressent. Nous espérons que la variété des possibilités offertes par les interfaces ouvertes vous donnera plus d'une idée audacieuse et utile.
seulement pour le résultat
respect strict des délais
Transparence
la mise en œuvre du projet
support technique en cadeau
Programmation, modifications, consultations sur 1C
Comment nous travaillons
1. Nous discutons du problème par téléphone. En présence de accès à distance- afficher sur l'écran de votre ordinateur.
2. Nous estimons le travail en roubles si le projet est de grande envergure, sinon le nombre approximatif d'heures.
3. Nous faisons le travail.
4. Vous acceptez le travail de votre programme, s'il y a des défauts, nous les corrigeons.
5. Nous émettons une facture, vous payez.
Coût des travaux
1. Tous les travaux sont répartis en 3 catégories : consultation, mise à jour d'une configuration standard, élaboration ou programmation d'un nouveau rapport, traitement, bouton, etc.
3. Les travaux de plus de 10 heures doivent être préparés à l'avance. tâche technique avec description et coût des travaux. Les travaux commencent une fois que les spécifications techniques ont été convenues avec vous.
Soutien technique
1. Si vous constatez des erreurs dans un travail précédemment accepté dans un délai de 3 mois, nous les corrigeons gratuitement.
2. Pour les clients réguliers, nous corrigeons gratuitement les défauts de notre travail dans un délai d’un an.
Logiciel pour gérer votre entreprise.
Acheter 1C:Entreprise
Nous sommes revendeur officiel Société 1C, vous pouvez acheter chez nous divers produits logiciels et les licences. En plus de l'achat de la « box », nous vous aiderons à mettre en place le programme, vous conseillerons et effectuerons les réglages de base.
- Comptabilité
- Automatisation du magasin
- De gros
- Aide à l'installation et la configuration initiale inclus dans le forfait !
- Ajuster les configurations aux besoins du client, développer de nouveaux modules en l'absence des fonctions nécessaires dans la configuration standard.
 |
 |
 |
 |
| comptabilité 1c | 1C : Gestion commerciale | 1C : Commerce de détail | 1C : Gestion des salaires et du personnel |
| À partir de 3300 roubles. | À partir de 6700 roubles. | À partir de 3300 roubles. | À partir de 7 400 roubles. |
Mise à disposition du serveur.
Configuration instantanée du serveur + 1C.
Pas de serveur ? Pas de problème, nous sélectionnerons et mettrons en place rapidement un serveur dans le cloud. Pour une somme modique, vous obtenez une solution très fiable.
- Disponibilité 24h/24 et 7j/7
- Pas besoin de garder le vôtre administrateur du système(les économies couvriront les coûts de votre serveur).
- Configuration et installation rapides de 1C sur le serveur, en 3 jours vous disposerez déjà d'un système entièrement fonctionnel.
- Vous pouvez vous déplacer vers serveur local, si la solution n'est pas satisfaisante.
SMS depuis votre 1C
Voulez-vous que vos clients soient informés des promotions et des réductions ? Les clients ne reviennent pas ? Configurez l'envoi de SMS directement depuis 1C !
Notre société pourra mettre en place rapidement l'envoi de SMS à vos clients directement depuis 1C. Exemples d'événements pouvant être automatisés :
- Merci pour l'achat et les bonus sont attribués immédiatement après le prochain achat.
- Accumulation de bonus sur la carte en cadeau pour un anniversaire/autre événement important ou un jour férié.
- Notification de l'arrivée des marchandises à l'entrepôt.
- Expiration des bonus cadeaux.
- Notification de réception de l’acompte et réservation des marchandises.
- Adresse avec indications pour se rendre au magasin/bureau, numéros de téléphone.
- Et ainsi de suite.
La mise en place en 1C peut être réalisée par nos spécialistes ou vos collaborateurs. Vous pouvez consulter les tarifs sur la page des tarifs SMS.
- Envoi de SMS garanti, l'argent n'est facturé que pour les SMS envoyés.
- Tarification séparée pour chaque SMS.
- Rechargez votre solde de différentes manières.
- Consultez l'historique de tous les SMS envoyés à tout moment.
- Le nom de l'expéditeur au lieu du numéro numérique indiqué sur le téléphone du destinataire du message.
La programmation orientée objet (POO), outre le concept de classe, fournit également le concept fondamental d'interface.
Qu'est-ce qu'une interface et quelles sont les fonctionnalités de son utilisation dans le langage de programmation Delphi ?
L'interface est une construction sémantique et syntaxique dans le code d'un programme utilisée pour spécifier les services fournis par une classe ou un composant (Wikipedia).
Essentiellement, une interface définit une liste de propriétés et de méthodes qui doivent être utilisées lorsque l'on travaille avec la classe implémentée par cette interface, ainsi que leur signature (nom, type de données, paramètres acceptés (pour les procédures et fonctions), etc.). Ainsi, une classe qui implémente une interface particulière doit implémenter tous ses composants. De plus, en stricte conformité avec la manière dont ils y sont décrits.
Les interfaces sont souvent comparées à des classes abstraites, mais malgré toutes les similitudes, cette comparaison n'est pas tout à fait correcte. Au minimum, les classes abstraites vous permettent de contrôler la visibilité des membres. Dans le même temps, les portées ne sont pas définies pour les interfaces.
Les interfaces permettent de rendre l'architecture plus flexible, car elles unifient l'accès à telle ou telle fonctionnalité, et permettent également d'éviter un certain nombre de problèmes liés à l'héritage de classe (les interfaces peuvent également être héritées les unes des autres).
Pour déclarer une interface dans Delphi, utilisez le mot-clé interface. C'est le même mot-clé qui définit la section du module accessible de l'extérieur (entre les mots-clés d'interface et d'implémentation). Cependant, lors de la déclaration d’une interface, une syntaxe différente est utilisée, similaire à celle utilisée pour déclarer des classes.
Delphes/Pascal
IMyNewInterface = procédure d'interface InterfaceProc ; fin;
IMaNouvelleInterface =interface procédure InterfaceProc ; fin ; |
Ainsi, la syntaxe de déclaration d'interface elle-même n'est pas fondamentalement différente des autres langages de programmation (les caractéristiques de la syntaxe basée sur Pascal ne comptent pas). Parallèlement, la mise en œuvre des interfaces présente un certain nombre de caractéristiques.
Le fait est que les interfaces Delphi ont été initialement introduites pour prendre en charge la technologie COM. Par conséquent, l'interface IInterface, qui dans Delphi est l'ancêtre de toutes les autres interfaces (une sorte d'analogue de TObject), contient déjà trois méthodes de base pour travailler avec cette technologie : QueryInterface, _AddRef, _Release. Par conséquent, si une classe implémente une interface, elle doit également implémenter ces méthodes. Même si cette classe n'est pas destinée au travail COM.
En raison de cette fonctionnalité de l'interface IInterface, dans Delphi, l'utilisation d'interfaces conduit dans la plupart des cas à l'ajout de fonctionnalités manifestement inutilisées à la classe.
Il existe une classe de bibliothèque TInterfaceObject qui contient déjà l'implémentation de ces méthodes et, si vous en héritez, il n'est pas nécessaire de les implémenter vous-même. Mais comme Delphi ne prend pas en charge l'héritage de classes multiples, son utilisation ne fait souvent qu'entraîner des difficultés supplémentaires dans la conception et la mise en œuvre de fonctionnalités déjà requises.
Tout cela a conduit au fait que, malgré toutes les possibilités offertes par les interfaces, elles utilisation pratique Dans Delphi, presque rien n'est allé au-delà du travail avec COM.
Étant optimisées pour fonctionner principalement avec cette technologie, les interfaces, ou plutôt les fonctionnalités et restrictions architecturales qu'elles ajoutent nécessairement, ne se justifient pas pour résoudre d'autres problèmes.
Par conséquent, de nombreux programmeurs Delphi sont encore, en fait, privés d’un outil puissant et flexible pour développer une architecture d’applications.
Création interface l'utilisateur est réduit à sélectionner parmi une palette de composants nécessaires au fonctionnement du programme Composants Delphi, employés interface la direction, ainsi que interface afficher les informations et les transférer vers le formulaire avec une mise en page ultérieure.
L'interface utilisateur que vous créez doit utiliser des éléments standard familiers aux utilisateurs et offrir un maximum de commodité. Tout cela est finalement déterminé par un critère tel que l'efficacité de l'interface - un maximum de résultats avec un minimum d'effort.
Les principes de création d'une interface conviviale sont connus. Comme principes les plus généraux lors de la création Les interfaces des utilisateurs Trois points principaux peuvent être considérés :
- Le programme doit aider à accomplir une tâche et non devenir cette tâche.
- Lorsqu'il travaille avec le programme, l'utilisateur ne doit pas se sentir idiot.
- Le programme doit fonctionner de manière à ce que l'utilisateur ne considère pas l'ordinateur comme un imbécile.
Deuxième principe est de négliger les capacités intellectuelles des utilisateurs. D'après ma propre expérience, je sais que souvent les utilisateurs non seulement ne savent pas travailler sur un ordinateur, mais ont simplement peur de faire quoi que ce soit par eux-mêmes. Par conséquent, l’interface utilisateur doit être aussi conviviale que possible.
De plus, les craintes des utilisateurs sont souvent justifiées, car le coût du programme, et même de l’ordinateur lui-même, ne peut être comparé au coût, par exemple, d’une base de données créée au cours de nombreuses années d’efforts. C'est pourquoi, lors de la création d'une interface utilisateur, un programmeur doit toujours intégrer une « protection infaillible » dans le programme - contre les actions incorrectes et la saisie par l'utilisateur de données incorrectes. Mais certains programmeurs se laissent trop emporter par une telle protection, la rendent trop intrusive, et du coup, le fonctionnement du programme ressemble au fameux « un pas à gauche, un pas à droite est considéré comme une évasion » ! Et ce que le programmeur crée comme solution à un problème commence à créer lui-même des problèmes.
Se conformer deuxième principe il n'est pas nécessaire de permettre au programme de « corriger » les actions de l'utilisateur et d'indiquer exactement comment il doit agir, le contraignant ainsi à rester dans un cadre étroit. De plus, vous ne devez pas trop vous laisser emporter par l'affichage de messages d'invite d'information, en particulier de dialogue, car cela distrait l'utilisateur du travail. Il serait préférable de fournir la possibilité de désactiver complètement les indices.
Troisième principe est de créer un programme doté des capacités « mentales » les plus élevées possibles. Malgré le développement rapide équipement informatique, même les programmes largement utilisés ne peuvent être qualifiés que de manière très conditionnelle d'intelligence artificielle. Ils interfèrent avec le travail de l'utilisateur en affichant des boîtes de dialogue avec des questions stupides qui prêtent à confusion même dans les situations les plus simples. Du coup, les utilisateurs s’exclament dans leur cœur : « Quelle stupide machine !
Personnellement, je suis irrité par les questions constantes de presque tout le monde. éditeurs de texte sur l'opportunité d'enregistrer le texte modifié, bien que le texte original et actuel ne diffèrent par aucun symbole. Oui, j'ai tapé quelque chose, mais ensuite j'ai tout renvoyé, est-ce vraiment impossible de le comprendre ! Je dois vérifier si je n'ai finalement rien gâché.
Essayez de respecter les règles suivantes :
Éléments d'interface standards
Utilisez des composants standard pour cet élément d'interface. Après avoir rencontré votre programme, l'utilisateur ne perdra pas de temps à se connaître, mais commencera immédiatement à travailler - c'est l'un des signes d'un programme conçu par des professionnels.Petite palette d'outils
Essayez de ne pas utiliser trop de composants différents. Et bien sûr, après avoir utilisé un composant standard quelque part au même endroit, utilisez-le également dans un cas similaire.Espacement égal entre les commandes
Placez les éléments de l'interface à la même distance les uns des autres. Les composants dispersés au hasard créent la sensation d’un produit fabriqué de manière non professionnelle. Et vice versa, le placement soigneusement vérifié des boutons, commutateurs, cases à cocher et autres composants qui composent l'interface sur le formulaire est le signe d'un travail de haute qualité.Ordre des onglets. "Bon ordre
Ordre des onglets est l'ordre dans lequel le curseur à l'écran se déplace sur les commandes lorsqu'une touche est enfoncée Languette. Dans un programme correctement écrit, le curseur se déplace selon la logique du travail de l'utilisateur avec le programme. Lors de la création d'un programme, le programmeur modifie souvent les composants, en supprime certains et en ajoute d'autres si nécessaire. En conséquence, dans le programme terminé, le curseur saute de manière chaotique autour du formulaire. Après avoir terminé le programme, n'oubliez pas de configurer Ordre des onglets.Sélection de police
Laissez simplement les polices tranquilles. Les polices par défaut de Delphi conviennent à tout système sur lequel votre programme peut s'exécuter. Utilisez des caractères gras uniquement pour mettre en évidence les éléments importants. Application italique et particulièrement soulignant, que l'utilisateur pourrait prendre pour un lien hypertexte, est une mauvaise forme.Choix de couleurs
Quant aux couleurs des éléments de l’interface, tout comme dans le cas des polices, il vaut mieux les laisser standard, par défaut. Delphi utilise la palette système Windows et l'utilisateur peut facilement personnaliser les couleurs en la modifiant.Gestion alternative
Un programme conçu par des professionnels doit pouvoir être contrôlé non seulement avec la souris, mais également avec le clavier. Aucune fonction ne peut être exécutée uniquement avec la souris (dessiner avec éditeurs graphiquesça ne compte pas !). Pour les fonctions les plus utilisées, vous devez fournir des « touches de raccourci » pour un accès rapide.Briques d'interface
Quant aux éléments spécifiques de l'interface utilisateur, la qualité de l'interaction de l'utilisateur avec le programme dépend de :- conformité de l'élément de contrôle avec la tâche qu'il exécute ;
- règles selon lesquelles l'élément de contrôle fonctionne.
Cette page traite des règles de création de certains éléments d'interface.
Pour disposer les composants les uns par rapport aux autres dans le bon ordre, commencez par il faut les mettre en valeur. Vous pouvez simplement encercler la zone du formulaire qui contient les composants sélectionnés. Ou en maintenant " Changement", utilisez la même souris pour indiquer chaque composant à sélectionner. Cliquez à nouveau avec la souris sur le composant sélectionné (tout en appuyant sur " Changement") le désélectionne.
Les composants sélectionnés peuvent être gérés comme un tout - déplacés dans le formulaire, attribués des valeurs aux mêmes propriétés, copiés (pour l'installation, par exemple, sur un autre formulaire), voire supprimés.
Maintenant, faites un clic droit sur l'un des composants et sélectionnez dans le menu contextuel Position -> Aligner... Une boîte de dialogue apparaîtra vous permettant d'ajuster la position horizontale et verticale des composants du groupe. Par exemple, nous devons aligner nos quatre boutons vers la gauche et nous assurer qu’il y a une distance verticale égale entre eux. Pour ce faire, sélectionnez les boutons radio Horizontal : côtés gauches Et Vertical : espacer de manière égale.
En sélectionnant l'article Centre, nous organiserons les composants de manière à ce que leurs centres soient situés sur la même ligne horizontalement ou verticalement, et l'élément Centrer dans la fenêtre déplace les composants vers le centre de la fenêtre, également horizontalement ou verticalement.
Dans la même ligne de menu Languette Ô commander... fait apparaître une boîte de dialogue qui contrôle la façon dont le curseur se déplace à travers les éléments de l'interface lorsqu'une touche est enfoncée Languette. Lorsque le Formulaire apparaîtra à l'écran, le curseur se trouvera naturellement sur le composant situé sur la première ligne de la boîte de dialogue. Et puis cela descendra dans la liste. Dans la boîte de dialogue, deux flèches bleues haut et bas contrôlent la position du composant sélectionné. Sélectionnez le composant souhaité, utilisez les flèches pour le déplacer vers la ligne souhaitée dans la liste, et ainsi de suite.
Lors de la sélection d'un élément de menu Contrôle -> Un sous-menu apparaît composé de deux éléments :
- Mettre au premier plan
- Envoyer au fond
