Version vom 29. November 2005, 18:49 Uhr

Komponenten Tutorial

Einleitung

Erst mal willkommen bei meinem Komponeten-Tutorial. Ich möchte in diesem Tutorial nicht absolutes Basiswissen über die Komponenten-Programmierung unter Delphi vermitteln, sondern denjenigen, die schon entsprechende Einsteigertutorials gelesen haben (wie etwa das auf Delphi-Treff.de) noch etwas tiefer in die Materie einführen.

Eigene Visuelle Komponeten

Wenn man seine Komponente komplett selber zeichnen möchte, so empfiehlt es sich diese von TGraphicControl oder TCustomControl abzuleiten. TCustomControl ist im Gegensatz zu TGrapicControl ein Nachfahre von TWinControl, und erbt von ihm ein (Fenster-) Handle. Dieses Handle ist eine Nummer, welche Komponenten von Windows erhalten um sie eindeutig zu bezeichnen. Nur wenn die Komponente ein Handle hat, kann Windows mit ihr etwas anfangen.

Möchte man nur statisch etwas anzeigen, wie etwa ein Label, so kann man auch nur TGraphicControl als Vorfahren wählen. Solche Komponenten ohne Handle werden von Windows nicht unterstützt, und sind nur eine Technik von Delphi, um dem Entwickler einfachere Gestaltungsmöglichkeiten zu bieten. Es ist ja schließlich viel einfacher, eine Komponente auf der Form zu platzieren, als diese mit Zeichenbefehlen selbst zu zeichnen.

Um selbst festzulegen, wie die Komponente gezeichnet wird, kann man bei Nachfahren von TGraphicControl oder TCustomControl ganz einfach die procedure Paint überschreiben.

TMeineKomponente = class(TGraphicControl)
protected
  procedure Paint; override; 

Gezeichnet wird dann über die Canvas-Eigenschaft der Komponente. Dabei sollte man nicht vergessen mit inherited die Paint Procedure des Vorfahren aufzurufen.

procedure TMeineKomponente.Paint;
begin
  inherited;//Paint Procedure des Vorfarhen aufrufen.
  Canvas.//irgendwas

Eine Abfrage der Eigenschaft ComponentState ermöglicht es uns, die Komponente zur Entwickungszeit anders zu zeichnen.

procedure TMeineKomponente.Paint;
begin
  inherited;//Zeichen Procedure des Vorfahren aufrufen.
  if csDesigning in ComponentState then //Wenn sich die Komponente in Entwicklung befindet.
  begin
    {Zeichung eines gestrichelten Rahmens}
    Canvas.Brush.style := bsClear;//Durchsichtiges Rechteck
    Canvas.Pen.style := psDashDot;//Gestrichelte Linen
    Canvas.Rectangle(0,0,width,height);//Rechteck zeichnen

    {Namen der Komponente in die Mitte schreiben}
    canvas.TextOut((width - Canvas.TextWidth(Name)) div 2,(height - Canvas.TextHeight(Name)) div 2,name);

    {Keine weitern Zeichnungen mehr ausführen}
    exit;//Verlässt die Procedure
  end;
  //Normale Zeichen-Anweisungen
end;

Eigenschafts-Editoren

Als erstes sollten wir der Frage nachgehen, was ein Eigenschaftseditor überhaupt ist : Wie schon fast zu erraten, handelt es sich hierbei um eine Möglichkeit, eine als veröffentlicht (published) deklarierte Eigenschaft im Objektinspektor zu bearbeiten. In Delphi sind schon diverse Eigenschaftseditoren vorhanden um die häufigsten Eigenschaftstypen abzudecken. Wenn ihr einer Komponente eine als published deklarierte Eigenschaft vom Typ Integer verpasst, so wird standardgemäß der Editor "TIntegerProperty" genutzt um die Eigenschaft im Objektinspektor darzustellen. Dieser Editor ist ein Eingabefeld für Zahlen.

Eigenschaftseditoren können aber nicht nur solche Eingabefelder sein, sondern können auch eine ganze Reihe anderer Bearbeitungsmöglichkeiten bieten. Ein richtig multifunktionaler Eigenschaftseditor ist zum Beispiel "TColorProperty". So kann man entweder eine hexadezimale Zahl oder einen Farbnamen eingeben, die entsprechende Farbe über eine Liste auswählen oder gar per Doppelklick einen Farbdialog öffenen.

Ein solcher Eigenschaftseditor ist programmiertechnisch gesehen nichts anderes als ein Nachfahre der Klasse "TPropertyEditor", welcher in einer Register-Prozedur in Delphi eingebunden wurde. Den Code von einem solchen Eigenschaftseditor sollte man in eine Unit packen, welche nur von Delphi genutzen Code enthält. Für das beiliegende Beispiel TFilePropertyEditor nehmen wir direkt TPropertyEditor als Vorfahren.

TFileNameProperty = class (TPropertyEditor)
  {...}
end;

In welcher Form der Eigenschaftseditor angezeigt wird, bestimmt der Rückgabewert der Funktion GetAttributes. Um diese zu ändern überschreiben wir die Funktion einfach.

TFileNameProperty = class (TPropertyEditor)
public
  function GetAttributes: TPropertyAttributes; override;
  {...}
end;

Dem Eigenschatseditor werde ich nun zusätzlich zu dem Standardeingabefeld noch per paDialog die Möglichkeit geben, auf Doppelklicks oder einen (nun evtl. erschienen) Buttonklick zu reagieren. paMultiSelect bewirkt schlussendlich noch, dass die Eigenschaft auch noch sichtbar ist, wenn mehre Komponenten ausgewählt sind. Weitere mögliche Parameter sind der Delphi Hilfe zu entnehmen.

function TFileNameProperty.GetAttributes: TPropertyAttributes;
begin
  Result := [paMultiSelect, paDialog];
end;

Um auf das neu geschaffene Editierereignis zu reagieren, überschreiben wir die Procedure Edit;

procedure TFileNameProperty.Edit;
var
  OpenDialog:TOpenDialog;
begin
  OpenDialog := TOpenDialog.create(Application);//Den OpenDialog erstellen
  try
    //Den akuellen Wert übergeben
    OpenDialog.FileName := GetStrValue;
    //Anzeigen und bei Erfolg Wert übernehmen
    if OpenDialog.Execute then SetStrValue(OpenDialog.FileName);
  finally
    OpenDialog.Free; //Den OpenDialog freigeben.
  end;
end;

Mit GetStrValue und SetStrValue kann der Wert einer Stringeigenschaften gelesen und geschrieben werden. Für andere Eigenschaftstypen stehen andere Funktionen zur Verfügung. An dieser Stelle können natürlich auch eigene Formulare eingeblendet werden.

• Fuer Interessierte: Eigene Dialoge

Durch überschreiben von GetValue kann man regeln, was für ein Text auf der rechten Seite im Objektinspektor angezeigt wird. Ein Überscheiben von SetValue hingegen legt fest, wie auf eingegebene Werte reagiert werden soll. In unserem Fall soll der Eigenschaftsinhalt direkt angezeigt und übernommen werden.

function TFileNameProperty.GetValue: string;
begin
  result := GetStrValue ;
end;

procedure TFileNameProperty.SetValue(const Value: string);
begin
  SetStrValue(Value);
end; 

Wie ihr euch vielleicht noch erinnert, haben wir am Anfang in GetAttributes festgelegt, dass die Eigenschaft auch bei mehrfacher Auswahl sichtbar bleibt. Nun liegt es an uns Delphi zu erklären wann zwei Eigenschaften wirklich identisch sind. Denn schließlich sagt der im Objektinspektor angezeigte Wert nichts über den tatsächlichen Inhalt der Eigenschaft. Durch ein Überschreiben der Funktion AllEqual können wir nun unsere eigene Prüfung definieren.

function TFileNameProperty.AllEqual: Boolean;
var
  Nr1:String;
  I:Integer;
begin
  AllEqual := true;
  Nr1 := GetstrValue ;
  // Ersten Eigenschafts-Wert mit restlichen Werten vergleichen.
  // Die Anzahl der zu überprüfenden Eigenschaften liefert PropCount.
  for I:= 1 to PropCount-1 do
    if Nr1 <> GetstrValueat(I) then
    begin
      AllEqual := false;
      break;
    end;
end;

Nach der Erstellung unserer Eigenschaftseditor-Klasse müssen wir nur noch festlegen für welche Eigenschaften und für welche Komponeten der Editor genutzt werden soll. Dies geschieht durch eine Regestrierung des Editors über einen Aufruf von RegisterPropertyEditor inherhalb der Register-Prozedur.

procedure Register;
begin
  RegisterPropertyEditor(TypeInfo(TFileName),nil,'FileName',TFileNameProperty);
end;

Der erste übergebene Parameter ist der Typ der Eigenschaft für den der Editor gelten soll. Mit dem zweiten Parameter wird festgelegt ob der Editor nur für die Eigenschaft einer bestimmten Komponente oder für alle(durch Angabe von nil) gelten soll. Der dritte Parameter legt fest ob die Eigenschaft einen bestimmten Namen haben muss (Ein leerer String bedeutet keine Festlegung). Der Letze Parameter beinhaltet nun die Editorklasse selbst.

Komponenten-Editoren