Optimales Codedesign?

[delphifan2004]

Zitat von schöni:

Hallo!

Ich stehe vor dem Problem, meinen Code zu vereinfachen.

Delphi-Quellcode:

unit UToolbarImplement;

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ComCtrls, Buttons, ExtCtrls, Menus, StdCtrls, SynEdit, IdeIntf;
  
  
type
  TToolbarImplementer = class(TInterfacedObject, IToolbarManager)
  private
    FDockBars: TObjectList;
    FToolBars: TObjectList; 
    FForm: TForm;
  public
    function GetDocks(Index: Integer): TComponent;
    function GetToolBars(DockIndex, TBIndex: Integer): TComponent;
    function GetControls(DockIndex, TBIndex, CtrlIndex: Integer): TComponent;
  
    procedure AddDock(ADock: TComponent);
    procedure AddToolBar(ToDock: TComponent; TheToolBar: TComponent); virtual; abstract;
    procedure AddControl(ToDock, ToToolBar: TComponent; TheTBControl: TComponent); virtual; abstract;

   procedure AddToolBarIX(ADockIndex: Integer; TheToolBar: TComponent); virtual; abstract; 
   procedure AddControlIX(ADockIndex, AToolbarIndex: Integer; TheTBControl: TComponent); virtual; abstract;

   constructor Create;
   destructor Destroy; override;
    
    procedure InsertAllControls; //fügt die Controls ins Formular ein 

    property Dockbars[Index: Integer]:TComponent read GetDocks;
    property ToolBars[DockIndex, TBIndex: Integer]:TComponent read GetToolBars;
    property Controls[DockIndex, TBIndex, CtrlIndex: Integer]:TComponent read GetControls;
    property VisibleWindow: TForm read FFOrm write FForm;
  end;
  
implementation

function TToolbarImplementer.GetDocks(Index: Integer): TComponent;
begin
  Result := FDockBars[Index];
end;

function TToolbarImplementer.GetToolBars(DockIndex, TBIndex: Integer): TComponent;
var
  TheDock: TComponent;
begin
  TheDock := FDockBars[DockIndex];
  Result  := TheDock.Components[TBIndex];
end;

function TToolbarImplementer.GetControls(DockIndex, TBIndex, CtrlIndex: Integer): TComponent;
var
  TheDock: TComponent;
  TheTBar: TComponent;
begin
  TheDock := FDockBars[DockIndex];
  TheTBar := TheDock.Components[TBIndex];
  Result  := TheTBar.Components[CtrlIndex];
end;

procedure AddDock(ADock: TComponent);
begin
  FDockBars.Add(ADock);
end;

constructor TToolbarImplementer.Create;
begin
  inherited
  FDockBars := TObjectList.Create;
end;

destructor TToolbarImplementer.Destroy;
begin
  FDockBars.Free;
  inherited 
end; 
    
end.

In einer abgeleiteten Klasse kriege ich aber dannProbleme mit der Implementation dieser Methoden:

procedure AddToolBarIX(ADockIndex: Integer; TheToolBar: TComponent); virtual; abstract;
procedure AddControlIX(ADockIndex, AToolbarIndex: Integer; TheTBControl: TComponent);

Ist dieses Design überhaupt optimal?

Was ich erreichen will, ist einen Container zu haben, wo die Toolbars komplett zur Laufzeit aufgebaut werden können und der Container soll nicht wissen, ob ich später die konkreten Toolbar mit TB2000 oder SpTBX oder mit Delphi Standard-Komponenten realisiere.

Ich will dann im Programmcode statt konkreter Toolbars diesen Container verwenden, also von diesem aus die konkreten Toolbar in mein Formular einfügen.

Die obige Klasse soll der generische Vorfahre sein für konkrete Implementationen, die da wären:

-Delphi Standardkomponenten (TControlBar oder TCoolBar oder TPanel als Docking-Container und zB.
TToolBar als ToolBar.

-Toolbar200 Komponenten oder

-SpTBX Komponenten.

Ist das Design so ok oder gibt es da bessere Lösungen?

Ich würde sowas mit TTreeNode machen und zwar so hier:

Delphi-Quellcode:

type
  TComponentTreeNodes = class(TTreeNodes)
    function AddControl(toNode: TTreeNode; ACaption: String; AControl: TControl): TTreeNode;
    function AddSubControl(toNode: TTreeNode; ACaption: String; AControl: TControl): TTreeNode;
    function AddControlFirst(toNode: TTreeNode; ACaption: String; AControl: TControl): TTreeNode;
    function AddSubControlFirst(toNode: TTreeNode; ACaption: String; AControl: TControl): TTreeNode;
    function InsertControl(toNode: TTreeNode; ACaption: String; AControl: TControl): TTreeNode;
  end;