Eigene Komponente (Toolbar) programmieren

[himitsu]

Der Owner der Unterkomponenten hat Self zu sein, da die Toolbar ja der Bersitzer ist.

.Create({Self.}Parent) und vorallem .Create({Self.}Owner) sind total falsch
und müßten in .Create(Self) abändert werden.

Da du den Subkomponenten den selben "externen" Owner gibst, sind bei einer zweiten Toolbar die Namen natürlich schon belegt, da innerhalb eines Owner keine Namen doppelt vorkommen dürfen (abgesehn von kein Name).

PS: Wenn man Komponenten dynamisch erstellt, dann muß man keinen Namen vergeben, da der Name vorwiegend nur von dem VCL-Loader benötigt wird, um die erstellten Komponenten den namentlich gleichen Feldern in der Form zuweisen zu können
oder wenn man FindComponent verwenden muß, welches sich aber auch anders/besser lösen läßt.

[Metallicwar]

Hi himitsu,
lass dir mal den Owner des Toolbuttons in der Toolbar anzeigen. --> Wirst das Formular zurück kriegen, auf das die Toolbar liegt.
Habs trotzdem mal so gemacht, wie du gesagt hast also anstatt .Create(Parent) habe ich .Create(Self) verwendet.
Dann kann ich nichtmal mehr, auf den Button in der Toolbar klicken.

[Metallicwar]

Lösung bis dahin:

Delphi-Quellcode:

unit Testtoolbar2;

interface

uses
  SysUtils, Classes, Controls, ToolWin, ComCtrls, ImgList, cxGraphics;

type TTestBars = set of (Standard1, Standard2, Standard3, Standard4, Standard5);

type
  TTestToolbar = class(TToolBar)
  public
  constructor create(aOwner: TComponent); override;
  destructor Destroy; override;
    //Bars: TTestBars;
    //Buttons: TToolButton;
    { Private-Deklarationen }
  private
    Buttons : TToolbutton;
    ImageList: TcxImageList;
    function GetNextName(AName: String): String;
  protected
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
  end;

  procedure Register;

implementation

function TTestToolbar.GetNextName(AName: String): String;
var
  i: Integer;
begin
  i := 1;
  while (Self.Owner.FindComponent(AName + IntToStr(i))) <> nil do
    i := i + 1;
  Result :=(AName + IntToStr(i));
end;

constructor TTestToolbar.Create;
begin
  inherited;
  Parent := Owner as TWinControl;
  if Assigned(Buttons) then
    Exit;

  if csDesigning in ComponentState then
  begin
    Buttons := TToolButton.Create(Parent);
    Buttons.Name := GetNextName('btnSpeichern');
    Buttons.Parent := self;
    Buttons.Caption := 'Speichern';

    Buttons := TToolButton.Create(Self.Parent);
    Buttons.Name := GetNextName('btnZurück');
    Buttons.Parent := self;
    Buttons.Caption := 'Zurück';

    Buttons := TToolButton.Create(Self.Parent);
    Buttons.Name := GetNextName('btnVor');
    Buttons.Parent := self;
    Buttons.Caption := 'Vor';

    Buttons := TToolbutton.Create(self.Parent);
    Buttons.Name := GetNextName('btnNeu');
    Buttons.Parent := self;
    Buttons.Caption := 'Neu';
  end;

  //Standardeigenschaften für Toolbar setzten
  Self.ShowCaptions := True;
end;

destructor TTestToolbar.Destroy;
begin
  Buttons.Free;
  inherited;
end;

procedure TTestToolbar.Notification(AComponent: TComponent;
  Operation: TOperation);
begin
  inherited Notification(AComponent, Operation);
  if (AComponent = Buttons) and (Operation = opRemove) then
    Buttons := nil;
end;

procedure Register;
begin
  RegisterComponents('ZTestKomponenten', [TTestToolbar]);
end;

end.

[himitsu]

Nur durch Änderung des Owners sollte sich nichts am Programmablauf ändern, da der Owner nur für die Freigabe der Subkomponenten zuständig ist und sonst keinen Einfluß besitzt, abgesen vom Property .Components und vom FindComponent.

Der Owner gibt seine zugeordneten Komponenten frei, wenn er selbst freigegeben wird ... Notification ist also etwas overload.

PS: Buttons kann nur einen Button aufnehmen, weswegen man hier ein Array, eine Liste (TObjectList) oder eben die vorhandene Liste .Components verwenden sollte.

Delphi-Quellcode:

unit Testtoolbar2;

interface

uses
  SysUtils, Classes, Controls, ToolWin, ComCtrls, ImgList, cxGraphics;

type TTestBars = set of (Standard1, Standard2, Standard3, Standard4, Standard5);

type
  TTestToolbar = class(TToolBar)
  private
    { Private-Deklarationen }
    Buttons : array[0..3] of TToolbutton;
    ImageList: TcxImageList;
  public
    { Public-Deklarationen }
    constructor Create(aOwner: TComponent); override;
  end;

  procedure Register;

implementation

constructor TTestToolbar.Create;
begin
  inherited;
  Parent := Owner as TWinControl;
  { wann sollten die/der denn erzeugt wurden sein? }
  //if Assigned(Buttons) then
  //  Exit;

  { sollen die Buttons wirklich NUR im Formdesigner vorhanden sein? }
  //if csDesigning in ComponentState then
  //begin
    Buttons[0] := TToolButton.Create(Self);
    Buttons[0].Parent := Self;
    Buttons[0].Caption := 'Speichern';

    Buttons[1] := TToolButton.Create(Self);
    Buttons[1].Parent := Self;
    Buttons[1].Caption := 'Zurück';

    Buttons[2] := TToolButton.Create(Self);
    Buttons[2].Parent := Self;
    Buttons[2].Caption := 'Vor';

    Buttons[3] := TToolbutton.Create(self.Parent);
    Buttons[3].Parent := Self;
    Buttons[3].Caption := 'Neu';
  //end;

  //Standardeigenschaften für Toolbar setzten
  ShowCaptions := True;
end;

procedure Register;
begin
  RegisterComponents('ZTestKomponenten', [TTestToolbar]);
end;

end.

[Metallicwar]

Wenn ich das so mache, wie von dir vorgeschlagen kann ich

A: keine Events mit den erzeugten Buttons auslösen(sind nichtmal anklickbar)

B: Beim Ausführen der Anwendung meint er dass eine Komponenten mit dem Namen TToolButton bereits existiert.

Hast du's mal bei dir getestet?

[himitsu]

Ich dachte ja, daß man über irgendeinen ComponentState sagen kann, daß die Buttons designbar sind, aber ich fand nichts ... nja

Delphi-Quellcode:

unit ToolBar1;

interface

uses
  SysUtils, Classes, Controls, ToolWin, ComCtrls;

type
  TTestToolBar = class(TToolBar)
  private
    { Private-Deklarationen }
  protected
    { Protected-Deklarationen }
    procedure Loaded; override;
  public
    { Public-Deklarationen }
    constructor Create(aOwner: TComponent); override;
  published
    { Published-Deklarationen }
  end;

procedure Register;

implementation

procedure TTestToolBar.Loaded;
var
  Button: TToolButton;
begin
  inherited;
  if ControlCount = 0 then
  begin
    Button := TToolButton.Create(Owner);
    Button.Parent := Self;
    Button.Caption := 'Speichern';

    Button := TToolButton.Create(Owner);
    Button.Parent := Self;
    Button.Caption := 'Zurück';

    Button := TToolButton.Create(Owner);
    Button.Parent := Self;
    Button.Caption := 'Vor';

    Button := TToolbutton.Create(Owner);
    Button.Parent := Self;
    Button.Caption := 'Neu';
  end;
end;

constructor TTestToolbar.Create(aOwner: TComponent);
begin
  inherited;
  Parent := aOwner as TWinControl;
  ShowCaptions := True;
  if not (csLoading in ComponentState) then
    Loaded;
end;

procedure Register;
begin
  RegisterComponents('Samples', [TTestToolBar]);
end;

end.

[Metallicwar]

Hallo, hier erstmal mein bisheriger Zwischenstand:
- Komponene lässt sich auf Formular ziehen
- Eigenschaft erstellt (Toolbartype), die unterschiedliche Standardtoolbars anlegt.

Delphi-Quellcode:

unit ZTestToolbar;

interface

uses
  SysUtils, Classes, Controls, ToolWin, ComCtrls, ImgList, cxGraphics, cxStyles,
  StdCtrls, Dialogs;

type
  TToolbarType = (ttStandard1, ttStandard2, ttStandard3);
type
  TTestToolbar = class(TToolBar)
  private
    FToolbarType: TToolbarType;
    Buttons : TToolbutton;
    ImageList: TcxImageList;
    function GetNextName(AName: String): String;
    procedure SetToolButtons();
    procedure SetToolbarType(Value: TToolbarType);
  protected
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
  public
    constructor create(aOwner: TComponent); override;
    destructor Destroy; override;
    { Private-Deklarationen }
  published
    property ToolbarType: TToolbarType read FToolbarType write SetToolbarType
          default ttStandard1;
end;

procedure Register;

implementation

procedure TTestToolbar.SetToolButtons();
var
  i: Integer;
begin
  for i := Self.ControlCount -1 downto 0 do
    Self.Controls[i].Free;

  case FToolbarType of
    ttStandard1:
    begin
      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnEnde');
      Buttons.Parent := self;
      Buttons.Caption := 'Ende';

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnKopieren');
      Buttons.Parent := self;
      Buttons.Caption := 'Kopieren';

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnSichern');
      Buttons.Parent := self;
      Buttons.Caption := 'Sichern';

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnLöschen');
      Buttons.Parent := self;
      Buttons.Caption := 'Löschen';

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnNeu');
      Buttons.Parent := self;
      Buttons.Caption := 'Neu';
    end;
    ttStandard2:
    begin
      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnEnde');
      Buttons.Parent := self;
      Buttons.Caption := 'Ende';

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextNAme('btnLöschen');
      Buttons.Parent := self;
      Buttons.Caption := 'Löschen';

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnVor');
      Buttons.Parent := self;
      Buttons.Caption := 'Vor';

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnZurück');
      Buttons.Parent := self;
      Buttons.Caption := 'Zurück';

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnSichern');
      Buttons.Parent := self;
      Buttons.Caption := 'Sichern';

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnNeu');
      Buttons.Parent := self;
      Buttons.Caption := 'Neu';
    end;
    ttStandard3:
    begin
      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextNAme('btnEnde');
      Buttons.Parent := self;
      Buttons.Caption := 'Ende';

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnLöschen');
      Buttons.Parent := self;
      Buttons.Caption := 'Löschen';

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnKopieren');
      Buttons.Parent := self;
      Buttons.Caption := 'Kopieren';

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnSpeichern');
      Buttons.Parent := self;
      Buttons.Caption := 'Speichern';

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnNeu');
      Buttons.Parent := self;
      Buttons.Caption := 'Neu';
    end;
  end;
end;


procedure TTestToolbar.SetToolbarType(Value: TToolbarType);
begin
  if FToolbarType <> Value then
  begin
    FToolbarType := Value;

    SetToolButtons();
    Invalidate;
  end;
end;

function TTestToolbar.GetNextName(AName: String): String;
var
  i: Integer;
begin
  i := 1;
  while (Self.Owner.FindComponent(AName + IntToStr(i))) <> nil do
    i := i + 1;
  Result :=(AName + IntToStr(i));
end;

constructor TTestToolbar.Create;
begin
  inherited;
  Parent := Owner as TWinControl;

  if Assigned(Buttons) then
    Exit;

  if csDesigning in ComponentState then
  begin
    SetToolButtons();
  end;

  //Standardeigenschaften für Toolbar setzten
  Self.ShowCaptions := True;
end;

destructor TTestToolbar.Destroy;
begin
  Buttons.Free;
  inherited;
end;

procedure TTestToolbar.Notification(AComponent: TComponent;
  Operation: TOperation);
begin
  inherited Notification(AComponent, Operation);
  if (AComponent = Buttons) and (Operation = opRemove) then
    Buttons := nil;
end;

procedure Register;
begin
  RegisterComponents('ZTestKomponenten', [TTestToolbar]);
end;

end.

sooo und nun zu meinem Hauptproblem....
Ich möchte die Toolbuttons mit PNG's versehen. Zur Laufzeit möchte ich eine ImageList erstellen und meine PNG's der Liste hinzufüge und anschließend den Toolbuttons zuweisen.
Problem:
- Die Standard ImageList bietet ja Funktion DELPHI]ImageList.Add[/DELPHI] an, aber diese erwartet ja ein Bitmap, also wandelte ich mein PNG in ein Bitmap um dadurch geht ja aber leider der Alphachannel verloren und mein PNG auf dem Toolbutton, besitzt einen schööönen schwarzen Background... Andere haben ja auch das Problem, wie ich schon gelesen habe.
Mich wundert es nur, dass es auch über die PngComponents nicht funktioniert, wieso gibts dort auch nur die Funktion Imagelist.Add (TImage: TBitmap...) ...
Kennt/ habt ihr eine Möglichkeit, um PNG über eine ImageList den Toolbuttons zuzuweisen, ohne den Alphachannel zu verlieren?

MfG

[Metallicwar]

habs hinbekommen:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var
  ImageList: TImageList;
  PNG: TPngImage;
  Bitmap: TBitmap;
begin
  Imagelist := TImageList.Create(Self);
  ImageList.ColorDepth := cd32bit;
  PNG := TPngImage.Create;
  try
    PNG.LoadFromFile('C:\Users\ZMI GmbH\Desktop\Imagelist umwandeln\png\exit16.png');
    Bitmap := TBitmap.Create;
    try
      Bitmap.Assign(PNG);
      Bitmap.PixelFormat := pf32bit;
      ImageList.Add(Bitmap, nil);
    finally
    Bitmap.Free;
    end;
  finally
  PNG.Free;
  end;
  TestToolbar1.Images := ImageList;
  btnNeu1.ImageIndex := 0;
end;

so mal schaun, ob ich den Rest (Buttons die PNG's zuweisen) auch hinbekomme

[Metallicwar]

soo hallo zusammen, hab es alleine mit den PNG's hinbekommen.
Meine vermutlich letzte Frage, vll kann mir jemand weiterhelfen, der sich besser mit Komponentenentwicklung auskennt wie ich (P.S. mach ich zum ersten mal)
Folgendes:
- Ich erstelle ein Projekt, ziehe meine programmierte Toolbar aufs Formular, kann auch die Eigenschaft "Toolbarstyle" ändern, das funktioniert alles. So, nun speicher ich mein Projekt ab und öffne es erneut und erhalte zu jeder Komponente folgenden Fehler:"Komponente mit der Bezeichnung btnNeu1 existiert bereits"

Das ist mein vollständiger Code, der Fehler hängt vermutlich damit zusammen, dass die Toolbuttons nach dem Speichern in der dfm Datei gespeichert werden. (vermute ich)
in meinem 2. Code den ich noch poste, hab ich wirklich nur das wichtigste im Code gelassen. (Ein Button wird erstellt)
Dort tritt der Fehler ebenfalls auf.

Delphi-Quellcode:

unit ZTestToolbar;

interface

uses
  SysUtils, Classes, Controls, Graphics, ToolWin, ComCtrls, ImgList, cxGraphics, cxStyles,
  StdCtrls, Dialogs, pngImage;

type
  TToolbarType = (ttStandard1, ttStandard2, ttStandard3);
type
  TTestToolbar = class(TToolBar)
  private
    FToolbarType: TToolbarType;
    Buttons : TToolbutton;
    cxImageList: TcxImagelist;
    function GetNextName(AName: String): String;
    procedure SetToolButtons();
    procedure SetPNGImages();
    procedure SetToolbarType(Value: TToolbarType);
  protected
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
  public
    constructor create(aOwner: TComponent); override;
    destructor Destroy; override;
    { Private-Deklarationen }
  published
    property ToolbarType: TToolbarType read FToolbarType write SetToolbarType
          default ttStandard1;
end;

procedure Register;

implementation

constructor TTestToolbar.Create;
begin
  inherited;
  Parent := Owner as TWinControl;

  if Assigned(Buttons) then
    Exit;
  //Standardeigenschaften für Toolbar setzten
  SetPNGImages;
  Self.ShowCaptions := True;
  Self.AutoSize := True;
  Self.Images := cxImageList;

   {
    if csLoading in ComponentState then Showmessage('csLoading');
    if csReading in ComponentState then showmessage('csReading');
    if csWriting in ComponentState then Showmessage('csWriting');
    if csDestroying in ComponentState then Showmessage('csDestroying');
    if csDesigning in ComponentState then Showmessage('csDesigning');
    if csAncestor in ComponentState then Showmessage('csAncestor');
    if csUpdating in ComponentState then Showmessage('csUpdating');
    if csFixups in ComponentState then Showmessage('csFixups');
    if csFreeNotification in ComponentState then Showmessage('csFreeNotification');
    if csInline in ComponentState then Showmessage('csInline');
    if csDesignInstance in ComponentState then Showmessage('csDesignInstance');
  }

  if csDesigning in ComponentState then
  begin
    SetToolButtons();
  end;

end;

procedure TTestToolbar.SetPNGImages();
var
  PNG: TPngImage;
  Bitmap: TBitmap;
  i: Integer;
  PNGListe: array [0..6] of string;
begin
  cxImageList := TcxImageList.Create(Self);
  cxImageList.ColorDepth := cd32bit;

  cxImageList.Height := 32;
  cxImageList.Width := 32;

  PNGListe[0] := 'C:\Users\ZMI GmbH\Desktop\Imagelist umwandeln\png\delete.png';
  PNGListe[1] := 'C:\Users\ZMI GmbH\Desktop\Imagelist umwandeln\png\element_add.png';
  PNGListe[2] := 'C:\Users\ZMI GmbH\Desktop\Imagelist umwandeln\png\elements.png';
  PNGListe[3] := 'C:\Users\ZMI GmbH\Desktop\Imagelist umwandeln\png\exit.png';
  PNGListe[4] := 'C:\Users\ZMI GmbH\Desktop\Imagelist umwandeln\png\hard_drive.png';
  PNGListe[5] := 'C:\Users\ZMI GmbH\Desktop\Imagelist umwandeln\png\navigate_left.png';
  PNGListe[6] := 'C:\Users\ZMI GmbH\Desktop\Imagelist umwandeln\png\navigate_right.png';

  for i := 0 to High(PNGListe) do
  begin
    PNG := TPngImage.Create;
    PNG.LoadFromFile(PNGListe[i]);
    Bitmap := TBitmap.Create;
    Bitmap.Assign(PNG);
    Bitmap.PixelFormat := pf32bit;
    cxImageList.Add(Bitmap, nil);
    Bitmap.Free;
    PNG.Free;
  end;
end;

procedure TTestToolbar.SetToolButtons();
var
  i: Integer;
begin
  showmessage('SetToolButtons');
  for i := Self.ControlCount -1 downto 0 do
    Self.Controls[i].Free;

  case FToolbarType of
    ttStandard1:
    begin
      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnEnde');
      Buttons.Parent := self;
      Buttons.Caption := 'Ende';
      Buttons.AutoSize := True;
      Buttons.ImageIndex := 3;

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnKopieren');
      Buttons.Parent := self;
      Buttons.Caption := 'Kopieren';
      Buttons.AutoSize := True;
      Buttons.ImageIndex := 2;

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnSichern');
      Buttons.Parent := self;
      Buttons.Caption := 'Sichern';
      Buttons.AutoSize := True;
      Buttons.ImageIndex := 4;

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnLöschen');
      Buttons.Parent := self;
      Buttons.Caption := 'Löschen';
      Buttons.AutoSize := True;
      Buttons.ImageIndex := 0;

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnNeu');
      Buttons.Parent := self;
      Buttons.Caption := 'Neu';
      Buttons.AutoSize := True;
      Buttons.ImageIndex := 1;
    end;
    ttStandard2:
    begin
      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnEnde');
      Buttons.Parent := self;
      Buttons.Caption := 'Ende';
      Buttons.ImageIndex := 3;

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextNAme('btnLöschen');
      Buttons.Parent := self;
      Buttons.Caption := 'Löschen';
      Buttons.ImageIndex := 0;

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnVor');
      Buttons.Parent := self;
      Buttons.Caption := 'Vor';
      Buttons.ImageIndex := 6;

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnZurück');
      Buttons.Parent := self;
      Buttons.Caption := 'Zurück';
      Buttons.ImageIndex := 5;

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnSichern');
      Buttons.Parent := self;
      Buttons.Caption := 'Sichern';
      Buttons.ImageIndex := 4;

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnNeu');
      Buttons.Parent := self;
      Buttons.Caption := 'Neu';
      Buttons.ImageIndex := 1;
    end;
    ttStandard3:
    begin
      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextNAme('btnEnde');
      Buttons.Parent := self;
      Buttons.Caption := 'Ende';
      Buttons.ImageIndex := 3;

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnLöschen');
      Buttons.Parent := self;
      Buttons.Caption := 'Löschen';
      Buttons.ImageIndex := 0;

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnKopieren');
      Buttons.Parent := self;
      Buttons.Caption := 'Kopieren';
      Buttons.ImageIndex := 2;

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnSpeichern');
      Buttons.Parent := self;
      Buttons.Caption := 'Speichern';
      Buttons.ImageIndex := 4;

      Buttons := TToolbutton.Create(self.Parent);
      Buttons.Name := GetNextName('btnNeu');
      Buttons.Parent := self;
      Buttons.Caption := 'Neu';
      Buttons.ImageIndex := 1;
    end;
  end;
  if not (csLoading in ComponentState) then
    RecreateWnd;
  AdjustSize;
end;


procedure TTestToolbar.SetToolbarType(Value: TToolbarType);
begin
  if FToolbarType <> Value then
  begin
    FToolbarType := Value;
    SetToolButtons();
  end;
end;

function TTestToolbar.GetNextName(AName: String): String;
var
  i: Integer;
begin
  i := 1;
  while (Self.Owner.FindComponent(AName + IntToStr(i))) <> nil do
    i := i + 1;
  Result :=(AName + IntToStr(i));
end;

procedure TTestToolbar.Notification(AComponent: TComponent;
  Operation: TOperation);
begin
  inherited Notification(AComponent, Operation);
  if (AComponent = Buttons) and (Operation = opRemove) then
    Buttons := nil;
end;


destructor TTestToolbar.Destroy;
begin
  Buttons.Free;
  inherited;
end;

procedure Register;
begin
  RegisterComponents('ZTestKomponenten', [TTestToolbar]);
end;

end.

gekürzter Code:

Delphi-Quellcode:

unit Unit1;

interface

uses
  SysUtils, Classes, Controls, Graphics, ToolWin, ComCtrls, ImgList, cxGraphics, cxStyles,
  StdCtrls, Dialogs, pngImage;

type
  TToolbarType = (ttStandard1, ttStandard2, ttStandard3);
type
  TTestToolbar = class(TToolBar)
  private
    Buttons : TToolbutton;
  protected
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
  public
    constructor create(aOwner: TComponent); override;
    destructor Destroy; override;
    { Private-Deklarationen }
  published
end;

procedure Register;

implementation

constructor TTestToolbar.Create;
begin
  inherited;
  Parent := Owner as TWinControl;

  if Assigned(Buttons) then
    Exit;

  Buttons := TToolbutton.Create(self.Parent);
  Buttons.Name := 'btnTest';
  Buttons.Parent := self;
  Buttons.Caption := 'Test';
end;

procedure TTestToolbar.Notification(AComponent: TComponent;
  Operation: TOperation);
begin
  inherited Notification(AComponent, Operation);
  if (AComponent = Buttons) and (Operation = opRemove) then
    Buttons := nil;
end;


destructor TTestToolbar.Destroy;
begin
  Buttons.Free;
  inherited;
end;

procedure Register;
begin
  RegisterComponents('ZTestKomponenten', [TTestToolbar]);
end;

end.

Kann mir damit vll nochmal jemand weiterhelfen?
Die Toolbar könnt ihr ja erzeugen, dann seht ihr was ich meine.
Freue mich über Antworten.
MfG

[Metallicwar]

hat keiner eine Idee?
Also meiner Meinung nach, liegt der Fehler daran, dass beim Neuladen meines Projekts, (in dem sich meine eigene Toolbar befindet) zuerst die Toolbar wieder erzeugt wird, anschließend die Buttons und diese werden dann auch in der dfm Datei gespeichert. Diese beinhaltet, allerdings bereits die Toolbuttons, daher die Meldung dass die Komponente bereits existiert.
Liege ich damit richtig?