Liste von vielen unterschiedlichen Grafikobjekten mit unterschiedlichen Properties

[Bjoerk]

Ich hab eine Liste von vielen unterschiedlichen Grafikobjekten mit unterschiedlichen Properties. Die published Werte markierter Objekte sollen nun editiert werden können. Die Frage wäre, wie macht man das denn am besten? :gruebel:

Beispielklasse:

Delphi-Quellcode:

  TCadRect = class(TPersistent)
  private
    FP1: TCadFloatPoint;
    FP2: TCadFloatPoint;
    FTyp: TGraphicObjectTyp;
    FPenMMWidth: double;
    FPenColor: TColor;
    FPenStyle: TColor;
    FBrushColor: TColor;
    FBrushStyle: TColor;
    FDesigning: boolean;
    FEnabled: boolean;
    FComment: string;
    FCrossRect: boolean;
    FSnapPoints: TFloatPoints;
    FRegion: TPolygon;
    FProp: TPropBooleanArray;
    FAction: TActionBooleanArray;
    FSelected: boolean;
    FPropertySelected: boolean;
    function GetScale: TScale;
    function GetScalemX1: double;
    function GetScalemY1: double;
    function GetScalemX2: double;
    function GetScalemY2: double;
    function GetAngle: double;
    function GetScalemWidth: double;
    function GetScalemHeight: double;
    function GetProp(Index: TProp): boolean;
    function GetAction(Index: TAction): boolean;
    procedure SetScale(const Value: TScale);
    procedure SetNewScale(const Value: TScale);
    procedure SetScalemX1(const Value: double);
    procedure SetScalemY1(const Value: double);
    procedure SetScalemX2(const Value: double);
    procedure SetScalemY2(const Value: double);
    procedure SetAngle(const Value: double);
    procedure SetScalemWidth(const Value: double);
    procedure SetScalemHeight(const Value: double);
    function ClipRect: TFloatRectEx;
    procedure Flip(const A, B: TFloatPoint);
  public
    function MovePtInRegion(const MovePt: TFloatPoint): boolean;
    function CenterRegionPtInSelectRect(const SelectRect: TFloatRectEx): boolean;
    function Compare(Value: TCadRect): boolean;
    procedure Assign(Value: TCadRect);
    procedure LoadFromFile(Ini: TIniDatei; const Section: string);
    procedure SaveToFile(Ini: TIniDatei; const Section: string);
    procedure Draw(Canvas: TCanvas; const Plot: TPlotDevice);
    procedure DrawRegion(Canvas: TCanvas; const Plot: TPlotDevice);
    procedure SetRegion(const Plot: TPlotDevice);
    procedure SetSnapPoints(SnapPoints: TFloatPoints);
    procedure Rotate(const R: TFloatPoint; const Alpha: double);
    procedure Shift(const ValueX, ValueY, Alpha: double);
    procedure FlipHorz(const Y: double);
    procedure FlipVert(const X: double);
    procedure Duplicate(Value: TCadRect; const Order: TModifyOrder);
    procedure Modify(const Order: TModifyOrder);
    procedure Clear;
    property SnapPoints: TFloatPoints read FSnapPoints;
    property P1: TCadFloatPoint read FP1;
    property P2: TCadFloatPoint read FP2;
    property Typ: TGraphicObjectTyp read FTyp write FTyp;
    property Prop[Index: TProp]: boolean read GetProp;
    property Action[Index: TAction]: boolean read GetAction;
    property Selected: boolean read FSelected;
    property PropertySelected: boolean read FPropertySelected write FPropertySelected;
    constructor Create;
    destructor Destroy; override;
  published
    property PenMMWidth: double read FPenMMWidth write FPenMMWidth;
    property PenColor: TColor read FPenColor write FPenColor;
    property PenStyle: TColor read FPenStyle write FPenStyle;
    property BrushColor: TColor read FBrushColor write FBrushColor;
    property BrushStyle: TColor read FBrushStyle write FBrushStyle;
    property Scale: TScale read GetScale write SetScale;
    property NewScale: TScale write SetNewScale;
    property Designing: boolean read FDesigning write FDesigning;
    property Enabled: boolean read FEnabled write FEnabled;
    property Comment: string read FComment write FComment;
    property CrossRect: boolean read FCrossRect write FCrossRect;
    property ScalemX1: double read GetScalemX1 write SetScalemX1;
    property ScalemY1: double read GetScalemY1 write SetScalemY1;
    property ScalemX2: double read GetScalemX2 write SetScalemX2;
    property ScalemY2: double read GetScalemY2 write SetScalemY2;
    property ScalemWidth: double read GetScalemWidth write SetScalemWidth;
    property ScalemHeight: double read GetScalemHeight write SetScalemHeight;
    property Angle: double read GetAngle write SetAngle;
  end;

[Stevie]

Einfachste Möglichkeit wäre, einer der zahllosen ObjektInspector Komponenten, die es so gibt, zu benutzen.
Zum Beispiel TJvInspector aus der JVCL.

[DeddyH]

Und da dürfen dann aber nur die Properties angezeigt werden, die allen aktuell markierten Objekten gemein sind. Es muss also irgendwie eine Schnittmenge gebildet werden.

[Bjoerk]

DeddyH, wir hatten schon mal kurz vor ca. einem Jahr darüber im DT gesprochen. Einen OI der alle möglichen Props meiner Objekte anzeigt gibt es schon. Die Frage ist wie krieg ich die aktuellen Werte meiner Liste in die Edits, Comboxen ect. und wie schreib ich die zurück?

[DeddyH]

Du kannst doch nach meinem Dafürhalten nur die Werte tatsächlich anzeigen, die bei allen Objekten gleich sind. Sind sie das nicht, muss das Feld in Deinem OI eben leer bleiben. Trägt der Benutzer nun einen Wert ein, wirst Du wohl mit einer Schleife über die Objekte gehen und diesen Wert zuweisen müssen.

[Bjoerk]

Das krieg ich nicht hin? Ernsthaft. :oops:

[DeddyH]

Aus der Hüfte geschossen: (ich weiß gerade nicht aus dem Kopf, ob es eine solche Struktur oder Klasse schon gibt, notfalls erstellt man sie eben selbst) wir brauchen den Property-Namen, dessen Typ und dessen Wert in einem Record/einer Klasse. Davon erstellen wir eine Liste und gehen nun die markierten Objekte durch. Das erste Objekt befüllt nun diese Liste, bei jedem weiteren wird geprüft:
- Property aus Liste (mit identischem Typ) vorhanden? Nein -> aus Liste löschen
- Wert der Property entspricht dem aus der Liste? Nein -> Wert löschen

Es wird also ggf. lediglich die Liste ausgedünnt, neue Elemente kommen nicht hinzu. Zum Schluss werden im "OI" nur noch die verbliebenen Properties angezeigt und auch nur die Werte, die "überlebt" haben. Nach Änderung durch den Benutzer wird der Wert wieder in einer Schleife der entsprechenden Property der Objekte zugewiesen.

[Bjoerk]

Weiß nicht recht? Wer soll diese Klasse in einem Jahr nochmal verstehen, erweitern, ergänzen, ändern? Kann man vielleicht mit einer IniFile als Schnittstelle was machen? Ich hab echt keine Idee mehr..

Delphi-Quellcode:

[Prop1]
Master = Object1
Slave1 = Object2
Slave2 = Object100
[Prop2]
..

[DeddyH]

Mir ist ehrlich gesagt nicht klar, wie da nun eine IniFile weiterhelfen soll. Oder aber ich habe das Problem gründlich missverstanden.

[Jens01]

Hi,
etwas ähnliches, aber einfacher, habe ich mal mit einer Holzliste gemacht. Da werden Höhe, Breite, Länge usw in jeweiligen Edits angezeigt. Wenn alle Werte der markierten Hölzer -zB die Breite- gleich ist, dann wird der Wert im Edit angezeigt, wenn die Werte unterschiedlich sind, dann ist das Edit-Feld leer. Wenn ins Edit etwas eingetragen wird, dann werden alle markierten Hölzer auf den Wert geändert.
Meinst Du sowas? Ich müßte mal gucken, wie ichs gemacht habe. War aber irgendwas mit Schleifen.

[Sir Rufo]

Da du ja die Eigenschaften von mehreren unterschiedliche Objekte zusammenfassen möchtest, brauchst du zunächst etwas, was du vergleichen kannst um gleiche Eigenschaften zusammenzufassen.

Oder anders ausgedrückt, wir benötigen eine Klasse, die eine Eigenschaft darstellen kann (aber nur die Eigenschaft selber, ohne den Wert)

Delphi-Quellcode:

TProperty = class
public
  constructor Create( const PropName : string; PropType : integer );
  function Equals( Obj : TObject ) : Boolean; override;
  function SameValueAs( Other : TProperty ) : Boolean;
published
  property PropName : string read FPropName;
  property PropType : integer read FPropType;
end;

function TProperty.Equals( Obj : TObject ) : Boolean;
begin
  Result := (Self = Obj) or Assigned( Obj ) and ( Self.ClassType = Obj.ClassType ) and SameValueAs( Obj as TProperty );
end;

function TProperty.SameValueAs( Other : Tproperty ) : Boolean;
begin
  Result := (Self = Other) or Assigned( Other ) and SameText( Self.FPropName, Other.FPropName ) and (Self.FPropType = Other.FPropType );
end;

Die nächste Klasse, wäre dann die, wo man auf den Eigenschaftswert zugreifen kann

Delphi-Quellcode:

TPropertyValue = class
public
  constructor Create( Instance : TObject; const PropName : string );
  // True, wenn gleiche Eigenschaft und gleicher Wert
  function Equals( Obj : TObject ) : Boolean; override;
  function SameValueAs( Other : TPropertyValue ) : Boolean;
published
  property Prop : TProperty read FProp;
  property ValueStr : string read GetValueStr write SetValueStr;
end;

Um jetzt ein ganze Instanz zu verwalten benötigen wir eine Klasse, die eine Liste mit den Property-Werten anbietet:

Delphi-Quellcode:

TObjectProperties = class abstract
public
  property Count : Integer read GetCount;
  property PropValue[Index : Integer] : TPropertyValue read GetPropValue;
end;

und diese Klasse benötigen wir für eine Instanz

Delphi-Quellcode:

TSingleObjectProperties = class( TObjectProperties )
public
  constructor Create( Instance : TObject );
end;

und für mehrere

Delphi-Quellcode:

TMultiObjectProperties = class( TObjectProperties )
public
  procedure Add( Object : TSingleObjectProperties );
  procedure Remove( Object : TSingleObjectProperties );
end;

Das ist jetzt alles etwas schematisch, aber das Prinzip sollte jetzt klar geworden sein.

[DeddyH]

Das ist ja ziemlich genau das, was ich gesagt hatte, in Code gegossen. Nur ist sich Bjoerk nicht sicher, ob er später noch versteht, was er da gemacht hat ;)

[Sir Rufo]

Zitat:

Zitat von DeddyH (Beitrag 1266938)

Das ist ja ziemlich genau das, was ich gesagt hatte, in Code gegossen. Nur ist sich Bjoerk nicht sicher, ob er später noch versteht, was er da gemacht hat ;)

Er erweckte in mir den Eindruck deine Worte nicht in Code umsetzen zu können, und mit der Ini-Datei war er auch auf dem völlig falschen Dampfer unterwegs ;)

Sollte nur ein etwas gröberer Stubser werden

[Bjoerk]

Bei einer Holzliste ist das sicherlich kein Problem.. Was machst du wenn das eine Object mit dem andern fast nichts zu tun hat? Den Ansatz von Sir Rufo und DeddyH schaut "ER" sich nachher genauer an, "ER" muß jetzt erst mal was essen..

BTW, jetzt hab ich so, daß ich alles in einem "TMegaShape" drin hab. Wollte aber eigentlich keinen Katastrophencode mehr produzieren..

[Jens01]

Zitat:

Was machst du wenn das eine Object mit dem andern fast nichts zu tun hat?

Vielleicht eine Grundklasse erstellen. Farbe usw könnte man dorthin verfrachten. Wenn die Daten/Properties nichts miteinander zu tun haben, ist fraglich, ob man sie gleich behandeln sollte.
Man könnte mit diesem rtti gleiche Namen heraussuchen, hmm..:gruebel:

Deine Software sieht aber schon ganz gut aus, naja für Betonbauer;)

[stahli]

Zitat:

Zitat von Bjoerk (Beitrag 1266891)

DeddyH, wir hatten schon mal kurz vor ca. einem Jahr darüber im DT gesprochen. Einen OI der alle möglichen Props meiner Objekte anzeigt gibt es schon. Die Frage ist wie krieg ich die aktuellen Werte meiner Liste in die Edits, Comboxen ect. und wie schreib ich die zurück?

Hallo Bjoerk,

Dein Screenshot hat mich animiert, den Thread nochmal genauer anzuschauen...
Respekt für das erreichte. Sieht richtig cool und aufgeräumt aus.

Wenn ich Dich richtig verstehe suchst Du nach "Databinding" (wobei Dein Screenshot suggeriert, dass das schon gelöst ist).
Oder ist Dein Problem nur, wie Du mit unterschiedlichen Werten mehrerer markierter Objekte umgehen sollst?

[Bjoerk]

Thanx. Das Ganze ist auch (fast) schon fertig, aber m.E. ziemlich unprofessionell gelöst? Es gibt ein zweidimensionales Array[Aufzahlungstyp über alle ShapeTypen, AufzählungsTyp über alle PropertiyTypen] of boolean.

Zum Beispiel hat das Objekt Line die Properties X1, Y1, X2, Y2.Diese Klasse setzt nun im Constructor

Delphi-Quellcode:

  Prop[gtLine, X1Prop] := true;
  Prop[gtLine, X2Prop] := true;
  Prop[gtLine, Y1Prop] := true;
  Prop[gtLine, Y2Prop] := true;

Der OI bekommt eine aktuelle Liste und geht a) die ganze Liste von hinten bis vorne durch b) über alle Typen und c) über alle Props. Wenn ein Object der Liste markiert ist und es ein X1Prop hat dann erzeugt der OI (einmal) ein TEdit, setzt einen TabIndex und gibt dem Edit als Tag TProp(X1Prop) mit. Der Oi setzt auch zweites Edit und schreibt "das ist die X1 Koordinate in Metern".

Und Schließlich speichert den Wert der Property in TEdit.Text.

Delphi-Quellcode:

 if CurrentItem.Prop[X1Prop] then EditX1.Text := FloatToStr(Item.X1);

Dann legt der OI eine Kopie aller Edit.Texts and an und überprüft bei jedem TEdit.OnExit ob sich ein Wert geändert hat.
Falls ja speichert den Wert zurück und zeichnet die Grafik neu.

Delphi-Quellcode:

 if CurrentItem[X1Prop] and (Edit.Tag = TProp(X1Prop)) then Item.X1 := StrToFloat(EditX1.Text);

Hinzu kommt daß es nur Object gibt daß Instanzen aller Klassentypen hat. *gmpf*

[stahli]

Wenn Du magst, dann schau mal nach DSharp oder ssFramework. Beide realisieren ein Databinding.
Am ssFramework arbeite ich aber nicht mehr weiter.
(Embarcadero unterstützt ja inzwischen auch LiveBindings, aber da will ich mal nicht weiter drauf eingehen.)

Grundsätzlich kann man die Eigenschaften der Objekte direkt untersuchen und diese nach Namen ermitteln. Vor D2010 gab es dafür IsPublishedProp.
Damit kann man ermitteln, ob ein Objekt die veröffentlichte Eigenschaft XYZ besitzt und dessen Wert verarbeiten.

Ab D2010 gibt es mit der neuen RTTI dafür noch deutlich mehr Möglichkeiten.

Wenn Deine Lösung so funktioniert würde ich es dabei belassen. Ein komplettes Databindingframework aufzubauen wird sich für ein (fast fertiges Projekt) nicht lohnen.
Wenn man aber von vorn herein eine solche Lösung verfügbar hat, dann kann man sich viel Arbeit sparen. Deshalb will ich ohne Databinding auch möglichst nicht mehr arbeiten.

Im Grunde kannst Du dann mit normalen Controls wie mit DBControls arbeiten und die an die Datenschicht binden. Die Datenschicht ist dann nur keine Datenbank sondern ein Manager, der das benötigte Objekt ermittelt und den Wert dessen benötigter Eigenschaft zurück gibt.

[Sir Rufo]

@stahli

Niemand sucht in diesem Thread nach DataBinding

Hier wird nach einer Möglichkeit gesucht, von einer Gruppe von Instanzen, die als gemeinsamen Vorfahren TObject haben, die Eigenschaften herauszufinden, die in diesen Instanzen vorkommen (das nennt sich Schnittmenge).

Wie diese Eigenschaften dann angezeigt und bearbeitet werden hat er gelöst (siehe Screenshot), wenn er diese denn nur hätte. Das DataBinding kann ihm da genauso helfen, wie das Bemalen der Blätter der Bäume an der Allee von der Straße wo man auch schon mal hergefahren ist, wenn man kein Benzin im Tank hat. Sieht lustig aus, ist nicht langweilig, aber hilft beim aktuellen Problem nicht weiter.

[Bjoerk]

Stahli, auch selbst wenn ich das Beispiel von Sir Rufo / DeddyH verstehen würde dann wärs vermutlich ein neues Programm? Dein ssFramework kenn ich vom Namen her hab es aber noch nie verwendet. Ist bestimmt sehr gut.

Ich lass es jetzt erst mal so. Sooo schlimm isses eigentlich nicht (wenn man so viel wie möglich wegkapselt). Mit meinem Codegenerator geht’s eigentlich ganz gut.

Delphi-Quellcode:

procedure TGraphicShape.DoSomething;
begin
  if Util_LineWerkzeug(FTyp) then
    case FTyp of
      gtLine:
        FLine.DoSomething;
      gtCircleLine:
        FCircleLine.DoSomething;
      gtHelpLine:
        FHelpLine.DoSomething;
      gtArrow:
        FArrow.DoSomething;
      gtPos:
        FPos.DoSomething;
      gtPosition:
        FPosition.DoSomething;
      gtDimension:
        FDimension.DoSomething;
      gtGerade:
        FGerade.DoSomething;
      gtSchnitt:
        FSchnitt.DoSomething;
      gtAchse:
        FAchse.DoSomething;
      gtHint:
        FHint.DoSomething;
      gtPosHint:
        FPosHint.DoSomething;
      gtDoubleLine:
        FDoubleLine.DoSomething;
    end
  else
    if Util_PolygonWerkzeug(FTyp) then
      case FTyp of
        gtPolyLine:
          FPolyLine.DoSomething;
        gtPolygon:
          FPolygon.DoSomething;
        gtRubber:
          FRubber.DoSomething;
        gtNEck:
          FNEck.DoSomething;
        gtHelpPolygon:
          FHelpPolygon.DoSomething;
        gtHelpNEck:
          FHelpNEck.DoSomething;
      end
    else
      if Util_RectWerkzeug(FTyp) then
      begin
        case FTyp of
          gtRect:
            FRect.DoSomething;
          gtCircle:
            FCircle.DoSomething;
          gtTriangle:
            FTriangle.DoSomething;
          gtAngleDimension:
            FAngleDimension.DoSomething;
        end
      end
      else
        if Util_ProfilWerkzeug(FTyp) then
          case FTyp of
            gtI:
              FI.DoSomething;
            gtHalfI:
              FHalfI.DoSomething;
            gtU:
              FU.DoSomething;
            gtL:
              FL.DoSomething;
            gtZ:
              FZ.DoSomething;
            gtT:
              FT.DoSomething;
            gtPipe:
              FPipe.DoSomething;
            gtFrame:
              FFrame.DoSomething;
            gtEllipsePipe:
              FEllipsePipe.DoSomething;
          end
        else
          if Util_TextWerkzeug(FTyp) then
            case FTyp of
              gtText:
                FText.DoSomething;
              gtKote:
                FKote.DoSomething;
            end
          else
            if Util_GraphicWerkzeug(FTyp) then
              case FTyp of
                gtGraphic:
                  FGraphic.DoSomething;
              end
            else
              if Util_ReinforcementWerkzeug(FTyp) or Util_ReinforcementPolygonWerkzeug(FTyp) then
                case FTyp of
                  gtGeschlossenerBuegel:
                    FGeschlossenerBuegel.DoSomething;
                  gtOffenerBuegel:
                    FOffenerBuegel.DoSomething;
                  gtRandbuegel:
                    FRandbuegel.DoSomething;
                  gtOffenerBuegelExInnen:
                    FOffenerBuegelExInnen.DoSomething;
                  gtOffenerBuegelExAussen:
                    FOffenerBuegelExAussen.DoSomething;
                  gtKoecherbuegel:
                    FKoecherbuegel.DoSomething;
                  gtSteckbuegel:
                    FSteckbuegel.DoSomething;
                  gtStab:
                    FStab.DoSomething;
                  gtCircleStab:
                    FCircleStab.DoSomething;
                  gtWinkel:
                    FWinkel.DoSomething;
                  gtAufbiegung:
                    FAufbiegung.DoSomething;
                  gtStabPunkt:
                    FStabPunkt.DoSomething;
                  gtSchlaufe:
                    FSchlaufe.DoSomething;
                  gtSHaken:
                    FSHaken.DoSomething;
                  gtMatteVertikal:
                    FMatteVertikal.DoSomething;
                  gtMatteHorizontal:
                    FMatteHorizontal.DoSomething;
                  gtMatte:
                    FMatte.DoSomething;
                  gtApsta:
                    FApsta.DoSomething;
                  gtPolygonStab:
                    FPolygonStab.DoSomething;
                end;
end;

Wenigstens "etwas" RTTI kann ich nutzen. :)

Delphi-Quellcode:

function Util_TGraphicObjectTypToStr(const Value: TGraphicObjectTyp): string;
begin
  Result := GetEnumName(TypeInfo(TGraphicObjectTyp), Ord(Value));
end;

function Util_TPropToStr(const Value: TProp): string;
begin
  Result := GetEnumName(TypeInfo(TProp), Ord(Value));
end;

function Util_TActionToStr(const Value: TAction): string;
begin
  Result := GetEnumName(TypeInfo(TAction), Ord(Value));
end;

LG
Thomas

[Bjoerk]

Jens, deine Idee Werkzeuge zu gruppieren werd' ich umsetzen. Thanx! Damit kann der case Kram weggekapselt werden.

Bei meinem OI ist es übrigens so daß nicht nur die Schnittmenge angezeigt wird sondern alle Eigenschaften, sofern sie denn vorhanden sind. Zur Unterscheidung für den User werden die InfoEdits dieser Eigenschaften dann mit Font.Color rot statt blau angezeigt.

[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

Delphi-Quellcode:

protected

. Wird diese Eigenschaft in einer Klasse dann benötigt, dann einfach als

Delphi-Quellcode:

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.

[Bjoerk]

Hab nur ein Klasse? Ein Bezug fehlt da nicht? Das Ding ist ja schließlich markiert und hat diese Eigenschaft? Aber ich kann's als Option anbieten. Ist ja mit meinem Hiftsarray no problem nur die Gemeinsamen anzuzeigen.

Delphi-Quellcode:

    N := PropertySelectedCount;
    if N > 1 then
      for I := Low(TProp) to High(TProp) do
        if Properties.Count[I] < N then
          Properties.Prop[I] := false;

Danke für den Hinweis!

[Bjoerk]

Ah. Jetzt. Ja. Kaum vergeht ein Jahr schon ist mir das jetzt auch klar. :)

Gruß an DeddyH. :thumb: Eben bei einem Ereignis hab ich‘s gemerkt. Es können in der Tat nur Eigenschaften und Methoden dargestellt werden die alle markierten Elemente teilen. Also nix mit rot und blau.. :-D

Und auch nochmal Danke an Sir Rufo Sir, ohne dich hätts vermutlich noch n Jahr gedauert... :oops: