Seit ich Delphi im Jahr 1999 kennengelernt habe, war ich von der schnellen Entwicklung fasziniert. Damals kam ich gerade mit der Programmierung in Berührung und interessierte mich besonders für die visuelle Entwicklung. Der Grund dafür ist, dass es schneller implementiert werden kann als C In den letzten Jahren habe ich von Delphi C/S bis hin zu dreischichtigem B/S auch einige große und kleine Software geschrieben. Ich denke, dass dieses Delphi nur über diese Funktionen verfügt, da ich kürzlich das Buch „Com Essence“ erhalten und den VCL-Quellcode studiert habe (ich weiß nicht, mit welchen Worten ich es beschreiben soll). Es gibt einige Durchbrüche, die hier mit allen geteilt werden. Bitte sagen Sie mir, ob es Fehler gibt.
Um es ganz klar auszudrücken: Komponenten umfassen nur zwei Arten von Mitgliedern: Eigenschaften und Methoden (die Methoden, von denen ich spreche, umfassen Ereignisse).
Es ist in vier Teile gegliedert:
Privat
geschützt
öffentlich
veröffentlicht
Die Bedeutung der oben genannten vier Teile wird in allgemeinen Büchern zur visuellen Entwicklung vorgestellt. Hier ist nur ein kurzer Überblick über Delphi.
Privat: Alle privaten Mitglieder werden hier platziert und können nur durch die eigenen Methoden der Klasse, nicht durch Unterklassen, aufgerufen werden und sind für Unterklassen transparent. Man kann auch sagen, dass der Zugriff nur über die Methoden der Einheit selbst möglich ist.
geschützt: Abgesehen davon, dass es von Unterklassen geerbt werden kann, ist der Rest derselbe wie bei privat. Für Außenstehende nicht zugänglich.
public: Öffentlich, die hier deklarierten Eigenschaften und Methoden können von Benutzern aufgerufen werden.
veröffentlicht: erscheint in der Eigenschaftsleiste der Delphi-Entwicklungsumgebung.
Lassen Sie uns zunächst das einfachste Steuerelement erstellen. In weniger als fünf Minuten werden Sie verstehen, wie die Komponenten im Komponentenfenster von Delphi erstellt werden.
Neu->Neu->Komponente und drücken Sie die Eingabetaste.
Wählen Sie dann im Ancestor-Typ die übergeordnete Klasse aus, von der Sie erben möchten: Hier wählen wir TComponent aus. Dies bedeutet, dass alle Eigenschaften und Methoden von TComponent geerbt werden.
Klassenname: Geben Sie den Klassennamen der zu erstellenden Komponente ein. (Wir geben TShowText ein)
Palettenseite: Auf welchem Panel in Delphi die Komponente installiert wird. (Wir wählen Samples, Sie können auch einen neuen Namen eingeben)
Folgendes muss ich nicht sagen.
Klicken Sie auf die Schaltfläche „OK“, und Delphi generiert automatisch ein von TComponent geerbtes Basissteuerelement. Es ist auch verständlich, dass wir ein Steuerelement entwickelt haben, das genauso leistungsfähig ist wie TComponent, aber das ist nicht das, was wir brauchen.
Im Folgenden werden die Lese- und Schreibmethoden der privaten Variablen der Komponente selbst erläutert:
Wir haben zum Beispiel den folgenden kurzen Absatz geschrieben:
Privat
FText: String;
....
/*Private Variablen dürfen von der Außenwelt nicht verwendet werden. Wie können wir diese FText-String-Variable bedienen? */
Wir müssen diesen Absatz auch nach „Veröffentlicht“ hinzufügen:
Eigenschaft Text: String read FText write FText;
Dies bedeutet hier, dass diese Texteigenschaft in der Eigenschaftsleiste von delphiSDK angezeigt wird. Benutzer, die den Text in der Eigenschaftsleiste ändern, ändern tatsächlich die Zeichenfolgenvariable FText. Lesen bedeutet, dass der Benutzer das Textattribut liest und tatsächlich FText liest. Schreiben bedeutet natürlich, dass der Benutzer Text einen Wert zuweist und ihn in der Zeichenfolgenvariablen FText speichert.
Wenn Sie es zu diesem Zeitpunkt speichern und in Delphi installieren, ist unsere grundlegendste Komponente fertig. (Die Methode zur Installation von Komponenten wird am Ende vorgestellt.)
Haha, ist das nicht ganz einfach? Es ist nur so, dass unsere Komponente keinen spezifischen Zweck hat.
Wir haben hier gerade Attribute eingeführt, jetzt werden wir weiterhin Funktionen hinzufügen, um die Verwendung von Methoden einzuführen.
Wir fügen nach Public Folgendes hinzu:
Prozedur ShowText();
Drücken Sie dann Strg + Alt + C. Das System fügt automatisch den Implementierungscode einiger Methoden für Sie hinzu.
Als nächstes schreiben wir:
procedure TShowText.ShowText();
beginnen
ShowMessage(FText);
Ende;
Wie Sie sehen können, zeigt die ShowMessage oben den Wert der privaten Variablen der Klasse an. Jetzt sollten Sie verstehen, dass auf private Variablen nur in der Methode der Klasse selbst zugegriffen werden kann. Hier müssen Sie die Dialogs-Einheit nach der Verwendung hinzufügen, da ShowMessage in der Dialogs-Einheit enthalten ist, andernfalls wird sie nicht übergeben.
Natürlich können die oben genannten Ereignisse nur im Steuerelement verwendet werden und nicht in der Ereignisleiste im Eigenschaftenfeld angezeigt werden. Denn die hier deklarierte Methode ist nur Public, eine reine Methode, und wird nicht als Ereignis deklariert.
Wissen Sie durch die obige Studie bereits, wie man die Eigenschaften und Methoden von Steuerelementen schreibt und anpasst?
Eine echte Steuerung ist jedoch untrennbar mit Ereignissen verbunden, und der Aufruf von Ereignissen muss durch Nachrichten gesteuert werden, die in meinem nächsten Artikel vorgestellt werden.
Die Eigenschaften und Methoden einer leistungsstarken Steuerung sind nicht so einfach. Sie erfordern mehr Übung und mehr Anwendungen.
Unten ist ein von mir geschriebenes DBGridToExcel-Steuerelement angehängt, dessen Funktion darin besteht, Daten im DBGrid nach Excel zu exportieren. Sie können daraus lernen und es als Referenz verwenden. Diese Kontrolle umfasst die Verwendung von Eigenschaften, Methoden und „Ereignissen“, über die wir im nächsten Artikel sprechen werden.
Anhang 1: So installieren Sie selbst erstellte Steuerelemente:
(1). Wählen Sie im Komponentenmenü „Komponente installieren…“.
(2). Klicken Sie nach dem Unit-Dateinamen auf „…“, wählen Sie die Unit-Datei des „*.pas“-Steuerelements aus und klicken Sie dann auf „OK“. Klicken Sie im erscheinenden Fenster auf „Installieren“ und die Installation ist abgeschlossen.
Das neu installierte Steuerelement wird in Ihrem Panel angezeigt.
Anhang 2: Kopieren Sie den gesamten Quellcode des TDBGridToExcel-Steuerelements in Notepad und speichern Sie ihn als .pas-Datei.
Einheit DBGridToExcel;
{************************************************ * *********************}
{* *}
{* Raster in Word-VCL-Steuerung für D5 und D6 exportieren *}
{* Copyright(C) xiangding 2003.10.1 Alle Rechte vorbehalten *}
{* Fehlerbericht: [email protected] *}
{* Autor: Kleiner Bär*}
{* *}
{************************************************ * *********************}
{* *}
{* Dies ist eine einfache Version *}
{* *}
{************************************************ * *********************}
{* *}
{* Installieren: *}
{* Bitte speichern Sie es als Datei GridToExcel.pas und öffnen Sie dann die Datei *}
{* Klicken Sie auf den Menüpunkt [Komponente] --> [Komponente installieren] *}
{* Klicken Sie im Dialogfeld „Komponente installieren“ auf die Schaltfläche „Installieren“ *}
{* Nach der Installation finden Sie das Steuerelement unter Komponente *}
{* Seite [Beispiel] *}
{* *}
{************************************************ * *********************}
{* *}
{* Installieren: *}
{* Speichern Sie den Anhang und öffnen Sie dann die Datei GridToExcel.Pas mit Delphi, *}
{* Wählen Sie Delphi-Menü -> Komponente -> Komponente installieren, *}
{* Wählen Sie dann „Installieren“. Nach der Installation auf der Seite „Beispiele“ des Bedienfelds *}
{* Nachdem Sie damit vertraut sind, können Sie versuchen, einige komplexe Attribute festzulegen und die anderen selbst zu erkunden, *}
{************************************************ * *********************}
Schnittstelle
verwendet
Windows, StdCtrls, ComCtrls, Nachrichten, DBGrids, Grafiken, ExtCtrls,
Formulare, DB, ComObj, Steuerelemente, SysUtils, Klassen;
ResourceString
SPromptExport = 'Bitte warten, Daten werden exportiert...';
SConnectExcel = 'Excel wird gestartet, bitte warten...';
SConnectExcelError= 'Verbindung zu Excel fehlgeschlagen. Excel ist möglicherweise nicht installiert und kann nicht exportiert werden.';
SCancel = '&Abbrechen';
SError = 'Fehler';
SConfirm = 'Möchten Sie den Datenexport wirklich beenden? ';
SCaption = 'Bestätigen';
SGridError = 'Kein Datensatz angegeben, bitte geben Sie die Datensatzsteuerung an! ';
Typ
TDBGridToExcel = class(TComponent)
Privat
ProgressForm: TForm;
FShowProgress: Boolean;
ExcelApp: Variante;
FTitle: String;
Beenden: Boolean;
FOnProgress: TNotifyEvent;
FGrid: TDBGrid; {Das Quellgitter}
ProgressBar: TProgressBar;
Eingabeaufforderung: TLabel;
FAutoExit: Boolean;
FAutoSize: Boolean;
FDBGrid: TDBGrid;
procedure SetShowProgress(const Value: Boolean);
Prozedur CreateProgressForm;
procedure ButtonClick(Sender: TObject);
Funktion ConnectToExcel: Boolean;
Prozedur ExportDBGrid;
{Private Erklärungen}
geschützt
{Geschützte Erklärungen}
öffentlich
Konstruktor Create(AOwner: TComponent);
Destruktor Destroy(); override;
Prozedur ExportToExcel; {Raster nach Excel exportieren}
{Öffentliche Erklärungen}
veröffentlicht
{ Veröffentlichte Erklärungen }
Eigenschaft DBGrid: TDBGrid read FDBGrid write FDBGrid;
Eigenschaft Titel: String read FTitle write FTitle;
Eigenschaft ShowProgress: Boolean read FShowProgress write SetShowProgress;
Eigenschaft OnProgress: TNotifyEvent read FOnProgress write FOnProgress;
Ende;
Verfahren Registrieren;
Durchführung
Verfahren Registrieren;
beginnen
RegisterComponents('Samples', [TDBGridToExcel]);
Ende;
{TDBGridToExcel}
procedure TDBGridToExcel.ButtonClick(Sender: TObject);
beginnen
Beenden := MessageBox(ProgressForm.Handle, pchar(SConfirm), pchar(SCaption),
MB_OKCANCEL + MB_ICONINFORMATION) = IDOK;
Ende;
Funktion TDBGridToExcel.ConnectToExcel: Boolean;
beginnen
Ergebnis := wahr;
Versuchen
ExcelApp := CreateOleObject('Excel.application');
ExcelApp.Visible := False;
if Title<>'' then ExcelApp.Caption := Title;
ExcelApp.WorkBooks.Add;
außer
MessageBox(GetActiveWindow,PChar(SConnectExcelError),PChar(SError),Mb_OK+MB_IconError);
Ergebnis := false;
Ende;
Ende;
Konstruktor TDBGridToExcel.Create(AOwner: TComponent);
beginnen
geerbt;
FShowProgress := True; {Standardwert war Show the Progress}
FAutoExit := False;
FAutoSize := True;
Ende;
procedure TDBGridToExcel.CreateProgressForm;
var
Panel: TPanel;
Schaltfläche: TButton;
beginnen
wenn Assigned(ProgressForm), dann beenden; {Aready Create?}
ProgressForm := TForm.Create(Owner);
Mit ProgressForm tun
beginnen
Font.Name := '宋体';
Schriftgröße := 10;
BorderStyle := bsNone;
Breite := 280;
Höhe := 120;
BorderWidth := 1;
Farbe := clBackground;
Position := poOwnerFormCenter;
Ende;
Panel := TPanel.Create(ProgressForm);
mit Panel tun { Panel erstellen }
beginnen
Parent := ProgressForm;
Ausrichten := alClient;
BevelInner := bvNone;
BevelOuter := bvRaised;
Bildunterschrift := '';
Ende;
Eingabeaufforderung := TLabel.Create(Panel);
mit Prompt führen Sie {Create Label} aus
beginnen
Übergeordnetes := Panel;
Links := 20;
Oben := 25;
Bildunterschrift := SConnectExcel;
Ende;
ProgressBar := TProgressBar.Create(panel);
mit ProgressBar do { Create ProgressBar }
beginnen
Schritt := 1;
Übergeordnetes := Panel;
Glatt := wahr;
Links := 20;
Oben := 50;
Höhe := 18;
Breite := 260;
Ende;
Button := TButton.Create(Panel);
mit Button do {Abbrechen-Button erstellen}
beginnen
Übergeordnetes := Panel;
Links := 115;
Oben := 80;
Bildunterschrift := SCancel;
OnClick := ButtonClick;
Ende;
ProgressForm.Show;
ProgressForm.Update;
Ende;
Destruktor TDBGridToExcel.Destroy;
beginnen
geerbt;
Ende;
procedure TDBGridToExcel.ExportDBGrid;
var
Daten: TDataSet;
ADBGrid: TDBGrid;
i, j: ganze Zahl;
CurrentPoint: Zeiger;
OldBeforeScroll, OldAfterScroll: TDataSetNotifyEvent;
beginnen
Screen.Cursor := crHourGlass;
versuchen
versuchen
TForm(Owner).Enabled := False;
ExcelApp.DisplayAlerts := false;
ExcelApp.ScreenUpdating := false;
Beenden := false;
if ShowProgress then Prompt.Caption := SPromptExport;
ADBGrid := DBGrid;
Daten := ADBGrid.DataSource.DataSet;
mit ADBGrid tun {Insert Table Header}
for i := 1 to Columns.Count do
if Columns[i - 1].Visible then
ExcelApp.Cells[1,i].Value :=Columns[i - 1].Title.Caption;
CurrentPoint := Data.GetBookmark; {Aktuelle Position speichern}
OldBeforeScroll := Data.BeforeScroll; { Save Old Before Scroll Event handle }
OldAfterScroll := Data.AfterScroll; { Altes AfterScroll-Ereignishandle speichern }
Data.DisableControls; {Disable Control}
Data.BeforeScroll := nil;
Data.AfterScroll := nil;
if ShowProgress then ProgressBar.Max := Data.RecordCount;
ich := 2;
Daten.Erste;
while not Data.Eof do { Alle Datensätze verarbeiten }
beginnen
mit ADBGrid do { Einen Datensatz verarbeiten }
for j := 1 to Columns.Count do
if Columns[j - 1].Visible then
ExcelApp.Cells[i,j].Value := Columns[j - 1].Field.DisplayText;
Inc(i);
Daten.Weiter;
if Assigned(FOnProgress) then FOnProgress(Self);
if ShowProgress then { Update Progress UI }
beginnen
ProgressBar.StepIt;
Application.ProcessMessages;
wenn Beenden, dann Beenden;
Ende;
Ende;
außer
MessageBox(GetActiveWindow,PChar(SConnectExcelError),Pchar(SError),MB_OK+MB_ICONERROR);
Ende;
ExcelApp.Visible := False;
TForm(Owner).Enabled := True;
Screen.Cursor := crDefault;
if ShowProgress then FreeAndNil(ProgressForm);
ExcelApp.DisplayAlerts := True;
ExcelApp.ScreenUpdating := True;
Endlich
Data.BeforeScroll := OldBeforeScroll; { Alten Event-Handle wiederherstellen }
Data.AfterScroll := OldAfterScroll;
Data.GotoBookmark(CurrentPoint);
Data.FreeBookmark(CurrentPoint);
Data.EnableControls;
Screen.Cursor := crDefault;
Ende;
Ende;
procedure TDBGridToExcel.ExportToExcel;
beginnen
if DBGrid= nil then raise Exception.Create(SGridError); {No DataSource, then Error}
if ShowProgress then CreateProgressForm; {Ob die ProgressForm angezeigt wird oder nicht}
Wenn nicht ConnectToExcel, dann { Beenden, wenn ein Fehler auftritt }
beginnen
if ShowProgress then FreeAndNil(ProgressForm);
Ausfahrt;
Ende;
ExportDBGrid; {begin Export Data}
Ende;
procedure TDBGridToExcel.SetShowProgress(const Value: Boolean);
beginnen
FShowProgress := Wert;
Ende;
Ende.