Propertys zusammenfassen

[snow]

Hallo

ich hab eine visuelle Komponente geschrieben, die viele published propertys vom typ TColor hat.

ICh würde diese nun gerne im Objectinspector zusammenfassen. Ich hab schon probiert einen Record zu nutzen. Aber der Objectinspector unterstütz anscheindend keine Records. Also hab ichs mit einer Klasse probiert. Doch wo muss ich diese Klassen createn, damit delphi mir keine Zugriffsverletzung an speicherstelle XY vorwirft.

gruß snow

[DeddyH]

Mal im Constructor versucht?

[snow]

Jepp

Delphi-Quellcode:

constructor TJTbahnhofsUhr.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FColors := TJTBahnhofsUhrColors.Create;
end;

doch trotzdem ne zugriffsverletzung.


(FColors ist die Interne variable)

gruß snow

[DeddyH]

Wie sieht denn die Klasse TJTBahnhofsUhrColors aus?

[snow]

sehr simpel

Delphi-Quellcode:

type TJTBahnhofsUhrColors = class(Tobject)
        private
          Fbkcolor          : TColor;
          FPPcolor          : Tcolor;
          FPBColor          : TColor;
        published
          property bkColor : Tcolor read FbkColor write FbkColor;
          property PPColor : Tcolor read FPPColor write FPPColor;
          property PBColor : Tcolor read FPBColor write FPBColor;
        end;

gruß snow

[DeddyH]

Hm... dann weiß ich im Moment auch nicht weiter.

[cruiser]

Die Unterklasse sollte von TPersistant und nicht von TObject abgeleitet werden, damit die puplished Properties auch gespeichert werden

greetz

[Kroko1999]

setze mal das Createn der Color-Klasse vor das inherited

[Hansa]

Er sollte das mit SetSubComponent erledigen. TColor erfordert kein Create und muss auch nicht irgendwie abgeleitet werden.

[DeddyH]

Es geht auch nicht um das Anlegen einer TColor, sondern das einer Klasse mit mehreren Colors.

[Muetze1]

1. Anlegen vor dem inherited braucht nicht sein, macht hier keinen Unterschied.
2. Ableiten von TPersistent (wurde hier schon erwähnt)
3. Assign() überschreiben und implementieren (Pflicht).
4. Diese Klasse über eine Property veröffentlichen und beim Setter nur Assign(Value) aufrufen.

[Kroko1999]

Zitat:

Zitat von Muetze1

1. Anlegen vor dem inherited braucht nicht sein, macht hier keinen Unterschied.
...

Kennst Du den Rest der Klasse?

[Muetze1]

Zitat:

Zitat von Kroko1999

Zitat:

Zitat von Muetze1

1. Anlegen vor dem inherited braucht nicht sein, macht hier keinen Unterschied.
...

Kennst Du den Rest der Klasse?

Mir fällt keine Konstellation ein, wo dies nötig wird. Ausnahme: schlechter Stil

[snow]

Zitat:

. Assign() überschreiben und implementieren (Pflicht).
4. Diese Klasse über eine Property veröffentlichen und beim Setter nur Assign(Value) aufrufen.

ich habs mitlerweile hinbekommen aber:

Wie kann ich nun auf änderungen der farben eingehen ohne für jede farbe eine eigene Set...(value : TColor) procedure zu schreiben.

ich hab probiert auf das ändern der Property zu reagieren aber leider ändert sich die nicht, wenn sich die farbe ändert.

Dieses Assign was genau bewirkt dass?

gruß snow

[Kroko1999]

ansonsten würde ich bei vielen Properties vom gleichen Typ folgendes Konstrukt bevorzugen

Delphi-Quellcode:

TMyClass = class
  private
    FData: array[0..5] of TColor;
    function GetData(const AIndex: Integer): TColor;
    procedure SetData(const AIndex: Integer; const Value: TColor);
  published
    property colColor1: TColor Index 0 read GetData write SetData;
    property colColor2: TColor Index 1 read GetData write SetData;

Man kommt mit einer Get/Set-Proc. aus, kann die Daten auf einen Schlag kopieren, per Schleife sichern und wiederherstellen,
ist nur ein Vorschlag!

[DeddyH]

Und das geht im OI? Ohne Property-Editor?

[Muetze1]

>> Änderungen werden nicht übernommen:

Du kannst jeweils in deiner Unterklasse einen Setter schreiben und der kann dann (wenn nötig, also die geänderte Farbe sichtbar ist) das neuzeichnen der Oberkomponente auslösen.

>> Viele Setter

Du kannst für viele Properties gleichen Typs einen einzigen Setter und auch Getter nutzen. Schau dir dazu mal das Schlüsselwort Index bei den Properties in der Hilfe an. Kroko1999 hat dir schon ein Beispiel getippt. Mit einer Case-Mehrfachverzweigung im Setter kannst du es auch mit unterschiedlichen TColor Membern machen. Beim Getter kannst du dann direkt den jeweiligen Member angeben.

>> Was soll Assign()

Dort übernimmst du alle Werte von der übergebenen Unterkomponenteninstanz, wenn diese angegeben wird. Der Objektinspektor benutzt diese Methode u.a. wenn du mehrere gleiche Objekte markierst und mit Enter die Eigenschaften von einer auf viele übernehmen willst.

>> Das geht ohne Property Editor

Ja, ohne Probleme. TPersistent bringt dazu alles nötige mit und wird unterstützt. Man muss (neben TPersistent als Basis und Assign() überschreiben) nicht viel dazu implementieren.

Wir reden hier aber von den aufklappbaren Unterpunkten. Einen Propertyeditor brauchst du z.B. wenn du eine Listenklasse veröffentlichst, dann hast du schlecht eine Chance ohne Property Editor auszukommen, da du nicht abhängig von den Einträgen Properties definieren kannst.

[Kroko1999]

Zitat:

Zitat von Muetze1

Zitat:

Zitat von Kroko1999

Zitat:

Zitat von Muetze1

1. Anlegen vor dem inherited braucht nicht sein, macht hier keinen Unterschied.
...

Kennst Du den Rest der Klasse?

Mir fällt keine Konstellation ein, wo dies nötig wird. Ausnahme: schlechter Stil

Mir fallen viele Dinge ein, ohne das man von schlechten Stil sprechen kann, zBsp. eine Klasse in einer Klasse, die im Konstruktor des Parentteil bestimmte Dinge setzt, aber in der letztendlichen Klasse von einer Grundklasse abgeleitet wurde, usw. usf.

[Muetze1]

Zitat:

Zitat von Kroko1999

Mir fallen viele Dinge ein, ohne das man von schlechten Stil sprechen kann, zBsp. eine Klasse in einer Klasse, die im Konstruktor des Parentteil bestimmte Dinge setzt, aber in der letztendlichen Klasse von einer Grundklasse abgeleitet wurde, usw. usf.

Dann bekommt die Unterklasse im Konstruktor die Hauptklasse mitgegeben. Auf die kann sie sich beziehen und man hat keine Probleme. Die Hauptklasse befindet sich zu dem Zeitpunkt im Constructor und somit kann sie Self mitgeben. Damit ist alles oben beschrieben möglich. Durch die Ableitung kann man sogar mit einer unspezifizierten Basisklasse als Constructor Parameter arbeiten.

[Jens Schumann]

Hallo,
ich verwende für "Subproperties" folgende Standartvorlage

Delphi-Quellcode:

  TMyPersistent = class(TPersistent)
  private
    FColor   : TColor;
    FOnChange : TNotifyEvent;
    procedure SetColor(Value : TColor);
  protected
    procedure DoChange; virtual;
  public
    constructor Create;
    destructor  Destroy; override;
    procedure Assign(Source : TPersistent); override;
    property  OnChange : TNotifyEvent read FOnChange write SetOnChange;
  published
    property Color   : TColor read FColor write SetColor;
  end;


procedure TMyPersistent .SetColor(Value : TColor);
begin
  If FColor<>Value then
    begin
    FColor:=Value;
    DoChange;
    end;
end;


procedure TMyPersistent .DoChange;
begin
  If Assigned(FOnChange) then
    FOnChange(Self);
end;

procedure TMyPersistent.Assign(Source : TPersistent); override;
begin
  If Source is TMyPersistent then
    begin
    FColor:=TMyPersistent(Source).Color;
    end;
  inherited Assign(Source);
end;

[andreash]

Die Methode Assign sollte besser so implementiert werden, da es sonst zu einem Fehler kommt.

Delphi-Quellcode:

procedure TMyPersistent.Assign(Source : TPersistent); override;
begin
  If Source is TMyPersistent then
  begin
    FColor:=TMyPersistent(Source).Color;
  end
  else
    inherited Assign(Source);
end;