Gruppen von Controls erzeugen - dynamisch vs. ?

[cltom]

Hallo,

es sollen eine Reihe von gleichförmigen Controls erzeugt werden (30-50 mal eine Gruppe von rund 10 Komponenten: Edit-Felder, Comboboxen natürlich mit Inhalten, etc. das alles versehen mit Events.) Bis dato hab ich das mit dynamisch erzeugten Controls gelöst. Das klappt auch soweit, aber am Ende: so richtig elegant und bequem ist das nicht. Ich finde es schwierig, ohne FindComponent zu arbeiten und das ist bekanntermaßen empfindlich und langsam. Beim Erzeugen braucht es schon Regelwerk was die Eigenschaften der Controls angeht, Positionen, Abstände, etc. Wenn die Anzahl an diesen Komponenten verändert wird, geht das mit einer unbedeutenden aber merklichen Verzögerung einher, es ist relativ viel Aufwand, dass das klappt.

Kurz: so richtig ideal erscheint mir das nicht.

Was wären Alternativen?

Die Gruppe von Controls auf einen Frame packen und den dynamisch erzeugen? Doch einfach alle Design-Time erzeugen und einfach mit visible arbeiten? Oder gibt es noch andere elegante Methoden, Objekte zur Laufzeit zu erzeugen, die dann ohne Findcomponent auskommen?

Danke für Inspiration!

[Uwe Raabe]

Dafür bietet sich die seit Delphi 10.4 enthaltene TControlList an. Für ältere Delphi-Versionen würde ich in der Tat den Frame-Ansatz in Betracht ziehen.

[cltom]

Zitat von Uwe Raabe:

Dafür bietet sich die seit Delphi 10.4 enthaltene TControlList an. Für ältere Delphi-Versionen würde ich in der Tat den Frame-Ansatz in Betracht ziehen.

ok, sehr schön, 10.4 krieg ich hoffenlich bald mal (ich mach noch mit XE2 herum). Danke!

[bernau]

Wenn du schon die Controls dynamisch erzeugts, was spricht dagegen die erzeugten Instanzen einem Array zuzuweisen und über das Array auf die Werte der Controls zugreifen.

Delphi-Quellcode:

type
  TAutolackComponentRow = record
    Farbname:TEdit;
    Matt:TCheckbox;
    Preis:TEdit;
    end;


type
  TmyForm = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    fControlRows:Array[0..10] of TAutolackComponentRow;
  public
  end;


procedure TmyForm.FormCreate(Sender: TObject);
var
  a:Integer;
begin
  for a:=0 to 10 do
    begin
    fControlRows[a].Farbname := TEdit.Create(self)
    // parent, Position setzen etc
    fControlRows[a].Matt := TCheckbox.Create(self)
    // parent, Position setzen etc
    fControlRows[a].Preis := TEdit.Create(self)
    // parent, Position setzen etc
  end;
end;

Auf die entsprechende Komponente greifst du dann über das Array zu.

Delphi-Quellcode:

fControlRows[1].Farbname.text := 'Blau';
fControlRows[5].Matt.checked := true;
fControlRows[7].Preis.checked := '10,25';
for a:=0 to 10 do
  begin
    fControlRows[a].Preis.left := 30;
    fControlRows[a].Preis.top := 25 * a;
  end;

[Delbor]

Hi zusammen

Und was ist der Unterschied zu TObjectList, ausser dass diese Objekte verschiedener Vorfahren verwalten kann (TControl, TGraphicConrtol etc)?

Zitat von bernau:

Wenn du schon die Controls dynamisch erzeugts, was spricht dagegen die erzeugten Instanzen einem Array zuzuweisen und über das Array auf die Werte der Controls zugreifen.

Eigentlich spricht da nichts dagegen - ausser dass Listen mit weniger Verwaltungsaufwand erweitert werden können.

Gruss
Delbor

[cltom]

Zitat von bernau:

Wenn du schon die Controls dynamisch erzeugts, was spricht dagegen die erzeugten Instanzen einem Array zuzuweisen und über das Array auf die Werte der Controls zugreifen.

Delphi-Quellcode:

type
  TAutolackComponentRow = record
    Farbname:TEdit;
    Matt:TCheckbox;
    Preis:TEdit;
    end;


type
  TmyForm = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    fControlRows:Array[0..10] of TAutolackComponentRow;
  public
  end;


procedure TmyForm.FormCreate(Sender: TObject);
var
  a:Integer;
begin
  for a:=0 to 10 do
    begin
    fControlRows[a].Farbname := TEdit.Create(self)
    // parent, Position setzen etc
    fControlRows[a].Matt := TCheckbox.Create(self)
    // parent, Position setzen etc
    fControlRows[a].Preis := TEdit.Create(self)
    // parent, Position setzen etc
  end;
end;

Auf die entsprechende Komponente greifst du dann über das Array zu.

Delphi-Quellcode:

fControlRows[1].Farbname.text := 'Blau';
fControlRows[5].Matt.checked := true;
fControlRows[7].Preis.checked := '10,25';
for a:=0 to 10 do
  begin
    fControlRows[a].Preis.left := 30;
    fControlRows[a].Preis.top := 25 * a;
  end;

schöner Gedanke. Ist mir ehrlich gesagt so nicht gekommen! Liesse sich einfach umsetzen und hat den Vorteil, dass ich eine ganze Gruppe ansprechen kann und ohne FindComponent auskomme. sehr schön, danke!

[Uwe Raabe]

Zitat von Delbor:

Und was ist der Unterschied zu TObjectList, ausser dass diese Objekte verschiedener Vorfahren verwalten kann (TControl, TGraphicConrtol etc)?

Beziehst du dich damit auf meinen Vorschlag mit TControList? In dem Fall ist der Unterschied schon signifikant. Im Gegensatz tu TObjectList, was einfach eine Liste von TObject-Instanzen oder dessen Nachfahren ist, handelt es sich bei TControlList um ein visuelles Grid-ähnliches Control, in dem man ein Layout für seine Controls (TLabel, TEdit usw.) einmal entwirft und diese dann zur Laufzeit in der gewünschten Anzahl dargestellt werden und auch bedienbar sind.

https://docwiki.embarcadero.com/RADS...olList_Control
https://www.youtube.com/watch?v=PfHV9AhV2NM

[bernau]

Zitat von Delbor:

Hi zusammen
Und was ist der Unterschied zu TObjectList, ausser dass diese Objekte verschiedener Vorfahren verwalten kann (TControl, TGraphicConrtol etc)?

Du musst nicht casten. Ausser du verwendest eine generische Objectliste. Dann müssen aber auch alle Controls gleich sein.

Zitat von Delbor:

Zitat von bernau:

Wenn du schon die Controls dynamisch erzeugts, was spricht dagegen die erzeugten Instanzen einem Array zuzuweisen und über das Array auf die Werte der Controls zugreifen.

Eigentlich spricht da nichts dagegen - ausser dass Listen mit weniger Verwaltungsaufwand erweitert werden können.

Ich finde Arrays intuitiver.... In diesem Fall.

Wenn ich ein paar Edits zweidimensional auf einem Form plaziere, kann ich über ein zweidimensionales Edit einfacher drauf zugreifen.

Beim Erzeugen der Controls kann ich die Arraygröße abfragen. Dann muss ich nur noch das Array vergrößern und du und hast die Menge der Edits angepasst.

Ist aber letztendlich Geschmackssache.

[cltom]

Danke Euch!

Hab das jetzt umgestellt auf die Array-Methode. Das passt hier tatsächlich ganz gut, weil auch die Daten in einem Array landen und das eine gewisse logische Parallele ergibt.

In jedem Fall macht es den Code so viel besser lesbar:

aus:
SomeClass.SomeArray.ValueTypeID[i] := (FindComponent('cmb_value_' + IntToStr(i) + '_TypeID') As TComboBox).ItemIndex;
wird:
SomeClass.SomeArray.ValueTypeID[i] := MyInputArray[i].ValueTypeID.ItemIndex;
deutlich schneller ist es außerdem.

[TurboMagic]

Zitat von cltom:

Zitat von Uwe Raabe:

Dafür bietet sich die seit Delphi 10.4 enthaltene TControlList an. Für ältere Delphi-Versionen würde ich in der Tat den Frame-Ansatz in Betracht ziehen.

ok, sehr schön, 10.4 krieg ich hoffenlich bald mal (ich mach noch mit XE2 herum). Danke!

Achtung: diese ControlList kann nur solche Controls enthalten, die kein Window Handle erzeugen.
Es ist also ein wenig eingeschränkt was da geht. Das ist aber deshalb so programmiert worden, damit
es sehr schnell geht und auch Listen mit tausenden Controls flüssig aufgebaut werden. Das Erzeugen
eines Window Handles dauert scheinbar geraume Zeit...