Schritt für Schritt: Entwicklung einer Komponente

Diese Anleitung zeigt, wie man eine eigene Komponente erstellt, indem man sie von einer Standardkomponente ableitet. Wir wollen hier ein normales TEdit um einige Eigenschaften erweitern.

1. Wir erstellen das Grundgerüßt und legen den Vorgänger unserer neuen Komponente fest:

Über den Menupunkt 'Komponente/Neu' können wir den Vorfahren (in diesem Fall TEdit) und einen Namen (TTestEdit) für unsere Komponente angeben. Auch kann man das Verzeichnis des zu erzeugenden Quelltextes ändern.

Nach dem Klick auf Ok wird ein entsprechender Quelltext erzeugt.

2. Wir wollen in unser TEdit einen einfachen Textfilter einbauen, mit dem wir für die Eingabe genau angeben können, welche Tasten akzeptiert werden und welche nicht. Dazu brauchen wir einen Schalter, der angibt, ob der Filter überhaupt genutzt werden soll und zwei Strings, einen der die erlaubten Zeichen angibt und einer für die verbotenen Zeichen.

Wir erweitern unseren Quelltext um die folgenden Zeilen:

  private
    fFiltered : Boolean;
    fFilterAccept, fFilterDeny : string;
  published
    property Filtered : Boolean read fFiltered write fFiltered default false;
    property FilterAccept : string read fFilterAccept write fFilterAccept;
    property FilterDeny : string read fFilterDeny write fFilterDeny;

Im published-Teil stehen alle Werte, die später im Objektinspektor zu sehen sind. In Delphi ist es üblich, dort keine direkten Variablen anzugeben, sondern immer nur properties, die auf Variablen im private-Teil zugreifen. So kann man später auch einfach den Zugriff auf die Variablen durch Get/Set-Prozeduren beschränken. Darauf wollen wir hier aber verzichten, unsere properties greifen direkt auf die Variablen im private-Teil zu. Diese haben laut Delphi-Konvention ein f vor dem eigentlichen Namen.

3. Jetzt kommt die eigentliche Arbeit, wir müssen die Eingaben in das Editfeld abfangen und mit dem Filter vergleichen. Ist ein Filter-String leer, so gilt der entsprechende Filter als nicht gesetzt. Außerdem soll ein doppelter Eintrag in Accept- und Deny-Filter zu einer Ablehnung führen. Um an die Tastatureingaben zu kommen, bevor sie im Editfeld erscheinen, überschreiben wir die KeyPress-Routine und ändern die Eingabe, bevor wir sie weiterleiten.

Wir erweitern unseren Quelltext um die folgende Prozedur:

  protected
    procedure KeyPress(var Key: Char); override;

implementation

  procedure TTestEdit.KeyPress(var Key: Char);
  begin
    if fFiltered then begin
      if Length(fFilterDeny)>0 then begin
        if StrScan(PChar(fFilterDeny),key)<>nil then key := #0;
      end;
      if Length(fFilterAccept)>0 then begin
        if StrScan(PChar(fFilterAccept+#8+#16),key)=nil then key := #0;
      end;
    end;
    inherited;
  end;

Ist ein Tastendruck im Deny-Filter enthalten, so löschen wir den Tastendruck. Beim Accept-Filter müssen wir aber auch auf die Tasten #8 und #16 (Delete und Backspace) prüfen, sonst werden die auch abgewiesen.
inherited ruft die KeyPress Routine des Vorgängers auf, damit die dortigen Anweisungen auch alle ausgeführt werden... allerdings mit dem von uns abgeänderten Tastenwert.

Näheres zur Funktion StrScan steht in der online-Hilfe.

4. Zur Sicherheit werden wir jetzt noch die Werte für unsere Properties auf definierte Anfangswerte setzen, wir überschreiben dazu den constructor der Komponente:

  public
    constructor Create(AOwner : TComponent); override;

implementation

  constructor TCustomdpEdit.Create(AOwner : TComponent);
  begin
    inherited Create(AOwner);
    fFiltered := False;
    fFilterAccept := '';
    fFilterDeny := '';
  end;

Wir rufen zuerst den constructor des Vorgängers auf, damit alles soweit initialisiert ist und setzen dann unsere Werte.

5. Jetzt ist unsere Komponente fertig, wir müssen sie nur noch registrieren. Dann können wir sie wie alle anderen Komponenten über die Komponenten-Palette auswählen und auf ein Formular setzen.

Über den Menupunkt 'Komponente/installieren' geben wir den Pfad zu unserem Quelltext an.

Wir haben jetzt die Wahl, die Komponente in ein bestehendes Package zu installieren oder in ein neues. Für unsere Zwecke ist es eigentlich egal, ich mache es immer so, daß ich alle eigenen Komponenten in ein eigenes Package setze, der Übersicht halber. Dies geht ganz einfach, wir können über den Punkt 'in neues Package' einen Namen und eine Beschreibung für unser neues Package angeben, den rest erledigt Delphi für uns.

Im Anschluß sehen wir jetzt eine Liste aller in unserem Package enthaltenen Quelltexte. Über den Punkt 'compilieren' werden wir das package übersetzen, dabei registriert Delphi die Komponenten. Treten Fehler auf, so können wir diese einfach im Editor korrigieren und dann nochmal auf 'compilieren' klicken.

Delphi meldet uns im Anschluß an die erfolgreiche Compilierung, welche Komponenten neu hinzugekommen sind.

6. Zusätzliches

• Unsere Komponente hat standardmäßig dasselbe Icon wie der Vorgänger, hier also das von TEdit. Ein eigenes Icon kann man erstellen, indem man mithilfe des Delphi Bildeditors eine Komponentenresource erstellt. Der Dateiname muß denselben Namen wie der Komponentenquelltext haben, nur mit der Endung .dcr. Das Bild der Komponente innerhalb der Resource ist eine Bitmap mit den Maßen 24x24 und dem Namen der Komponente (hier also TTESTEDIT).
  
  Anschließend muß das Package nochmal neu compiliert werden. Dazu wählen wir den Menupunkt 'Komponente/Package installieren' (und nicht etwa 'Package bearbeiten'). Dort wählen wir unser Package aus und klicken auf Bearbeiten, schon öffnet sich das Package-Fenster.
  
• Bei den Delphi Standardkomponenten hat es sich eingebürgert, zu einer Komponente erst eine Version mit dem Zusatz TCustom zu erzeugen und dann später davon alle benötigten properties abzuleiten. Im Fall von TEdit gibt es also einen direkten Vorgänger TCustomEdit, der die eigendlichen Prozeduren und Properties enthält, dort sind aber alle diese properties im protected-Bereich, also im Objektinspektor nicht sichtbar. TEdit ist von TCustomEdit abgeleitet, enthält aber keinen zusätzlichen Code. Hier werden nur alle wichtigen properties vom protected in den published-Teil verschoben und so sichtbar gemacht.
  Wir hätten unsere Komponente auch von TCustomEdit ableiten können, der hier beschriebene Weg ist aber der einfachere und für unsere Zwecke ausreichend.

siehe auch:

Delphi FAQ