Liste von vielen unterschiedlichen Grafikobjekten mit unterschiedlichen Properties

[Sir Rufo]

Wenn ich mir das recht überlege, dann ist mein Ansatz zwar umsetzbar, allerdings mit einem sehr, sehr hohem Aufwand. Du müsstest jede Eigenschaft dahingehend untersuchen, ob diese wirklich jetzt vom Namen und Typ exakt übereinstimmt.

Der OI von Delphi geht hierbei ja die Vererbungsliste der Klassen durch, bis er die größte gemeinsame Basis-Klasse gefunden hat und zeigt die Eigenschaften dieser Basis-Klasse an. Das ist sehr simpel zu realisieren.

Schwierig wird es, wenn unterschiedliche Objekte mit gleichem Eigenschaftsnamen und gleichem Typ aber etwas Anderes bedeuten (etwas konstruiert, aber denkbar). Unübersichtlich wird es, wenn bei den Objekten Eigenschaften mit gleichem Namen und unterschiedlichen Typen vorkommen und diese nun in der Liste präsentiert werden. Dann spielt es keine Rolle mehr, ob die nun farblich markiert sind oder nicht, der Anwender wird verwirrt, wenn dort Eigenschaften mit gleichem Namen auftauchen, weil dann der Bezug fehlt.

Du kannst auch eine Mega-Basis-Klasse erstellen mit allen Eigenschaften, die bei allen Objekten vorkommen, diese allerdings protected . Wird diese Eigenschaft in einer Klasse dann benötigt, dann einfach als published deklarieren.

Delphi-Quellcode:

TCustomFoo = class
private
  FValue1 : Integer;
  FValue2 : string;
  procedure SetValue1( const Value : Integer );
  procedure SetValue2( const Value : string );
protected
  procedure SomeValueChanged; virtual;
  property Value1 : Integer read FValue1 write SetValue1;
  property Value2 : string read FValue2 write SetValue2;
end;

procedure TCustomFoo.SetValue1( const Value : Integer );
begin
  if FValue1 <> Value then
  begin
    FValue1 := Value;
    SomeValueChanged;
  end;
end;

procedure TCustomFoo.SetValue2( const Value : string );
begin
  if FValue2 <> Value then
  begin
    FValue2 := Value;
    SomeValueChanged;
  end;
end;

procedure TCustomFoo.SomeValueChanged;
begin
end;

TFoo = class( TCustomFoo )
protected
  procedure SomeValueChanged; override;
published
  property Value1;
end;

procedure TFoo.SomeValueChanged;
begin
  inherited;
  // Neuzeichnen ... oder was auch immer auslösen
end;

TBar = class( TFoo )
protected
  procedure SomeValueChanged; override;
published
  property Value2;
end;

procedure TBar.SomeValueChanged;
begin
  inherited;
  // Neuzeichnen ... oder was auch immer auslösen
end;

Neue Eigenschaften werden dann in der Basis-Klasse eingeführt und in der abgeleiteten Klasse auf published gesetzt. Das funktioniert dann ohne die anderen Klassen zu stören und man hat garantiert keine Überschneidungen bei den Eigenschaftsnamen.