[FMX] Ansatz gesucht: Panels duplizieren?

[warschonweg]

Ich hätte gern für den Eigengebrauch ein Programm, das ungefähr so aussehen soll:

Code:

+---------------------------------------------------+
| Textfeld                            Textfeld        |
| Combobox                                           |
|                                                   |
|                                                   |
|                                                   |
|                                                   |
|                                                   |
|                                                   |
|                                                   |
|                                                   |
|                                                   |
|                                                   |
| [+]                                 [ Process ]     |
+---------------------------------------------------+

Ein Klick auf "[+]" soll weitere Zeilen hinzufügen (das ganze Feld sitzt in einer Scrollbox, so weit logisch kein Problem):

Code:

+---------------------------------------------------+
| Textfeld                            Textfeld        |
| Combobox                                           |
|                                                   |
| Textfeld                            Textfeld        |
| Combobox                                           |
|                                                   |
| Textfeld                            Textfeld        |
| Combobox                                           |
|                                                   |
|                                                   |
|                                                   |
|                                                   |
| [+]                                 [ Process ]     |
+---------------------------------------------------+

Nach einem Klick auf "Process" sollen alle Felder zeilenweise verarbeitet werden. Weil ich das Programm auch gern unter Android nutzen würde, erwäge ich FireMonkey als GUI-Framework - ansonsten müsste ich zu einer anderen Sprache greifen und das will ich nicht unbedingt.

Mir fehlt allerdings gerade ein guter Ansatz: Wie kann ich das realisieren? Die einzelnen Zeilen sollten vermutlich ein Gridpanel sein (wegen der Positionierung) - aber wie "klone" ich die dann am besten?

Danke für jede Hilfe. :)

[Redeemer]

Zeilen als Frames anlegen?

[warschonweg]

Klingt auch gut - habe ich nie gemacht. Haben Frames eine Klonfunktion?

[Der schöne Günther]

Du erstellst eine neue Komponente zur Laufzeit. Ein Frame ist genauso eine Komponente wie ein

Delphi-Quellcode:

TButton

. Wenn du ihn nach dem Hinzufügen mit [+] noch mit bestimmten Inhalt vorbelegen willst kannst du dem Frame einfach eine Methode verpassen die du danach aufrufst.

PS: Einen "Hinzufügen"-Button hätte ich links unten als aller letztes erwartet. Lange eingebürgert hat sich eigentlich ein dauerhaft sichtbarer Button über dem Scrollcontainer oder ein schwebender (+) Button ganz am Ende der Liste.

[warschonweg]

Danke für den Designtipp - ich denke wahrscheinlich zu desktopmäßig gerade. :)
Zum Erstellen der Komponente: Gucke ich mir mal an. Vielleicht kriege ich es ja hin.

[Redeemer]

Ein Frame ist einfacher zu erstellen als eine Komponente. Man erstellt einfach einen Frame im Designer und den instanziiert man dann zur Laufzeit. (Aus zur Entwurfszeit instanziierten Frames macht der Designer ohnehin nichts Vernünftiges.)

Delphi-Quellcode:

var
  Frames: TList<TMeinFrame>;

...

procedure TMeineForm.ButtonAddClick(Sender: TObject);
begin
  Frames.Add(TMeinFrame.Create(Self));
  with Frames[Frames.Count-1] do
  begin
    { Startwerte in den Frame schreiben usw. (falls nötig) }
    Parent := Self; // wichtig, funktioniert sonst nicht
  end;
end;

[KodeZwerg]

Tut mir leid wenn ich es nochmal anspreche obwohl ich glaube das manche sagten es sei doof.
Ich selbst benutze für so etwas eine Scrollbox in der dynamisch Panels erstellt werden, auf den Panels lege ich rauf was immer ich will, sprich: alles was man an Komponenten hat steht damit frei auch eingesetzt zu werden.
Realisiert hab ich es indem ich mir einmal solch ein Panel per IDE erstellt habe um anschließend die Informationen der .DFM als Dynamische Panels weiter zu verwenden.
Für die Panels selbst nutz ich mittlerweile eine Class da ich sehr oft so etwas brauche, das Gerüst der Class ist wiederverwendbar :mrgreen:
Damit bin ich auch schon wieder still.

[warschonweg]

Zitat:

Zitat von KodeZwerg (Beitrag 1398487)

Ich selbst benutze für so etwas eine Scrollbox in der dynamisch Panels erstellt werden, auf den Panels lege ich rauf was immer ich will, sprich: alles was man an Komponenten hat steht damit frei auch eingesetzt zu werden.

Das war auch mein initialer Gedanke - ich suche aber erst mal Input von Leuten, die das schon mal gemacht haben. :)

Reddemer: Danke für den Code!

[Delphi.Narium]

Zitat:

Zitat von KodeZwerg (Beitrag 1398487)

Tut mir leid wenn ich es nochmal anspreche obwohl ich glaube das manche sagten es sei doof.
Ich selbst benutze für so etwas eine Scrollbox in der dynamisch Panels erstellt werden, auf den Panels lege ich rauf was immer ich will, sprich: alles was man an Komponenten hat steht damit frei auch eingesetzt zu werden.
Realisiert hab ich es indem ich mir einmal solch ein Panel per IDE erstellt habe um anschließend die Informationen der .DFM als Dynamische Panels weiter zu verwenden.
Für die Panels selbst nutz ich mittlerweile eine Class da ich sehr oft so etwas brauche, das Gerüst der Class ist wiederverwendbar :mrgreen:
Damit bin ich auch schon wieder still.

Das geht mit Frames auch, nur viel einfacher.

Ein Frame ist ein Container (ähnlich einem Panel).

Da packt man drauf, was immer man dort haben will, Buttonereignisse ... kann man direkt im Frame implementieren, Plausibilitätsprüfungen, die für die Komponenten im Frame untereinander erforderlich sind ...

Man macht sich das einmal fertig und durch das Einfügen dieser Frames (z. B. in 'ne Scrollbox) hat man ganz simple die gesamte Funktionalität dupliziert. Kann man in etwa so nutzen, wie eine Komponenten, die viele weitere Komponenten enthält.

[KodeZwerg]

Hallo Delphi.Narium, ich finde interessant das Frames so etwas können und würde mich damit auch bald beschäftigen um, falls tatsächlich besser, meine Class rauszuwerfen.
Momentan werden bei mir ja die Controls automatisch durchnummeriert um damit später was anfangen zu können, wie funktioniert es bei Frames mit den Controls darauf wenn Frames selber über eine "Replizier/Duplizier" funktionalität verfügt?

[Daniel]

Ein Frame ist nicht mehr als eine vom Entwickler selbst zusammengestellte Kombination aus Controls und zugehörigem Code.
Automatisch wird da gar nichts dupliziert. Wenn Du zwei Instanzen benötigst, erzeugst Du zwei und gibst den Frames zwei verschiedene Namen.
Das Prinzip ist nicht anders, als zwei TButtons zu erzeugen.

[Headbucket]

Wichtig ist es meiner Meinung nach noch, parallel zur Oberfläche in deiner Klasse eine Liste zu pflegen.
Diese Liste enthält dann pro Eintrag z.B. mindestens eine Referenz (einen Zeiger) auf das entsprechende Frame.

So kannst du dann z.B. bei einem Klick auf Process einfach die Liste durchgehen und alles abarbeiten.
Die Zuweisung zur Liste kannst du direkt nach dem Erzeugen vornehmen.

Grüße
Headbucket

[Delphi.Narium]

@Kodezwerg

Nehmen wir an, wir erstellen ein Frame frmEingabe, dieses enthält die Buttons btnOk und btnCancel, sowie die Edits edName und edVorname.

Fügen wir nun ein derartiges Frame auf einem Formular ein und geben ihm den Namen frmPerson1, so können wir im Formularquelltext z. B. so auf die Komponenten auf dem Frame zugreifen:

Delphi-Quellcode:

...
  ShowMessage(frmPerson1.edName.Text);
  if frmPerson1.edVorname.Text = 'Paul' then begin
     ...
  end;
...

Benötigen wir nun noch ein Frame und nennen es frmPerson2, dann erfolgt der Zugriff analog dazu:

Delphi-Quellcode:

...
  ShowMessage(frmPerson2.edName.Text);
  if frmPerson2.edVorname.Text = 'Paul' then begin
     ...
  end;
...

Eigentlich ist es nicht anders, als bei den Eigenschaften irgendeiner anderen Komponente, deren Eigenschaften über weitere Eigenschaften verfügen.

Delphi-Quellcode:

IrgendeineKlasse.Eigenschaft.EigenschaftDerEigenschaft

Delphi-Quellcode:

Framename.KomponenteAufDemFrame.EigenschaftderKomponente

Delphi-Quellcode:

frmWieErAuchHeissenMag.KomponenteDadrauf.EigenschaftDerKomponente

Ein Buttonereignis könnte man so im Frame implementieren, dabei gehe ich davon aus, dass sich auf dem Frame zusätzlich noch 'ne Komponenten vom Typ TDataSource befindet:

Delphi-Quellcode:

procedure TfrmPerson.btnOKClick(Sender: TObject);
begin
  Screen.Cursor := crSQLWait;
  // Inhalt der Texteigenschaften von edName und edVorname in eine Datenbank suchen.
  if fDataSource.DataSet.Filtered then begin
    fDataSource.DataSet.Filtered := False;
  end else
  if (edName.Text <> '') and (edVorname.Text <> '') then begin
    Try
      fDataSource.DataSet.Filtered := False;
      fDataSource.DataSet.Filter   := Format('Name = ''%s'' and Vorname = ''%s''',[edName.Text, edVorname.Text]);
      fDataSource.DataSet.Filtered := True;
    except
      on e : Exception do begin
        fDataSource.DataSet.Filtered := False;
        MessageDlg('Fehler beim Setzen des Filters.' + #13 + #13 + e.Message,mtError, [mbOk], 0);
      end;
    end;
  end;
  Screen.Cursor := crDefault;
end;

(Über den tieferen Sinn der Beispiele wollen wir jetzt nicht diskutieren, es geht nur ums Prinzip einer möglichen Framenutzung.)

Hat man nun alle Frames auf einem Formular in einer Liste, so muss man im Quelltext nichtmalmehr den Namen der einzelnen Frames wissen.

Delphi-Quellcode:

for i := 0 to IrgendeineListe.Count - 1 do begin
  if IrgendeineListe[i] is tfrmPerson then begin
    MemoNamensliste.Lines.Add(tfrmPerson(IrgendeineListe[i]).edName.Text + ', ' + tfrmPerson(IrgendeineListe[i]).edVorName.Text);
  end;
end;

oder:

Delphi-Quellcode:

var
   myFrame : TfrmPerson;
   i : Integer;
begin
  for i := 0 to IrgendeineListe.Count - 1 do begin
    if IrgendeineListe[i] is tfrmPerson then begin
      myFrame := IrgendeineListe[i];
      VerschickeEmail(Format('[e-mail]',[myFrame.edVorname.Text, myFrame.edName.Text));
    end;
  end;
end;

Ob man jetzt die Frames bereits zur Entwicklungszeit auf 'nem Formular platziert oder sie zur Laufzeit dynamisch erzeugt, ändert nichts an der Funktionalität.

Frames sind eigentlich, gut implementiert, genauso zu nutzen, wie eine Klasse mit diversen Eigenschaften, Methoden, Ereignissen ... (genaugenommen sind sie es ja auch

Delphi-Quellcode:

type TfrmPerson = class(TFrame) ...

).

[KodeZwerg]

Hab das Prinzip Verstanden, Danke das Du so weit ausgeholt hast und Danke auch den anderen Meinungen dazu.
Nachdem ich das gelesen habe stelle ich fest, das ich mit meiner Panel-Class eigentlich genauso vorgehe.
In einer Liste speichere ich jede Panel-Instanz um den Controls darauf irgendwas machen zu lassen und um die Panels auch wieder los zu werden.
Für mich selbst ist es damit leider nicht mehr so interessant da ich für mich doch keine Großen Vorteile darin sehe, aber wenn man bei Null anfängt wäre das sicherlich auch eine gute Variante, vielleicht sogar eine einfachere.
Ich habe wahrscheinlich den Post auch ein wenig falsch interpretiert als gesagt wurde das Frames eine "duplizier" methode mitbringen.
Naiv wie ich numal bin stellte ich es mir so vor (was dann Vorteilhaft für mich gewesen wäre):
1. Ich erstelle eine sichtbare Scrollbox
2. Ich erstelle ein nicht sichtbares Frame als Ausgangsmaterial für weitere
3. Ich füge ein [+] Knopf mit einem Frame duplizier Aufruf ein der das unsichtbare Frame nun in ein sichtbares macht
4. Ich brauche keine Kontroll-Liste zur Verwaltung, da Frames das alles mit sich bringt
5. Ich brauch mir keine Gedanken machen wie die Controls auf dem Frame benannt werden
6. Wenn ich ein's loswerden will ([-] Knopf auf jedem Frame) kann ich mit Frame Funktionen dies erreichen
Also das mir der komplette Verwaltungsaufwand abgenommen wird, das dachte ich mir im Hinterstübchen.