Programm vergißt Komponenteneinstellung im Objektinspektor

[DrUArn]

Hi, Comm.,
prinzipielle Frage zur Darstellung und Übernahme von Eigenschaften aus dem Objektinspektor:

Delphi-Quellcode:

  TTestpanel = class(Tpanel)
  private
    FcheckA: TCheckBox;
    FcheckB: TCheckBox;

    { private declarations }
  protected
    { protected declarations }
  public
    { public declarations }

  published
    { published declarations }
    property checkA: TCheckBox read FcheckA write FcheckA;
    property checkB: tcheckbox read FcheckB write FcheckB;
    constructor create(AOWNER:tcomponent);override;
  end;


constructor TTestpanel.create(AOWNER: tcomponent);
begin
  inherited;
  checkA:=tcheckbox.Create(self);
  checkA.Caption:='A';
  InsertControl(checkA);
  checkb:=tcheckbox.Create(self);
  checkB.Caption:='B';
  checkB.top:=checkB.top+15;
  InsertControl(checkB);
end;

Stellt man im Objektinspektor die Eigenschaft checkA.checked auf true, sieht man das auch auf dem Formular - aber nach Start des Programms ist dieses checked=true wieder weg.

Spendiere ich z.B. checkA eine Setter und getter:

[DELPHI]

Delphi-Quellcode:

  TTestpanel = class(Tpanel)
  private
    FcheckA: TCheckBox;
    FcheckB: TCheckBox;
    procedure setcheckA(const Value: TCheckBox);
    Function getcheckA:tcheckbox;
    { private declarations }
  protected
    { protected declarations }
  public
    { public declarations }

  published
    { published declarations }
    property checkA: TCheckBox read FcheckA write setcheckA;
    property checkB: tcheckbox read FcheckB write FcheckB;
    constructor create(AOWNER:tcomponent);override;
  end;


procedure TTestpanel.setcheckA(const Value: TCheckBox);
begin
 FcheckA:=value;
end;

function TTestpanel.getcheckA: tcheckbox;
begin
result:=FcheckA;
end;

bleibt ales beim alten. SetcheckA wird im Debug-Modus erreicht, die Voreinstellung des Objektinspektors aber nicht übernommmen.

Nun speicherte ich den Zustand von checkA.Checked in einer Extra-Variablen:

Delphi-Quellcode:

  private
    FA:boolean; 
    FcheckA: TCheckBox;
    FcheckB: TCheckBox;

    procedure SetA(const Value: boolean);
    function GetA: boolean;
    procedure setcheckA(const Value: TCheckBox);
    { private declarations }
  protected
    { protected declarations }
  public
    { public declarations }

  published
    { published declarations }
    property checkA: TCheckBox read FcheckA write setcheckA;
    property checkB: tcheckbox read FcheckB write FcheckB;
    constructor create(AOWNER:tcomponent);override;
  end;

procedure TTestpanel.SetA(const Value: boolean);
begin
 FA:=value;
 checkA.Checked:=value;
end;

function TTestpanel.GetA: boolean;
begin
  a:=FA;
end;

Jetzt wird die Eigenschaft aus dem Objektinspektor auch in's Programm übernommen - aber nur, wenn sowohl setA als auch getA genutzt werden (geht auch ohne setcheckA). Geht das nur so? - Finde ich umständlich.

Wo steckt mein Wissensdefizit?

MfG
Uwe

[DeddyH]

Darf man fragen, was Du eigentlich erreichen willst? Ich finde es zumindest fragwürdig, dass Du TCheckbox-Instanzen selbst anlegst, diese aber durch einen Setter möglicherweise überschreiben lässt. Ich habe das Gefühl, dass Du mit Boolean-Properties hier besser bedient wärst, in deren Setter Du dann eben die Checked-Eigenschaft der Checkboxen änderst.

[stahli]

SetSubComponent dürfte helfen: http://www.delphipraxis.net/79726-un...der-gruen.html

[DrUArn]

Hi,

@ Detlef: wollte eben auch im Formulareditor und Objektinspektor die Eigenschaften der (Sub)-Komponenten nutzen, wie man es in vielen VCL-Beispielen sehen kann.
@ Stahli: Dein Vorschlag=Lösung!


So einfach sieht's jetzt aus:

Delphi-Quellcode:

  TTestpanel = class(Tpanel)
  private
    FcheckA: TCheckBox;
    FcheckB: tcheckbox;
    { private declarations }
  protected
    { protected declarations }
  public
    { public declarations }

  published
    { published declarations }
    property checkA: TCheckBox read FcheckA write Fchecka;
    property checkB: tcheckbox read FcheckB write FcheckB;
    constructor create(AOWNER:tcomponent);override;
  end;



constructor TTestpanel.create(AOWNER: tcomponent);
begin
  inherited;
  checkA:=tcheckbox.Create(self);
  checkA.Caption:='A';
  InsertControl(checkA);
  checkb:=tcheckbox.Create(self);
  checkB.Caption:='B';
  checkB.top:=checkB.top+15;
  InsertControl(checkB);
  fchecka.SetSubComponent(true);
  fcheckb.SetSubComponent(true);
end;

Das ist alles. So wird eben auch das checkA.checked mit ins Programm übergeben!!

Danke an alle!!

[DeddyH]

Und wenn man nun checkA eine andere CheckBox zuweist? Dann hast Du ein Speicherleck.

[himitsu]

Zitat:

tcheckbox.Create(self);

Zitat von DeddyH:

Und wenn man nun checkA eine andere CheckBox zuweist? Dann hast Du ein Speicherleck.

Nicht wirklich, da das Panel als Owner angegeben wurde.

Aber dennoch, würde ich die Proerty nur als ReadOnly deklarieren.

[DrUArn]

Hi,

@himitsu: ok, dann kann keiner dieses Feld überschreiben:

.
.
.
property checkC: TCheckBox read FcheckC;
.
.
.

und in Create:

FcheckC:=tcheckbox.Create(self);// hier muß auf das Feld zugreifen (weil nur-Lese-Properties nichts zugewiesen werden darf)
checkC.Caption:='C';
checkC.top:=checkb.top+15;
InsertControl(checkC);
fcheckc.SetSubComponent(true);


Funktioniert aber genau so.

Einen schönen Abend an alle!

Uwe

[himitsu]

Zitat von DrUArn:

hier muß auf das Feld zugreifen (weil nur-Lese-Properties nichts zugewiesen werden darf)

Ist auch vollkommen richtig.

Ich persönlich nutze innerhalb einer Klasse auch vorzugsweise nicht deren Property, sondern geht direkt auf die Felder.
(abgesehn dort, wo es einen Setter gibt und ich nicht die Setter-Methode direkt aufrufen möchte/kann)
Property sind für mich also "nur" externe Schnittstellen.

Tipp: Siehe Lines eines TMemo oder Items einer TListBox.

Ja, Lines verfügt zwar über einen Setter, aber dort ist quasi eine Assign-Methode dahinter versteckt.
Es wird also nicht die Komponenten-Variable (das Feld) überschrieben, sondern es werden nur die Eigenschaften des übergebenen Objektes an das interne Objekt übertragen.


Aber vorallem wird intern möglichst immer nur eine Variante verwendet.

Zitat:

Delphi-Quellcode:

FcheckC:=tcheckbox.Create(self);// hier muß auf das Feld zugreifen (weil nur-Lese-Properties nichts zugewiesen werden darf)
checkC.Caption:='C';
checkC.top:=checkb.top+15;
InsertControl(checkC);
fcheckc.SetSubComponent(true);

also entweder

Delphi-Quellcode:

FcheckC:=TCheckBox.Create(self);
FcheckC.Caption:='C';
FcheckC.Top:=FcheckB.Top+15;
InsertControl(FcheckC);
FcheckC.SetSubComponent(true);

oder

Delphi-Quellcode:

FcheckC:=tcheckbox.Create(self);// geht eh nicht ander
checkC.Caption:='C';
checkC.Top:=checkB.Top+15;
InsertControl(checkC);
checkC.SetSubComponent(true);

Zusärtlich macht sich eine einheitliche Schreibweise (inkl. der Groß-/Kleinschreibung) IMHO irgendwie besser ... Code ist dadurch meißt übersichlicher.
Und Refactoring macht sich mit solchem Code bestimmt auch besser. (wenn Zusammengehörendes gleich heißt)