Li Xiaoping/North China Petroleum Workers University in Gu'an, Provinz Hebei
---- Unabhängig davon, welche Art von Programm entwickelt wird, ist die Dateneingabe unverzichtbar. Die schnelle Erstellung einer schönen Eingabeschnittstelle wird zweifellos die Effizienz der Programmentwicklung erheblich verbessern. Die ursprünglichen Steuerungen des Systems sind oft unbefriedigend. Wenn es sich in Delphi um ein bestimmtes Feld handelt, sind die optionalen Steuerelemente DBLabel, DBEdit usw.; wenn es sich um die Eingabe der gesamten Tabelle handelt, gibt es DBGrid. Bei der Verwendung von Steuerelementen wie Dbedit müssen Benutzer die Positionen jedes Felds vollständig anordnen. Obwohl damit schöne Effekte erzielt werden können, ist dies zweifellos sehr problematisch, wenn viele Felder vorhanden sind. Wenn DBGrid verwendet wird, reicht nur ein Steuerelement aus, egal wie viele Felder es gibt. Es ist einfach, aber die Felder werden einzeln angeordnet, was etwas umständlich zu verwenden ist. Für normale Benutzer ist die Eingabe in Tabellenform sowohl bequem als auch schön. Dies ist das Problem, das dieser Artikel lösen soll.
----Technischer Schlüssel
----Die Hauptfunktion dieses Steuerelements besteht darin, Datenbankfelder zu bearbeiten. Gemäß den allgemeinen Regeln sollte das Steuerelement ein TdataLink-Objekt enthalten und eine Reihe von Methoden implementieren, die sich auf TdataLink beziehen. Dies verbraucht jedoch viel Code. Je größer die Codemenge, desto komplexer das System und desto größer das Fehlerpotenzial. Die Entwicklungsidee dieser Steuerung besteht darin, mit möglichst wenig Code die meisten Funktionen zu erreichen. Bearbeiten Sie Datenfelder daher direkt mit dem TDBComboBox-Steuerelement.
---- Um die Universalität zu erreichen, werden innerhalb des Steuerelements ein Feldbearbeitungssteuerfeld und ein Feldtitelfeld verwaltet. wie folgt:
Editoren: Array von TDBComboBox;
->Ein spezifisches Array von Datensteuerelementen zur Bearbeitung, dynamisch generiert
Labels: Array von TLabel;
->Der Titel jedes Feldes wird dynamisch generiert
----Der Vorteil der Verwendung von TDBComboBox besteht darin, dass es nicht nur über allgemeine Bearbeitungsfunktionen verfügt, sondern auch jedem Feld entsprechende Eingabeaufforderungsinformationen hinzufügen kann. Der Code lautet wie folgt:
{Methode zum Hinzufügen von Eingabeaufforderungsinformationen zu Feld I}
Prozedur TDBPanel.AddHits
(ItemIndex: Integer; Hits: String-Array);
var
m,n,i: Ganzzahl;
beginnen
n := Länge(Herausgeber);
m := Länge(Treffer);
Wenn ItemIndex< n, dann beginnen
for i:=0 to m-1 do Editors[ItemIndex].Items.Add(Hits[i]);
Ende;
Ende;
---- Spezifische Anwendungen variieren stark, daher muss die Steuerung auch genügend Ereignisverarbeitungsschnittstellen bieten, damit Programmierer spezielle Funktionen für bestimmte Anwendungen implementieren können. Dies erfordert die Definition bestimmter Ereignisverarbeitungsmethoden im Steuerelement, die von Benutzern implementiert werden können. Hier wird ein OnOkClick-Ereignis bereitgestellt, bei dem es sich um die Verarbeitung handelt, die ausgeführt wird, wenn alle Felder bearbeitet werden. Der Code lautet wie folgt:
OkButton: TButton;
->Die zuletzt hinzugefügte OK-Schaltfläche wird zum Implementieren der Übermittlungsaktion verwendet.
Eigenschaft OnOkClick: TNotifyEvent lesen FClick schreiben FClick;
---- Durch die Implementierung der OnOKClick-Methode können Benutzer verschiedene Verarbeitungsaufgaben wie Übermittlung und Datenrationalitätstests ausführen. Eine weitere Sache, die einer besonderen Behandlung bedarf, ist die Steuerung der Konvertierung zwischen verschiedenen Feldern. Standardmäßig wird mit der Maus geklickt. Es ist jedoch üblich, dass Benutzer häufig die vier Pfeiltasten „oben, unten, links und rechts“ auf der Tastatur verwenden. Um diese Funktion zu implementieren, müssen die folgenden zwei Methoden definiert werden:
procedure AKeyPress(Sender: TObject; var Key: Char);
procedure AKeyDown(Sender: TObject;
var Key: Word; Shift: TShiftState);
---- Weisen Sie die beiden oben genannten Methoden dynamisch generierten Editoren zu, um die Reaktion auf Pfeiltasten zu implementieren.
---- Verschiedene Tabellen haben eine unterschiedliche Anzahl von Feldern, die möglicherweise nicht angezeigt werden, was eine Scrollfunktion erfordert. Daher wird ein TscrollBox-Steuerelement in das Steuerelement eingefügt. Als letztes ist das Rückgängigmachen dynamischer Kontrollen und die Freigabe von Speicher zu beachten. Das Rückgängigmachen des Kontrollarrays und die Freigabe des Speichers sind in der richtigen Reihenfolge – die genau entgegengesetzte Reihenfolge der Erstellung. Sonst geht etwas schief.
----Verwendung von Steuerelementen
---- Platzieren Sie zunächst das DBPanel-Steuerelement im Formular und legen Sie dann die Datenquelleneigenschaften, die Anzahl der Spalten des Dateneingabeformulars und andere Eigenschaften fest. Rufen Sie im Programm nach dem Öffnen der Datenquelle einfach die Methode auf, um das Datenbearbeitungssteuerelement zu erstellen. Im Augenblick:
Abfrage1.Öffnen;->Datenquelle öffnen
DBPanel1.CreateEditors; ->Bearbeitungssteuerelemente für jedes Feld erstellen
DBPanel1.AddHits(0,['1111','11222','eeee']);
->Eingabeaufforderungsinformationen für ein bestimmtes Feld festlegen
DBPanel1.AddHits(1,['1111','11222','eeee']);
->Eingabeaufforderungsinformationen für ein bestimmtes Feld festlegen
Das Steuer- und Beispielprogramm wurde in der Win98+Delphi 5.0-Umgebung debuggt.
---- Anhang: Quellcode von TDBPanel
Einheit DBPanel;
Schnittstelle
verwendet
Windows, Nachrichten, SysUtils, Klassen,
Grafiken, Steuerelemente, Formulare, Dialoge,
ExtCtrls, dbctrls, stdctrls, db;
Typ
TDBPanel = Klasse(TPanel)
Privat
{Private Erklärungen}
FLinks: Ganzzahl;
FTop: Ganzzahl;
maxTextLen: Integer;
maxLabelLen: Integer;
FScrollBox: TScrollBox;{Scroll-Steuerung}
FLineHeight: Integer;
FClick: TNotifyEvent;
Editoren: Array von TDBComboBox;
->Ein spezifisches Array von Datensteuerelementen zur Bearbeitung, dynamisch generiert
Labels: Array von TLabel;
->Der Titel jedes Feldes wird dynamisch generiert
OkButton: TButton;
->Die zuletzt hinzugefügte OK-Schaltfläche wird zum Implementieren der Übermittlungsaktion verwendet.
{Datenquelle}
FDataSource: TDataSource;
FColumns: Integer;
->Geben Sie die Anzahl der Spalten der Tabelle ein
geschützt
{Geschützte Erklärungen}
Verfahren FreeEditors;
->Speicher der Dateneingabesteuerung freigeben
öffentlich
Verfahren CreateEditors;//
(DS: TDataSource; ColCount: Integer);
->Erstellen Sie Dateneingabesteuerelemente für jedes Feld
Konstruktor Create(AOwner:
TComponent);
Destruktor Zerstören; überschreiben;
Prozedur AKeyPress(Sender:
TObject; var Key: Char);
procedure AKeyDown(Sender:
TObject; var Key: Word Shift:
TShiftState);
procedure ClearHits(ItemIndex: Integer);
Prozedur AddHits(ItemIndex:
Ganzzahl; Treffer: Array von Zeichenfolgen);
Funktionseditor (Index: Ganzzahl):
TDBComboBox;
{Öffentliche Erklärungen}
veröffentlicht
propertyLeftLimit: Ganzzahl gelesen
FLeft write FLeft default 10;
Eigenschaft TopLimit: Ganzzahl gelesen
FTop schreibt FTop Standard 10;
Eigenschaft EditorLen: Ganzzahl gelesen
maxTextLen write maxTextLen;
Eigenschaft LabelLen: Ganzzahl gelesen
maxLabelLen schreibt maxLabelLen Standard 100;
Eigenschaft LineHeight: Ganzzahl gelesen
FLineHeight schreibt FLineHeight Standard 15;
Eigenschaft OnOkClick: TNotifyEvent
lesen FKlick schreiben FKlick;
Eigenschaft DataSource: TDataSource
FDataSource lesen FDataSource schreiben;
->Datenquelle
Eigenschaftsspalten: Ganzzahl gelesen
FColumns schreibt FColumns;->Anzahl der Tabellenspalten
{ Veröffentlichte Erklärungen }
Ende;
Verfahren Registrieren;
Durchführung
Verfahren Registrieren;
beginnen
RegisterComponents('Additional', [TDBPanel]);
Ende;
{Methode zum Hinzufügen von Eingabeaufforderungsinformationen zu Feld I}
Prozedur TDBPanel.AddHits(ItemIndex:
Ganzzahl; Treffer: Array von Zeichenfolgen);
var
m,n,i: Ganzzahl;
beginnen
n := Länge(Herausgeber);
m := Länge(Treffer);
Wenn ItemIndex< n, dann beginnen
for i:=0 to m-1 do Editors[ItemIndex].Items.Add(Hits[i]);
Ende;
Ende;
Prozedur TDBPanel.AKeyDown
(Sender: TObject; var Key: Word;
Schicht: TShiftState);
beginnen
if (Sender is TDBComboBox) then beginne
Fall Schlüssel von
VK_Next: (Absender als TDBComboBox)
.DataSource.DataSet.Next;
VK_PRIOR: (Absender als TDBComboBox)
.DataSource.DataSet.Prior;
Ende;
Ende;
Ende;
procedure TDBPanel.AKeyPress(Sender: TObject; var Key: Char);
beginnen
if (Sender is TDBComboBox) then beginne
if Key=#13 then (Owner as TForm).Perform(WM_NEXTDLGCTL, 0, 0);
Ende;
Ende;
procedure TDBPanel.ClearHits(ItemIndex: Integer);
var
n: Ganzzahl;
beginnen
n := Länge(Herausgeber);
if ItemIndex< n then Editors[ItemIndex].Items.Clear;
Ende;
Konstruktor TDBPanel.Create(AOwner: TComponent);
beginnen
Inherited Create(AOWner);
FLinks :=10;
FTop := 10;
maxTextLen := 100;
maxLabelLen := 100;
FLineHeight := 15;
Ende;
{Methode zum Erstellen von Dateneingabekontrollen für jedes Feld}
Prozedur TDBPanel.CreateEditors;//
(DS: TDataSource; ColCount: Integer);
var
i, n, RowCount: Integer;
TextHeight: Ganzzahl;
beginnen
Wenn DataSource.DataSet.Active, dann beginnen
n := DataSource.DataSet.FieldCount;
{Berechnen Sie die maximale Titellänge und Anzeigelänge}
DataSource.DataSet.First;
{Höhe berechnen}
TextHeight := Canvas.TextHeight(DataSource
.DataSet.Fields[0].DisplayLabel) + FLineHeight;
{Berechnen Sie die Anzahl der Zeilen und Spalten}
RowCount := n div Columns;
if n mod Columns < > 0 then inc(RowCount);
{Speicher zuweisen}
FreeEditors;
SetLength(Editors, n);
SetLength(Labels, n);
{Bildlauffeld erstellen}
FScrollBox := TScrollBox.Create(Owner);
FScrollBox.Parent := Self;
FScrollBox.Align := alClient;
{ErstellenBearbeiten}
für i:=0 bis n-1 beginnen
{Titel erstellen}
Labels[i] := TLabel.Create(Owner);
Labels[i].Parent := FScrollBox; //Self;
Labels[i].Caption := DataSource.DataSet.Fields[i].DisplayLabel;
Labels[i].Left := FLeft + (maxLabelLen +
maxTextLen + 10) * (i div RowCount);
Labels[i].Width := maxLabelLen;
Labels[i].Top := FTop + (i mod RowCount) * TextHeight + 5;
{Bearbeitungsobjekt erstellen}
Editors[i] := TDBComboBox.Create(Owner);
Editors[i].Parent := FScrollBox; //Self;
Editors[i].Left := Labels[i].Left + Labels[i].Width;
Editoren[i].Width := maxTextLen;
Editors[i].Top := FTop + (i mod RowCount) * TextHeight;
Editoren[i].DataSource := DataSource;
Editors[i].DataField := DataSource.DataSet.Fields[i].FieldName;
Editors[i].OnKeyPress := AKeyPress;
Editors[i].OnKeyDown := AKeyDown;
Ende;
{Schaltfläche „OK erstellen“}
OkButton := TButton.Create(Owner);
OkButton.Parent := FScrollBox;
OkButton.Left := Editors[n-1].Left;
OkButton.Top := Editors[n-1].Top + TextHeight;
OkButton.Caption := 'OK';
OKButton.OnClick := FClick;
Ende;
Ende;
Destruktor TDBPanel.Destroy;
beginnen
FreeEditors;
Geerbte Zerstörung;
Ende;
Funktion TDBPanel.Editor(Index: Integer): TDBComboBox;
beginnen
wenn Index< Länge(Editoren) dann Ergebnis := Editoren[Index]
sonst Ergebnis := nil;
Ende;
Prozedur TDBPanel.FreeEditors;
var
i,n: Ganzzahl;
beginnen
{Speicher muss in der richtigen Reihenfolge freigegeben werden! Muss in umgekehrter Reihenfolge der Erstellung erfolgen!
Insbesondere wenn zwischen Komponenten eine Eltern-Kind-Beziehung besteht}
if OkButton< >nil then OkButton.Free;
Wenn Editoren< >nil, dann beginnen
n := Länge(Herausgeber);
for i:=0 to n-1 do Editors[i].free;
Herausgeber := Null;
n := Länge(Beschriftungen);
for i:=0 to n-1 do Labels[i].Free;
Etiketten := Null;
Ende;
Wenn FScrollBox< >nil, dann beginnen
FScrollBox.Free;
FScrollBox := nil;
Ende;
Ende;
Ende.