Li Xiaoping/Université des travailleurs du pétrole de Chine du Nord à Gu'an, province du Hebei
---- Quel que soit le type de programme développé, la saisie des données est indispensable. Générer rapidement une belle interface de saisie améliorera sans aucun doute considérablement l'efficacité du développement du programme. Les contrôles initiaux du système sont souvent insatisfaisants. Dans Delphi, s'il s'agit d'un certain champ, les contrôles facultatifs sont DBLabel, DBEdit, etc. ; s'il s'agit de l'entrée de la table entière, il existe DBGrid. Lors de l'utilisation de contrôles tels que Dbedit, les utilisateurs doivent organiser complètement les positions de chaque champ. Bien que cela puisse obtenir de beaux effets, ce sera sans aucun doute très gênant s'il y a de nombreux champs. Si DBGrid est utilisé, quel que soit le nombre de champs, un seul contrôle suffit, mais les champs sont disposés un par un, ce qui est un peu gênant à utiliser. Pour les utilisateurs ordinaires, la saisie sous forme de tableau est à la fois pratique et esthétique. C’est le problème que cet article vise à résoudre.
----Clé technique
----La fonction principale de ce contrôle est d'éditer les champs de la base de données. Selon les règles générales, le contrôle doit contenir un objet TdataLink et implémenter une série de méthodes liées à TdataLink, qui consommeront cependant beaucoup de code ; Plus la quantité de code est importante, plus le système est complexe et plus le risque d’erreurs est grand. L'idée de développement de ce contrôle est de réaliser le plus de fonctions avec le moins de code. Par conséquent, modifiez les champs de données directement à l'aide du contrôle TDBComboBox.
---- Afin d'atteindre l'universalité, un tableau de contrôle d'édition de champ et un tableau de titre de champ sont conservés à l'intérieur du contrôle. comme suit:
Éditeurs : tableau de TDBComboBox ;
->Un ensemble spécifique de contrôles de données utilisés pour l'édition, générés dynamiquement
Étiquettes : tableau de TLabel ;
->Le titre de chaque champ est généré dynamiquement
----L'avantage d'utiliser TDBComboBox est qu'il dispose non seulement de fonctions d'édition générales, mais peut également ajouter des informations d'invite correspondantes à chaque champ. Le code est le suivant :
{Méthode pour ajouter des informations d'invite au champ I}
PROcédure TDBPanel.AddHits
(ItemIndex : entier ; Hits : tableau de chaînes) ;
var
m,n,i : entier ;
commencer
n := Longueur (Éditeurs);
m := Longueur (Hits);
si ItemIndex < n alors commencez
pour i:=0 à m-1, faites Editors[ItemIndex].Items.Add(Hits[i]);
fin;
fin;
---- Les applications spécifiques varient considérablement, de sorte que le contrôle doit également laisser suffisamment d'interfaces de traitement d'événements pour que les programmeurs puissent implémenter des fonctions spéciales pour des applications spécifiques. Cela nécessite de définir certaines méthodes de traitement des événements dans le contrôle que les utilisateurs doivent mettre en œuvre. Ce qui est fourni ici est un événement OnOkClick, qui correspond au traitement effectué lorsque tous les champs sont modifiés. Le code est le suivant :
Bouton Ok : TButton ;
->Le dernier bouton OK ajouté est utilisé pour implémenter l'action de soumission.
propriété OnOkClick : TNotifyEvent lecture FClick écriture FClick ;
---- En implémentant la méthode OnOKClick, les utilisateurs peuvent effectuer diverses tâches de traitement telles que la soumission et les tests de rationalité des données. Une autre chose qui nécessite un traitement spécial est le contrôle de la conversion entre les différents domaines. La valeur par défaut est de cliquer avec la souris. Cependant, l'habitude des utilisateurs est souvent d'utiliser les quatre touches fléchées « haut, bas, gauche et droite » du clavier. Pour implémenter cette fonction, les deux méthodes suivantes doivent être définies :
procédure AKeyPress (Expéditeur : TObject ; var Key : Char) ;
procédure AKeyDown(Expéditeur : TObject;
var Clé : Mot ; Maj : TShiftState);
---- Attribuez les deux méthodes ci-dessus aux éditeurs générés dynamiquement pour obtenir une réponse aux touches fléchées.
---- Différentes tables ont un nombre de champs différent et peuvent ne pas pouvoir être affichées, ce qui nécessite une fonction de défilement. Ainsi, un contrôle TscrollBox est inséré dans le contrôle. La dernière chose à noter est l'annulation des contrôles dynamiques et la libération de mémoire. L'annulation du tableau de contrôle et la libération de la mémoire sont dans l'ordre exact de la création. Sinon, quelque chose ne va pas.
----Utilisation des contrôles
---- Placez d'abord le contrôle DBPanel sur le formulaire, puis définissez les propriétés de la source de données, le nombre de colonnes du formulaire de saisie de données et d'autres propriétés. Dans le programme, après avoir ouvert la source de données, appelez simplement la méthode pour créer le contrôle d'édition des données. Tout de suite:
Requête1.Open ; -> Ouvrir la source de données
DBPanel1.CreateEditors ; ->Créer des contrôles d'édition pour chaque champ
DBPanel1.AddHits(0,['1111','11222','eeee']);
->Définir les informations d'invite pour un certain champ
DBPanel1.AddHits(1,['1111','11222','eeee']);
->Définir les informations d'invite pour un certain champ
Le programme de contrôle et l'exemple ont été débogués dans l'environnement Win98+Delphi 5.0.
---- Pièce jointe : Code source de TDBPanel
unité DBPanel ;
interface
utilise
Windows, messages, SysUtils, classes,
Graphiques, contrôles, formulaires, boîtes de dialogue,
ExtCtrls, dbctrls, stdctrls, db ;
taper
TDBPanel = classe (TPanel)
privé
{Déclarations privées}
FLgauche : entier ;
FTop : entier ;
maxTextLen : entier ;
maxLabelLen : entier ;
FScrollBox : TScrollBox ; {contrôle de défilement}
FLineHeight : entier ;
FCliquez sur : TNotifyEvent ;
Éditeurs : tableau de TDBComboBox ;
->Un tableau spécifique de contrôles de données utilisés pour l'édition, générés dynamiquement
Étiquettes : tableau de TLabel ;
->Le titre de chaque champ est généré dynamiquement
Bouton Ok : TButton ;
->Le dernier bouton OK ajouté est utilisé pour implémenter l'action de soumission.
{source de données}
FDataSource : TDataSource ;
FColonnes : nombre entier ;
->Entrez le nombre de colonnes du tableau
protégé
{ Déclarations protégées }
procédure FreeEditors;
-> Libérer la mémoire du contrôle d'entrée de données
publique
procédure CreateEditors;//
(DS : TDataSource ; ColCount : entier );
->Créer des contrôles de saisie de données pour chaque champ
constructeur Create(AOwner :
TComponent);
destructeur Détruire ;
procédure AKeyPress(Expéditeur :
TObject ; var Clé : Char);
procédure AKeyDown(Expéditeur :
TObject ; var Clé : Mot ;
TShiftState);
procédure ClearHits(ItemIndex: Integer);
procédure AddHits(ItemIndex :
Nombre entier ; nombre d'accès : tableau de chaînes );
éditeur de fonctions (Index : Entier) :
TDBComboBox ;
{Déclarations publiques}
publié
propertyLeftLimit : lecture entière
FLeft écrit FLeft par défaut 10 ;
propriété TopLimit : lecture entière
FTop écrit FTop par défaut 10 ;
propriété EditorLen : lecture entière
maxTextLen écrire maxTextLen ;
propriété LabelLen : lecture entière
maxLabelLen écrit maxLabelLen par défaut 100 ;
propriété LineHeight : lecture entière
FLineHeight écrit FLineHeight par défaut 15 ;
propriété OnOkClick : TNotifyEvent
lire FClick écrire FClick ;
propriété DataSource : TDataSource
lire FDataSource écrire FDataSource ;
->Source de données
Propriété Colonnes : lecture entière
FColumns écrit FColumns ; -> Nombre de colonnes du tableau
{ Déclarations publiées }
fin;
registre de procédure ;
mise en œuvre
registre de procédure ;
commencer
RegisterComponents('Supplémentaire', [TDDBanel]);
fin;
{Méthode pour ajouter des informations d'invite au champ I}
procédure TDBPanel.AddHits(ItemIndex :
Nombre entier ; nombre d'accès : tableau de chaînes );
var
m,n,i : entier ;
commencer
n := Longueur (Éditeurs);
m := Longueur (Hits);
si ItemIndex < n alors commencez
pour i:=0 à m-1, faites Editors[ItemIndex].Items.Add(Hits[i]);
fin;
fin;
procédure TDBPanel.AKeyDown
(Expéditeur : TObject ; clé var : Word ;
Maj : TShiftState);
commencer
si (l'expéditeur est TDBComboBox), alors commencez
cas Clé de
VK_Next : (Expéditeur en tant que TDBComboBox)
.DataSource.DataSet.Next ;
VK_PRIOR : (Expéditeur en tant que TDBComboBox)
.DataSource.DataSet.Prior ;
fin;
fin;
fin;
procédure TDBPanel.AKeyPress (Expéditeur : TObject ; var Key : Char) ;
commencer
si (l'expéditeur est TDBComboBox), alors commencez
si Key=#13 alors (Propriétaire en tant que TForm).Perform(WM_NEXTDLGCTL, 0, 0);
fin;
fin;
procédure TDBPanel.ClearHits(ItemIndex: Integer);
var
n : entier ;
commencer
n := Longueur (Éditeurs);
si ItemIndex< n alors Editors[ItemIndex].Items.Clear ;
fin;
constructeur TDBPanel.Create(AOwner : TComponent);
commencer
Création héritée (AOWner);
FLgauche :=10 ;
FHaut := 10;
maxTextLen := 100;
maxLabelLen := 100;
FLigneHauteur := 15 ;
fin;
{Méthode pour créer des contrôles de saisie de données pour chaque champ}
procédure TDBPanel.CreateEditors;//
(DS : TDataSource ; ColCount : entier );
var
i, n, RowCount : entier ;
Hauteur du texte : entier ;
commencer
si DataSource.DataSet.Active alors commencez
n := DataSource.DataSet.FieldCount;
{Calculer la longueur maximale du titre et la longueur d'affichage}
DataSource.DataSet.First ;
{calculer la hauteur}
TextHeight := Canvas.TextHeight (DataSource
.DataSet.Fields[0].DisplayLabel) + FLineHeight ; //10 ;
{Calculer le nombre de lignes et de colonnes}
RowCount := n colonnes div ;
si n colonnes mod < > 0 alors inc(RowCount);
{Allouer de la mémoire}
Éditeurs gratuits ;
SetLength(Editeurs, n);
SetLength(Étiquettes, n);
{Créer une zone de défilement}
FScrollBox := TScrollBox.Create(Propriétaire);
FScrollBox.Parent := Soi ;
FScrollBox.Align := alClient;
{CréerModifier}
pour i:=0 à n-1, commencez
{Créer un titre}
Étiquettes[i] := TLabel.Create(Propriétaire);
Étiquettes[i].Parent := FScrollBox; //Self;
Étiquettes[i].Caption := DataSource.DataSet.Fields[i].DisplayLabel;
Étiquettes[i].Left := FLeft + (maxLabelLen +
maxTextLen + 10) * (je div RowCount);
Étiquettes[i].Width := maxLabelLen;
Étiquettes[i].Top := FTop + (i mod RowCount) * TextHeight + 5;
{Créer un objet d'édition}
Éditeurs[i] := TDBComboBox.Create(Propriétaire);
Éditeurs[i].Parent := FScrollBox; //Self;
Éditeurs[i].Left := Étiquettes[i].Left + Étiquettes[i].Width;
Éditeurs[i].Width := maxTextLen;
Editors[i].Top := FTop + (i mod RowCount) * TextHeight;
Éditeurs[i].DataSource := DataSource;
Éditeurs[i].DataField := DataSource.DataSet.Fields[i].FieldName;
Éditeurs[i].OnKeyPress := AKeyPress;
Éditeurs[i].OnKeyDown := AKeyDown;
fin;
{Créer un bouton OK}
OkButton := TButton.Create(Propriétaire);
OkButton.Parent := FScrollBox;
OkButton.Left := Éditeurs[n-1].Left;
OkButton.Top := Éditeurs[n-1].Top + TextHeight;
OkButton.Caption := 'OK';
OKButton.OnClick := FClick;
fin;
fin;
destructeur TDBPanel.Destroy ;
commencer
Éditeurs gratuits ;
Détruire héritée ;
fin;
fonction TDBPanel.Editor(Index : Integer) : TDBComboBox ;
commencer
si Index< Longueur (Editeurs) alors Résultat := Editeurs[Index]
sinon Résultat := nul ;
fin;
procédure TDBPanel.FreeEditors ;
var
i,n : entier ;
commencer
{La mémoire doit être libérée dans l'ordre ! Doit être fait dans l’ordre inverse de la création !
Surtout quand il existe une relation parent-enfant entre les composants}
si OkButton< >nil alors OkButton.Free ;
si Editors< >nil alors commencez
n := Longueur (Éditeurs);
pour i:=0 à n-1, faites Editors[i].free;
Éditeurs := nul ;
n := Longueur (Étiquettes);
pour i:=0 à n-1, faites Labels[i].Free;
Étiquettes := néant ;
fin;
si FScrollBox< >nil alors commencez
FScrollBox.Free;
FScrollBox := nul ;
fin;
fin;
fin.