Komponente schreiben, Teil 3

4/17/2023

5664

Komponente schreiben, Teil 3

Dieser Artikel ist der letzte Teil eines dreiteiligen Artikels auf Komponenten. Dieser letzte Teil deckt Eigenschaft / Komponenten-Editoren, wie spezielle Editoren für die Komponente zu schreiben / -Eigenschaft, und wie Sie schreiben 'versteckt' Komponenten.

Dieser Artikel erschien ursprünglich in Delphi-Entwickler

Benutzerdefinierte Komponenten-Editoren
Sobald wir beginnen, fortgeschrittene Eigenschaftentypen für unsere Komponenten zu schreiben, wird das Leben ein wenig komplizierter. Obwohl in Delphi integriert Objektinspektor die meisten Eigenschaftentypen zu erkennen ist, ist es unmöglich zu jeder möglichen benutzerdefinierten Typ erledigen, den wir in unserer Komponenten schreiben kann. Manchmal Objektinspektor ist unsere benutzerdefinierten Typen erledigen, aber Bearbeitung solch eine komplexe Anordnung von Eigenschaften im Objektinspektor ist einfach nicht intuitiv genug. Es ist an dieser Stelle, wir kann erforderlich sein, Eigenschaft schreiben / Komponenten-Editoren. Delphi hat bereits viele vordefinierte Editoren, diese Editoren sind in der DsgnIntf.pas-Datei in das Verzeichnis $ \Source\ToolsAPI $(Delphi). Du musst diese Einheit in der Klausel verwendet Komponenten-Editor auflisten / Eigenschaften-Editor können Sie schreiben, es ist auch eine gute Idee, diese Datei als Referenz offen zu halten, wenn Sie Ihre eigenen Redakteure schreiben.

Coding-standards
Um zu beginnen mit I deckt einige coding-Standards, die beim Schreiben von Komponenten oder Eigenschaft Editoren verwendet werden. Es gibt nur wenige, aber es wäre eine gute Idee, diese Standards zu halten, wenn Ihre eigenen Redakteure schreiben, wie es für andere Menschen zu verstehen, Ihre Arbeit erleichtert.

Wenn Sie eine Eigenschaft Editor erstellen, beenden Sie den Namen Ihres Editors mit dem Wort 'Eigentum'; z. B. TAngleProperty

Wenn Sie einen Komponenten-Editor erstellen, beenden Sie den Namen Ihres Editors mit dem Wort 'Editor'; z. B. TPieChartEditor

Beim Schreiben von Editoren schreiben Sie immer den Editor in einer separaten Einheit auf Ihre tatsächliche Komponente. Es ist gut, den Gestaltung und Laufzeit-Code zu trennen, und abgesehen davon, es macht die resultierende EXE-Größe kleiner (in einigen Versionen von Delphi Komponente Anwendungen kompilieren, wenn Sie ihnen nicht trennen einstellen kann). Auch trennen Sie die Pakete, damit Ihre Benutzer mit Runtime-Pakete erstellt werden können, wenn sie wollen!

Nennen Sie Ihren Editor-Einheit mit dem gleichen Namen wie Ihre Komponente-Einheit, sondern hängen Sie das Wort 'Reg' am Ende; Beispielsweise würde eine Komponente mit dem Namen der Einheit 'MyComponent.pas' im Editor Dateinamen wird 'MyComponentreg.pas' führen.

Schließlich beim Schreiben eines Komponenten-Editors / Eigenschaften-Editor für die Komponente verschieben Sie Ihre RegisterComponents -Anweisung aus der Komponente und in Ihren Komponenten-Editor-Einheit. Auf diese Weise wird die Komponente nicht ohne den Editor auch registriert wird registriert.

Eigenschaften-editor
Eigenschaften-Editoren werden vom IDE verwendet, um spezielle Bearbeitung einzelner Eigenschaften innerhalb einer Komponente. Einige Editoren sind sehr einfach, einige sind viel komplizierter. Delphi hat bereits eine Reihe von standard-Eigenschaftseditoren, einige davon sind:

TIntegerProperty. Für die Eingabe von Zahlen verwendet.

TCharProperty. Für die Eingabe eines einzelnen Zeichens verwendet.

TEnumProperty. Verwendet ein einzelnes Element in einen Aufzählungstyp (AlTop, AlClient etc.) aktiviert. TBoolProperty. Für die Auswahl von 'True' oder 'False' für boolesche Eigenschaften verwendet.

TFloatProperty. Für die Eingabe von Gleitkommazahlen verwendet (Variable Typ Float / etc. erweitert. Der 'Echte' Typ sollte nicht für die Eigenschaften der Komponente verwendet werden).

TStringProperty. Für die Eingabe von Zeichenketten bis maximal 255 Zeichen verwendet.

TSetProperty. Für inklusive / exklusive Einzelelemente einer Set-Eigenschaft verwendet. Jedes Element wird als untergeordnete boolesche Eigenschaft angezeigt. Wenn Sie den Wert auf 'True' enthält das Element, werden ausgeschlossen auf 'False' festlegen.

TClassProperty. Dies ist die Basisklasse von abzusteigen, wenn Sie möchten, erstellen Sie einen benutzerdefinierten Editor für Eigenschaften einer bestimmten Klasse aufgerufen werden, (wenn Sie eine Klasse als eine Eigenschaft wie TImage.Picture haben).

Alle diese Eigenschaften-Editoren Abstieg direkt oder indirekt aus TPropertyEditor. TPropertyEditor hat viele Eigenschaften und Methoden, die bedeutendsten sind.

Funktion AllEqual: Boolean; virtuelle;
Funktion GetAttributes: TPropertyAttributes; virtuelle;
Verfahren Bearbeiten; virtuelle;
Funktion GetValue: String; virtuelle;
Verfahren GetValues(Proc: TGetStrProc); virtuelle;

AllEqual
Wenn mehrere Komponenten ausgewählt sind filtert Objektinspektor seine Liste mit Eigenschaften, die nur diejenigen, die die ausgewählten Komponenten gemeinsam haben. Wenn der Wert in jeder Komponente für eine bestimmte Eigenschaft (z.B. Breite) identisch ist, wird der Wert angezeigt werden, sonst wird kein Wert angezeigt. AllEqual ist die Routine, die bestimmt, ob jeder Wert identisch ist.

Funktion TStringProperty.AllEqual: Boolean;
var
I: Integer;
V: Zeichenfolge;
beginnen
Ergebnis: = False;
if PropCount > 1 dann
beginnen
V: = GetStrValue;
für Ich: = 1 bis PropCount - 1 tun
if GetStrValueAt(I) <> V dann Ausfahrt;
end;
Ergebnis: = True;
end;

Im obigen Beispiel TStringProperty vergleicht jeden Wert (mit GetStrValueAt) mit dem Wert der ersten Komponente in der Liste (mit GetStrValue, GetStrValueAt(0) hätte das gleiche getan haben). Die Größe der Liste wird mithilfe der PropCount bestimmt, dies gibt den Gesamtbetrag der ausgewählten Komponenten.

GetAttributes
GetAttributes wird von der IDE aufgerufen, wenn Informationen über Eigenschaften-Editor erfasst werden muss. Objektinspektor zeigt einen geeigneten Editor, basierend auf den Informationen geliefert. Das Ergebnis der GetAttributes (TPropertyAttributes) ist ein Satz, so dass es eine Kombination der folgenden Werte enthalten kann (Dies ist keine vollständige Liste)

paDialog
Sagt der Objektinspektor auf Knopfdruck [...] nach den Namen der Eigenschaft, zeigen klickt der Benutzer auf diese Schaltfläche wird die Edit-Methode ausgelöst.

paSubProperties
Sagt der Objektinspektor zeigen ein [+] expand Schaltfläche vor die Name-Eigenschaft, klicken auf diese Schaltfläche wird eine umfangreichere Liste der Sub-Eigenschaften (in der Regel die veröffentlichten Eigenschaften einer Klasse-Eigenschaft) zeigen.

paValueList
Objektinspektor zeigt einer Combobox mit einer Liste von Werten, diese Liste von der IDE bestimmt wird, indem die GetValues-Methode.
Hinweis: die GetValues-Methode, nicht die GetValue-Methode die ganz anders ist

paSortList
Wenn mit PaValueList kombiniert wird, werden die angezeigten Werte alphabetisch sortiert.

paMultiSelect
Dies gibt der IDE, dass die Eigenschaft angezeigt werden, wenn mehrere Komponenten ausgewählt werden darf. Dieses Produkt ist nicht für solche TClassProperty-Editoren vorhanden.

paAutoUpdate
Bewirkt, dass die SetValue-Methode aufgerufen werden, jedes Mal, wenn der Wert im Objektinspektor geändert wird, anstatt drücken Sie warten auf den Benutzer oder einer anderen Eigenschaft zu bearbeiten. Dies ist für 'Caption' und 'Text', verwendet, um eine live-Darstellung des Werts zu geben, die der Benutzer eingibt.

paReadOnly
Wenn dieses Element enthalten ist ist der Wert im Objektinspektor schreibgeschützt. Dies wird normalerweise in Verbindung mit PaDialog verwendet. GetValue würde überschrieben werden, um eine beschreibende Darstellung der Eigenschaft zurückzugeben.

Bearbeiten
Diese Methode wird aufgerufen, wenn die [...] für die Eigenschaft geklickt wird. Diese Schaltfläche wird angezeigt, wenn das PaDialog-Element in das Ergebnis der GetAttributes eingeschlossen wird.

GetValue
Diese Methode wird aufgerufen, wenn der Objektinspektor, wie die Eigenschaft als Zeichenfolge angezeigt wissen muss. Dies ist i. d. r. verwendet, wenn [PaDialog, PaReadOnly] werden in das Ergebnis der GetAttributes angegeben.

GetValues
Diese Methode wird aufgerufen, wenn Objektinspektor muss zum Abrufen einer Liste von Werten angezeigt, wenn PaValueList in das Ergebnis der GetAttributes angegeben ist. GetValues übergibt einen Parameter namens 'Proc', die vom Typ TGetStrProc ist. GetStrProc wird als TGetStrProc deklariert = Verfahren(const S: String) des Objekts;

Die IDE erwartet 'Proc' einmal für jeden Wert aufgerufen werden, die im Objektinspektor für diese Eigenschaft angezeigt werden soll.

Verfahren THintProperty.GetValues(Proc: TGetStrProc);
beginnen
Proc ('erstes Element anzeigen');
Proc ('zweites Element anzeigen');
Ende;

Das folgende Beispiel veranschaulicht eine Liste von Standardwerten für die 'Hint' Eigenschaft aller Komponenten bereitstellen, während noch erlauben den Benutzer, die nicht in der Liste einen Wert eingeben.

Typ
THintProperty = Klasse(TStringProperty)
öffentliche
Funktion GetAttributes: TPropertyAttributes; außer Kraft setzen;
Verfahren GetValues(Proc: TGetStrProc); außer Kraft setzen;
end;

Verfahren Registrieren;

Umsetzung

Verfahren Registrieren;
beginnen
RegisterPropertyEditor (TypeInfo (String), null, 'Hinweis', THintProperty);
end;

{THintProperty}

Funktion THintProperty.GetAttributes: TPropertyAttributes;
beginnen
Ergebnis: = geerbt GetAttributes + [PaValueList PaSortList];
end;

Verfahren THintProperty.GetValues(Proc: TGetStrProc);
beginnen
Proc ('Dies ist ein oblig.');
Proc (' Press F1 Weitere Informationen ');
Proc ('dieser Wert ist Read-only');
end;

Ersten GetAttributes wird überschrieben, und [PaValueList, PaSortList] sind im Ergebnis enthalten. Nächsten GetValues überschrieben, und drei Werte werden durch Aufrufen der Prozedur 'Proc' auf die Dropdown-Liste hinzugefügt.

Eigenschaftseditoren registrieren
Schließlich wird der Editor mit RegisterPropertyEditor registriert. RegisterPropertyEditor hat vier Parameter:

PropertyType: PTypeInfo
Ist einen Zeiger auf einen TTypeInfo-Eintrag erforderlich. Das klingt viel komplizierter als es wirklich ist, alles, was wir tun müssen, ist unsere Uses-Clausel TypInfo hinzu, und verwenden Sie die TypeInfo-Funktion zum Abrufen des Zeigers für uns. TypeInfo(SomeVariableType)

ComponentClass: TClass
Dies ist die Basisklasse, der dieser Editor für gelten sollte. Der Editor gelten für diese Klasse und alle Klassen, die von ihm abstammen. Wenn NULL angegeben ist, gilt dieser Editor für jede Klasse.

const PropertyName: String
Wenn dieser Editor nur für eine bestimmte Eigenschaft gelten soll, sollte der Name der Eigenschaft hier angegeben. Wenn der Editor, eine Eigenschaft eines Typs in PropertyType angegeben gelten soll dieser Wert sollte sein ''.

EditorClass: TPropertyEditorClass
Dies ist die Klasse, die erstellt wurde, um die Eigenschaft zu bewältigen. Im obigen Beispiel ist die Klasse THintProperty.

Die unsachgemäße Verwendung des RegisterPropertyEditor
Es ist wichtig, wenn Sie RegisterPropertyEditor verwenden, dass Sie die richtige Informationen bereitstellen. Die falsche Informationen eingeben könnte entweder das Ihr falsche Eigenschaften des Editors Affekte (zB alle Zeichenfolgeneigenschaften) oder falsche Komponenten bedeuten.

Im anderen Extremfall könnte die Einstellung der Parameter falsch bedeuten, dass nur eine bestimmte Eigenschaft in eine bestimmte Komponente (und Abkömmlinge) Ihrem Editor zugeordnet ist. Dies scheint nicht wie ein großes Problem am ersten, sondern untergeordneten Komponenten zusätzliche Eigenschaften desselben Typs implementieren möchten. Wie diese Eigenschaften offensichtlich einen anderen Namen haben, haben sie nicht den richtigen Eigenschaften-Editor zugeordnet werden.

Ein Beispiel für schlecht registrierte Editor ist bereits innerhalb der VCL vorhanden. Der standard-Editor für TCollection wurde für alle Klassen von TComponent registriert. Das Problem ist, dass die niedrigste Klasse Lage im Objektinspektor angezeigt wird TPersistent (die Klasse, die TComponent aus senkt sich).

Wenn eine Komponente verfügt über eine Eigenschaft des Typs TPersistent (die standardmäßig seinen Untereigenschaften in eine erweiterbare Liste verfügbar macht) und eine Eigenschaft vom Typ TCollection ist, ist das Ergebnis einer [...]-Schaltfläche in der Objektinspektor, der tut nichts, wenn geklickt (wie wir im zweiten Teil dieser Artikelserie gesehen haben).

Die Lösung dieses Problems scheint recht einfach. Anstatt unsere Untereigenschaft wird stammen von TPersistent könnten wir es von TComponent stattdessen abstammen. Allerdings ist die Vorgabe für eine Eigenschaft vom Typ TComponent (entsprechend der TComponentProperty-Editor Editor) eine Liste der anderen Komponenten, anstatt die Untereigenschaften der embedded-Komponente zeigen.

Die tatsächliche Lösung ist wirklich einfach, aber nur, wenn Sie wissen, wie einen Editor zu schreiben.

Schritt 1:

Typ
TExpandingRecord = Klasse(TPersistent)

Sollte geändert werden, um zu lesen

Typ
TExpandingRecord = Klasse(TComponent)

Schritt 2: Erstellen Sie eine Eigenschaft Editor wie folgt

Typ
TExpandingRecordProperty = Klasse(TClassProperty)
öffentliche
Funktion GetAttributes: TPropertyAttributes; außer Kraft setzen;
end;

Verfahren Registrieren;

Umsetzung

Verfahren Registrieren;
beginnen
RegisterComponents ('Artikel', [TExpandingComponent]);
RegisterPropertyEditor(TypeInfo(TExpandingRecord), null, '', TExpandingRecordProperty);
end;

{TExpandingRecordProperty}

Funktion TExpandingRecordProperty.GetAttributes: TPropertyAttributes;
beginnen
Ergebnis: = [PaReadOnly, PaSubProperties];
end;

Schritt 3: Entfernen Sie den RegisterComponents-Aufruf aus der Komponente-Einheit, und es stattdessen innerhalb des Editors zu registrieren. Auf diese Weise können wir gewährleisten, die Komponente wird nicht ohne die Komponente registriert werden.

Nun wird unser Eigentum des Typs TExpandingRecord als expandierende Eigenschaft (wegen uns zurückgeben PaSubProperties aus GetAttributes) zeigen und der Standardeditor für TCollection funktionieren wie der Eigentümer des Grundstücks TCollection eine TComponent ist.

Dialogfeld Eigenschaften-Editoren
Die meisten der Zeit, beim Erstellen einer benutzerdefinierten Eigenschaft Editor, soll ein grafisches Mittel zur Interaktion mit der Eigenschaft bieten.

In diesem erste Beispiel ist eine sehr einfache Art der Benutzer mehrere Zeilen in der Eigenschaft 'Beschriftung' von einem TLabel eingeben. Obwohl in diesem Beispiel nicht sehr kompliziert ist, wird gezeigt, wie ein Formular innerhalb Ihres Herausgebers enthalten.

Schritt 1:
Wählen Sie Datei, neue Anwendung aus dem Hauptmenü. Dies wird ein Formular erstellen, benennen Sie das Formular 'FmLabelEdit', das Formular mit dem Namen MemCaption einem TMemo hinzugefügt. Fügen Sie zwei Schaltflächen, 'OK' und 'Abbrechen', mit der ModalResult Eigenschaften auf MrOK und MrCancel beziehungsweise.

Schritt 2:
Fügen Sie DsgnIntf und TypInfo Ihre Klausel verwendet.

Caption property editor

Schritt 3:
Fügen Sie den folgenden Eigenschaft-Editor-Code auf Ihr Gerät.

TCaptionProperty = Klasse(TStringProperty)
öffentliche
Funktion GetAttributes: TPropertyAttributes; außer Kraft setzen;
Verfahren Bearbeiten; außer Kraft setzen;
end;

Und registrieren Sie den Eigenschaften-Editor wie folgt

Verfahren Registrieren;

Umsetzung
{$R *. DFM}

Verfahren Registrieren;
beginnen
RegisterPropertyEditor(TypeInfo(TCaption), TLabel, 'Caption', TCaptionProperty);
end;

Schritt 4:
Fügen Sie den folgenden Code in Reihenfolge für den Objektinspektor die Bearbeiten-Schaltfläche [...] nach den Namen der Eigenschaft angezeigt.

Funktion TCaptionProperty.GetAttributes: TPropertyAttributes;
beginnen
Ergebnis: = geerbt GetAttributes + [PaDialog];
end;

Schritt 5:
Schließlich erstellen Sie eine Instanz von Editor das Kontaktformular wir, legen Sie den Inhalt des Memo die aktuelle Beschriftung, und zeigen Sie dann das Formular modal.

Verfahren TCaptionProperty.Edit;
var
I: Integer;
beginnen
mit TfmLabelEdit.Create(Application) tun
versuchen Sie
memCaption.Lines.Text: = GetStrValue;
ShowModal;

{Wenn die ModalResult der Form MrOK ist, müssen wir die Eigenschaft 'Caption' jede TLabel festgelegt.}

if ModalResult = MrOK dann
für Ich: = 0 , PropCount-1 tun
TLabel(GetComponent(I)). Bildunterschrift: = memCaption.Lines.Text;
Schließlich
Frei;
end;
end;

Schritt 6:
Installieren Sie die Einheit in das Paket zu, und dann probieren Sie den neuen Editor!

Erweiterte Eigenschaften-Editoren
Wer jemals TActionList oder TDataSet benutzt hat (Tabelle / TQuery) Erfahrung des folgenden Beispiels, möglicherweise ohne zu merken, sogar müssen.

Die ActionList, den Editor offensichtlich einen benutzerdefinierten Editor ist es erlaubt Gruppierung von Aktionen, kann sich die FieldsEditor TDataSet bei zuerst wirken wie eine standard-Editor, aber bei näherem Hinsehen hat ein Popup-Menü mit Elementen wie z. B. 'Felder hinzufügen'. Die bemerkenswerteste Eigenschaft der beiden diesen Editoren ist jedoch nicht, dass sie benutzerdefinierte Dialogfeld Editoren (ähnlich der wir früher fallen), sind aber die Tatsache, dass die Elemente, die sie erstellen in der Hauptklasse Erklärung des aktuellen Geräts enthalten sind.

Typ
TForm1 = Klasse(TForm)
ActionList1: TActionList;
Aktion1: TAction;
Aktion2: TAction;
Private
{Private Deklarationen}
öffentliche
{Public Deklarationen}
end;

Der Vorteil davon ist, dass die IDE bewusst gemacht, ist diese Elemente daher so, dass sie aus einer Liste von Objekten ausgewählt werden, wenn die Eigenschaft einer Komponente verlangt, sie dass.

Action property

In der obigen Abbildung werden zwei Aktionen hinzugefügt ein TActionList durch Klicken auf die 'Action'-Eigenschaft von Button1 zeigt eine Liste bestehend aus den Aktionen hinzugefügt. Die beiden Aktionen werden auch Klassendeklaration des Formulars hinzugefügt und können daher von Namen (Aktion1, Aktion2) bezeichnet.

Der Trick dabei liegt vollständig in den Editor und nicht innerhalb der Komponente. Wenn ein Editor ausgelöst wird (dh die Edit-Methode genannt) die Designer-Eigenschaft enthält einen gültigen Verweis auf ein IFormDesigner (TFormDesigner in Delphi 4). Viele der Funktionen dieser Schnittstelle sind nicht in den Anwendungsbereich dieses Artikels wollen Sie mehr über die Funktionen dieser Schnittstelle zu erfahren, empfehle ich ein Buch namens Delphi Developer's Handbook von Marco Cantu, würde.

Einige der Methoden sind

Funktion MethodExists (const Name: String): Boolean;
Verfahren RenameMethod (const CurName, neuer Name: String);
Verfahren SelectComponent(Instance: TPersistent);
Verfahren ShowMethod (const Name: String);
Funktion GetComponent (const Name: String): TComponent;
Funktion CreateComponent (ComponentClass: TComponentClass; Eltern: TComponent; Links, Top, Width, Height: Integer): TComponent;

Einige der oben genannten Anrufe relativ elementare sind, werden MethodExists z. B. zurück True oder False je nachdem ob ein Methodenname bereits in Form der aktuellen Einheit (FormCreate, Button1Click usw.) vorhanden ist. ShowMethod wird der Cursor an die benannte Methode und RenameMethod ändert sich der Name einer Methode.

Die zwei Methoden, die für die Verwendung von Interesse sind, sind an dieser Stelle:

CreateComponent
Angesichts eine Komponentenklasse, ein Elternteil, die Komponente zu halten und Position / Abmessungen, der Designer erstellt eine Instanz der Klasse als ob der Entwickler hatte es aus der Komponente-Palette ausgewählt und hinzugefügt ihm das Formular selbst.

Geändert
Informiert, dass der Designer, die etwas (eine Eigenschaft etc.) verändert. Dies ändert den Status des Gerätes, so dass die IDE weiß es vor dem Schließen gespeichert werden soll (es ermöglicht auch die speichern-Schaltfläche in der IDE).

Beim Hinzufügen von Elementen in unserem Array alles, was wir tun müssen, ist, TMyProperty.Designer erstellen Sie eine Komponente in unserem Auftrag zu erhalten. Diese Komponente wird dann zum Formular hinzugefügt werden, und jede Eigenschaft, die bezieht sich auf eine Klasse dieser Art werden automatisch bewusst zu sein. Bei TActionList und TDataSet die Komponenten, die das Formular hinzugefügt werden, nicht sind sichtbar zur Entwurfszeit, fungiert die Besitzerkomponente als eine Art 'Manager' für die Komponenten.

Finden Sie während der Entwurfszeit-Sie pflegen einen TAction oder ein TField-Komponente die Komponente-Palette, die möglicherweise, Sie machen würde vermuten, dass sie noch nicht registriert sind, noch die IDE kann weiterhin zum Erstellen von Instanzen dieser Komponenten (und sie sind auch nicht sichtbar). Die Antwort ist nicht, dass sie sind nicht angemeldet, dieses Verhalten ist ein Ergebnis des 'wie' die Komponente registriert ist.

Während RegisterComponents der Komponente Palette Ihrer Komponenten hinzufügen wird, erzählt die RegisterNoIcon Methode Ihre Komponente registrieren wird, ohne es der Palette Komponente registrieren in dieser Weise auch der IDE, dass die Komponente nicht während der Entwurfsphase angezeigt werden soll.

Im folgenden Beispiel erstellen wir eine Komponente namens ein TWavSound (im Quellcode, der in diesem Artikel als Beispiel begleitet ist eine zusätzliche Komponente namens TWavButton enthalten). TWavSound wird einfach Daten aus einer WAV-Datei speichern und Abspielen der Sounds on-Demand. Es wäre einfach für uns fallen eine TWavSound auf unserem Formular für jedes WAV sound benötigen wir, unser Formular könnte bald beginnen, unüberschaubar geworden, daher werden wir auch eine Managerklasse namens TWavList erstellen.

TWavList

Jede Technik verwendet im Quellcode zu diesen Komponenten war in Teil 2 dieser Artikelreihe bedeckt, so dass der Quellcode in allen großen Level an Details nicht abgedeckt werden. Allerdings werde ich zeigen, dass die Klassendeklarationen dieser Komponenten nur um Ihnen eine Vorstellung davon, wie sie strukturiert sind.

Hinweis: An der Unterseite des Gerätes, im Initialisierungsabschnitt des Gerätes Sie möglicherweise den folgenden Code fest:

Initialisierung
RegisterClass(TWavSound);

Der Grund ist, dass RegisterNoIcon scheint nicht, eine vollständige Arbeit zu tun. Obwohl es uns erlaubt, die Instanzen der registrierte Komponente aus unserer Eigenschaften-Editor zu erstellen, scheint etwas schiefgehen, wenn ein Projekt wird neu geladen, die diese Komponenten enthalten. Ein Meldungsfeld 'Klasse nicht registriert' angezeigt, und das Projekt ist beschädigt. Registrieren zusätzlich die Klasse auf diese Weise scheint das Problem zu beheben

TWavSound

Typ
PWavData = ^ TWavData;
TWavData = gepackte Datensatz
Größe: Longint;
Daten: Array[0..0] Byte;
Ende;

TWavSound = Klasse(TC

Komponente schreiben, Teil 3

Komponente schreiben, Teil 3 : Mehreren tausend Tipps, um Ihr Leben einfacher machen.

Dieser Artikel erschien ursprünglich in Delphi-Entwickler

Wenn Sie eine Eigenschaft Editor erstellen, beenden Sie den Namen Ihres Editors mit dem Wort 'Eigentum'; z. B. TAngleProperty

Wenn Sie einen Komponenten-Editor erstellen, beenden Sie den Namen Ihres Editors mit dem Wort 'Editor'; z. B. TPieChartEditor

Beim Schreiben von Editoren schreiben Sie immer den Editor in einer separaten Einheit auf Ihre tatsächliche Komponente. Es ist gut, den Gestaltung und Laufzeit-Code zu trennen, und abgesehen davon, es macht die resultierende EXE-Größe kleiner (in einigen Versionen von Delphi Komponente Anwendungen kompilieren, wenn Sie ihnen nicht trennen einstellen kann). Auch trennen Sie die Pakete, damit Ihre Benutzer mit Runtime-Pakete erstellt werden können, wenn sie wollen!

Nennen Sie Ihren Editor-Einheit mit dem gleichen Namen wie Ihre Komponente-Einheit, sondern hängen Sie das Wort 'Reg' am Ende; Beispielsweise würde eine Komponente mit dem Namen der Einheit 'MyComponent.pas' im Editor Dateinamen wird 'MyComponentreg.pas' führen.

Schließlich beim Schreiben eines Komponenten-Editors / Eigenschaften-Editor für die Komponente verschieben Sie Ihre RegisterComponents -Anweisung aus der Komponente und in Ihren Komponenten-Editor-Einheit. Auf diese Weise wird die Komponente nicht ohne den Editor auch registriert wird registriert.