Eine Eigenschaftseditor-Klasse ableiten

Nach oben zu Eigenschaftseditoren hinzufügen

In beiden Komponentenbibliotheken sind mehrere Arten von Eigenschaftseditoren definiert, die von der Klasse TPropertyEditor abgeleitet sind. Beim Erstellen eines Editors können Sie Ihre Editorklasse entweder direkt von TPropertyEditor oder indirekt von einer der in der folgenden Tabelle aufgeführten Klassen ableiten. Die Klassen in der Unit DesignEditors können für VCL-Anwendungen verwendet werden.

Hinweis: Ein Eigenschaftseditor muss unbedingt von der Klasse TBasePropertyEditor abgeleitet sein und das Interface IProperty unterstützen. TPropertyEditor stellt eine Standardimplementierung des Interface IProperty bereit.

Die folgende Tabelle ist nicht vollständig. Die Unit VCLEditors enthält auch einige spezialisierte Editoren, die nur für eine bestimmte Eigenschaft verwendet werden (z. B. für den Komponentennamen). Die aufgelisteten Eigenschaftseditoren eignen sich am besten für benutzerdefinierte Eigenschaften.

Vordefinierte Eigenschaftseditor-Typen:

Typ	Bearbeitbare Eigenschaften
TOrdinalProperty	Alle von TOrdinalProperty abgeleiteten Editoren für Integer-, Zeichen- und Aufzählungseigenschaften
TIntegerProperty	Alle Integer-Typen einschließlich vor- und benutzerdefinierter Teilbereiche
TCharProperty	Char-Typ und Teilbereiche von Char wie 'A'..'Z'
TEnumProperty	Alle Aufzählungstypen
TFloatProperty	Alle Gleitkommawerte
TStringProperty	Strings.
TSetElementProperty	Einzelne Elemente in Mengen (angezeigt als boolesche Werte)
TSetProperty	Alle Mengen. Mengen können nicht direkt bearbeitet werden. Sie können aber als Liste der Eigenschaften der Mengenelemente angezeigt werden.
TClassProperty	Klassen. Es wird der Name der Klasse angezeigt und die Eigenschaften der Klasse können angezeigt werden.
TMethodProperty	Methodenzeiger, vor allem Ereignisse
TComponentProperty	Komponenten im selben Formular. Der Benutzer kann die Eigenschaften der Komponente nicht bearbeiten, aber auf eine bestimmte Komponente eines kompatiblen Typs verweisen.
TColorProperty	Komponentenfarben. Sie werden als Farbkonstanten oder hexadezimale Werte angezeigt. Die Dropdown-Liste enthält die Farbkonstanten. Durch Doppelklicken wird ein Dialogfeld zur Farbauswahl geöffnet.
TFontNameProperty	Schriftartnamen. In der Dropdown-Liste werden alle im System installierten Schriftarten angezeigt.
TFontProperty	Schriftarten. Einzelne Schriftarteigenschaften können erweitert und das Dialogfeld „Schriftart“ kann geöffnet werden.

Zuordnen von unbenannten Aufzählungen

Für unbenannte Aufzählungen zeigt die IDE Zahlen anstelle von Namen an. In diesem Abschnitt wird die Zuordnungstechnik für Namen zu Zahlen in der Menge erläutert, damit die Namen im Objektinspektor angezeigt werden.

Das folgende Codebeispiel zeigt, wie unbenannte Aufzählungen zu bestimmten Namen mithilfe der Eigenschaftszuordnungsfunktion zugeordnet werden:

unit DemoComponent;

interface

uses
  System.SysUtils, Vcl.Forms, System.Classes, Vcl.Controls, Vcl.Menus, TypInfo, Vcl.Graphics,
  DesignIntf, DesignEditors, DesignConst, DesignMenus, VclEditors;

  const
  Bit0     = 0;
  Bit1     = 1;
  Bit2     = 2;
  Bit3     = 3;
  Bit4     = 4;
  Bit5     = 5;
  Bit6     = 6;
  Bit7     = 7;
  BitCount = 8;

type
  TSomeBits = 0..SizeOf(Integer) * 8 - 1;
  //OR
  //TASetOfBits = Bit0..Bit7;
  TPiecesOfEight = set of TSomeBits;

  //IMPORTANT to use "VclEditors.TSetProperty"
  //The DesignEditors.TSetProperty will have the old True/False dropdown editor
  TPiecesOfEightProperty = class(VclEditors.TSetProperty)
  public
    function GetValue: string; override;
    procedure GetProperties(Proc: TGetPropProc); override;
  end;

  TPiecesOfEightElementProperty = class(TSetElementProperty)
  public
    function GetName: string; override;
  end;

  TPiecesOfEightControl = class(TComponent)
  private
    FPiecesOfEightValues: TPiecesOfEight;
  published
    property PiecesOfEight: TPiecesOfEight read FPiecesOfEightValues write FPiecesOfEightValues;
  end;

procedure Register;

implementation
const
  cBitValues : array [Bit0..Bit7] of string = (
  'Bit One'    ,
  'Bit Two'    ,
  'Bit Three'  ,
  'Bit Four'   ,
  'Bit Five'   ,
  'Bit Six'    ,
  'Bit Seven'  ,
  'Bit Eight'
  );

procedure TPiecesOfEightProperty.GetProperties(Proc: TGetPropProc);
var
  I: integer;
  E: IProperty;
begin
  with GetTypeData(GetTypeData(GetPropType)^.CompType^)^ do
  begin
    //for I := MinValue to Maxvalue do // is a smaller set is used.
    for I := MinValue to BitCount-1 do
    begin
      E := TPiecesOfEightElementProperty.Create(Self, I);
      Proc(E);
      E := nil;
    end;
  end;
end;

function TPiecesOfEightProperty.GetValue: string;
var
  I : integer;
  S: TIntegerSet;
begin
  Integer(S) := GetOrdValue;
  Result := '';
  for I := 0 to SizeOf(Integer) * 8 - 1 do
    if I in S then
      Result := Result + cBitValues[I+Low(TSomeBits) ] + ',';
  if Result.EndsWith(',') then Delete(Result, Length(Result), 1);
    Result := '[' + Result + ']';
end;

function TPiecesOfEightElementProperty.GetName: string;
begin
   Result := cBitValues[Element];
end;

//For "sets", the VCLDesigner code always maps the property editor back to: VclEditors.TSetProperty.
//So we need to make OUR set's properties map to *our* editor implementation
function SetPiecesOfEightPropertyMapper(Obj: TPersistent; PropInfo: PPropInfo): TPropertyEditorClass;
begin
  Result := nil;
  if Assigned(Obj) and (Obj.ClassType <> TPiecesOfEightControl) then Exit;
  if PropInfo.PropType^.Kind = tkSet then
    if PropInfo.PropType^ = TypeInfo(TPiecesOfEight) then
      Result := TPiecesOfEightProperty;
end;

procedure Register;
begin
  RegisterComponents('Test Group', [TPiecesOfEightControl]);
  RegisterPropertyMapper(SetPiecesOfEightPropertyMapper);
  RegisterPropertyEditor(TypeInfo(TPiecesOfEight), TPiecesOfEightControl, 'PiecesOfEight', TPiecesOfEightProperty);
end;
end.