Tabs organisieren

[Joe_the_Junkie]

Hallo Gemeinde,
Ich hab da mal ne Frage (Wer hätte das gedacht? )

Und zwar wollte ich aus langeweile einen kleinen Editor basteln der Tabfähig ist.

Ich hab das so gemacht, dass ich die Tabs in einem Array speichere ,sprich:

tabs = array of ttabsheets; Und die Editorenfelder, in denen der Code geschrieben wird wird, die werden auch als array gespeichert.

Jedoch, wenn ich jetzt sage mal 5 Tabs offen hab, also so

____ ____ ____ ____ ____
/ / / / /

dann sind werden die ja so gezählt: 0,1,2,3,4.

Wenn ich jetzt aber den mittleren schließe werden die ja reorganisiert zu: 0,1,2,3.

Wie kann ich das jetzt am besten machen, dass wenn mittendrin ein Tab geschlossen wird ich immer noch weis, welches
Editorfeld zu welchem Tab gehört, damit ich zum Beispiel weis, was gespeichert werden soll???

PS: Ich hoffe ihr habt meine Frage verstanden, kann es irgendwie nicht besser ausdrücken...

[BenjaminH]

Das müsste eine Property Tag haben:
tabs[i].tag:=a; Da kannst du denen eine Nummer geben, die auch wenn einer gelöscht wird bleiben.
Aber je nachdem was du machst ist vermutlich eine Klasse von tabsheet Abgeleitet einfacher.

[Der_Unwissende]

Hi,
am leichtesten kannst Du Dein Problem lösen, wenn Du kurz überlegst, was deinen Editor ausmacht. Du hast Tabs und zu jedem Tab gehört ein Editoren-Feld. Der Satz ist nicht all zu spektakulär, also hoffe ich einfach mal, dass Du dem so zustimmst?!

Unter der Annahme das dem so ist (sonst einfach nochmal nachfragen), kannst Du genau diese Beziehung auch in Delphi modellieren. Dazu erzeugst Du Dir einfach eine Klasse, TEditorTabSheet. Diese Klasse muss dann alle Eigenschaften besitzen, die Du Dir halt für ein Tab in deinem Editor so wünschst. Das wären aktuell wohl die Eigenschaften eines TTabSheet, die Du aber zusätzlich um ein Editoren-Feld erweiterst. Da Du damit nur ein neues (spezielleres) TTabSheet erzeugst, kannst Du die einfach von TTabSheet erben lassen (die erbt einfach alle Eigenschaften).

Delphi-Quellcode:

type
  TEditorTabSheet = class(TTabSheet)
    private 
      FEditorFeld: TEditorFeld;
    public
      constructor Create(AOwner: TComponent);
      destructor Destroy; override;
    published
      property EditorFeld: TEditorFeld read FEditorFeld;
  end; 

....

constructor TEditorTabSheet.Create(AOwner: TComponent);
begin
  inherited Create(AOwner); // geerbten Konstruktor aufrufen
  
  // hier jetzt die neue Eigenschaft initialisieren
  // Da jedes TEditorTabSheet immer ein und das selbe TEditorFeld besitzen
  // kann dies einmalig im Konstruktor erzeugt und im Destruktor frei gegeben 
  // werden
  self.FEditorFeld := TEditorFeld.Create;
  // ...
  self.insertControl(self.FEditorFeld);  
end; 

destructor TEditorTabSheet.Destroy;
begin
  self.FEditorFeld.Free;

  inherited destroy;
end;

Ja, das wäre wohl grob der Weg. Das mit dem Array/den Arrays solltest Du an sich hier lieber lassen. Arrays sind recht statische Konstrukte. MIttels setLength kannst Du natürlich ihre Größe ohne weiteres anpassen, aber hinter dieser Methode verbirgt sich eine Menge Arbeit. So muss das System erst freien Speicher der entsprechenden Größe finden und allozieren. Dann werden die Elemente des alten Arrays in diesen neuen Speicher kopiert und zu guter letzt wird das alte Array aus dem Speicher entfernt.
Wichtig ist dabei zu wissen, dass dieser Overhead nahezu konstant ist. Ob Du dein Array um ein, zehn oder 100.000 Elemente vergrößerst, der Aufwand ist nahezu gleich. Der Overhead pro Element sinkt also mit der Anzahl der neuen Elemente ab.
Genau das nutzen Klassen wie TList und TObjectList aus. Hierbei handelt es sich um dyn. Strukturen, die ihre Größe automatisch für der Anzahl der gespeicherten Elemente anpassen. Intern verwalten sie für Dich nur ein dyn. Array. Dessen Größe wird immer dem Füllstand angepasst, ohne dass Du etwas dafür tun musst. Ist die Anzahl der Elemente (z.B. Tabs), die Du speichern möchtest unbekannt, so eignen sich Listen viel besser zum speichern!

Für dein Problem sieht die Sache aber noch viel einfacher aus, TTabSheet gehört immer zu einem TPageControl. Zu den Eigenschaften eines TPageControl zählen dann u.A.

• ActivePage
• ActivePageIndex
• PageCount
• Pages

In Pages stecken dann schon alle Seiten, die in dem TPageControl angezeigt werden, ActivePage gibt Dir zudem das aktuell ausgewählte TTabSheet zurück. Damit hast Du dann auch alles was Du brauchst.

Mittels TEditorTabSheet.Create(...) kannst Du leicht eines der neuen TTabSheets erzeugen. Das kannst Du wie eine normales TabSheet (auf gewohnte/geerbte Weise) einfügen und anzeigen lassen.
Um an das EditorFeld des aktiven Tabsheet zu kommen, holst Du Dir einfach mit der Eigenschaft ActivePage die aktive Seite (als TTabSheet) und castest die in ein TEditorTabSheet. Nach diesem cast kannst Du dann mit der entsprechenden Eigenschaft auf das Editorfeld zugreifen.

Gruß Der Unwissende

[Joe_the_Junkie]

Jo super, ich danke euch beiden für die super schnelle hilfe.

Ich werd mich mal damit beschäftigen und wünsch euch beiden einen schönen Abend.

Vielen Dank