Eigene Komponente (Toolbar) programmieren

[Metallicwar]

Hallo zusammen, ich habe folgendes vor:
In einem Programm werden in fast allen Modulen Toolbars verwendet, meistens mit den Toolbutton(Vor, Zurück, Abbruch, Löschen, etc... und eben Zusatzbuttons, wie z.B. Speichern, etc.)
Ich möchte nun eben eine Toolbar programmieren, die mir standardmäßig alle Toolbuttons anzeigt. Im Objektinspektor möchte ich zusätzlich eine neue Eigenschaft anlegen, mit dem Namen "Toolbar Standards". In dieser Eigenschaft soll man zwischen mehreren Standards auswählen können (Standard1, Standard2, Standard3, usw.)
Standard1 blendet mir z.B. alle Zusatzbuttons aus.
Standard2 zeigt mir z.B. nur Vor und Zurück an .
...
Eine neue Toolbar Komponente zu erstellen, bekomm ich hin.
Nun meine Fragen:
-wie füge ich die Toolbarbuttons hinzu
-wie kann ich meinem Programm sagen, dass er mir bei der Auswahl von "Standard1" eben alle Zusatzbuttons ausblendet.

Delphi-Quellcode:

unit ToolBar1;

interface

uses
  SysUtils, Classes, Controls, ToolWin, ComCtrls;

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

type
  TTestToolbar = class(TToolBar)
  private
    Bars: TTestBars;
    { Private-Deklarationen }
  protected
    { Protected-Deklarationen }
  public
    { Public-Deklarationen }
  published
    property Ort: TTreffpunkt read Bars write Bars;
    { Published-Deklarationen }
  end;

procedure Register;

implementation

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

end.

[Metallicwar]

mein aktueller Stand:

Delphi-Quellcode:

unit Testtoolbar2;

interface

uses
  SysUtils, Classes, Controls, ToolWin, ComCtrls;

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

type
  TTestToolbar = class(TToolBar)
  public
  constructor create(aOwner: TComponent); override;
    //Bars: TTestBars;
    //Buttons: TToolButton;
    { Private-Deklarationen }
  private
    Button : TToolbutton;
  end;

  procedure Register;

implementation

constructor TTestToolbar.Create;
var
  iButtons: Integer;
begin
  inherited Create(aOwner);
  TRY
    for iButtons := 0 to 9 do
      Button := TToolbutton.Create(self);
      Button.Caption := 'Button'+IntToStr(iButtons+1);
      Button.Parent := TTestToolbar;
      Button.Show;
  EXCEPT
    Button.Free;
  END;
end;

  {
destructor TTestToolbar.
begin
  if Button <> nil then
  begin
    Button.Free;
    Button := nil;
  end;
  inherited Destroy;
end;
           }
procedure Register;
begin
  RegisterComponents('ZTestKomponenten', [TTestToolbar]);
end;

end.

Fehler: Inkompatible Typen : "TWinControl" und "Class Reference"

[Jumpy]

Müsste

Button.Parent := TTestToolbar;

nicht

Button.Parent := self

sein oder so?

[DeddyH]

Müsste da nicht ein begin-end rein?

[shmia]

Zitat:

Zitat von DeddyH (Beitrag 1086525)

Müsste da nicht ein begin-end rein?

Richtig, und das

Delphi-Quellcode:

Button.Show

muss raus; das hat in einem Konstruktor nichts verloren.

[DeddyH]

Zitat:

Delphi-Quellcode:

Button.Parent := TTestToolbar;

Das kann auch nicht stimmen, der Parent muss eine Instanz sein und keine Klasse.

[Jumpy]

Zitat:

Zitat von DeddyH (Beitrag 1086527)

Zitat:

Delphi-Quellcode:

Button.Parent := TTestToolbar;

Das kann auch nicht stimmen, der Parent muss eine Instanz sein und keine Klasse.

Sach ich ja :wink:


Wäre es nicht besser ein Array oder 'ne Liste oder sowas mit Buttons zu erstellen, damit man im Verlaufe des Programms weiter Zugriff auf bestimmte Buttons erhält, um z.B. Zusatzbuttons ein- und auszublenden, etc. ?

[Metallicwar]

aktueller Stand:

Delphi-Quellcode:

unit Testtoolbar2;

interface

uses
  SysUtils, Classes, Controls, ToolWin, ComCtrls;

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

type
  TTestToolbar = class(TToolBar)
  public
  constructor create(aOwner: TComponent); override;
    //Bars: TTestBars;
    //Buttons: TToolButton;
    { Private-Deklarationen }
  private
    Buttons : TToolbutton;
  end;

  procedure Register;

implementation

constructor TTestToolbar.Create;
begin
  inherited Create(aOwner);
  begin
    //Standardeigenschaften für Toolbar setzen
    //Self.ShowCaptions := True;
    Parent := AOwner as TWinControl;
    Buttons := TToolbutton.Create(self);
    Buttons.Name := 'btnNeu';
    Buttons.Parent := self;
    Buttons.Caption := 'Neu';
    Self.Buttons := Buttons;
  end;
end;

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

end.

Ich kann nun die Toolbar auf die Formziehen, mein Toolbutton wird angezeigt, aber er ist nicht anklickbar.
Befindet er sich noch nicht in der Collection der Toolbar?
über

Delphi-Quellcode:

 TToolbutton.Buttons[0] := Buttons

ist ja ja möglich einen Button der COllection der Toolbar hinzuzufügen.
aber in meinem Code funktionierts nicht.
Hab das auch in meinem Code versucht, dort bekomm ich aber die Fehlermeldung "Klasse besitzt keine Standardeigenschaft"
und hab es daher mal über

Delphi-Quellcode:

    Self.Buttons := Buttons;

probiert, aber das hilft auch nicht.

Hat jemand eine Lösung dafür?
MfG

end.

[/DELPHI]

[Jumpy]

Wenn ich eine normale Toolbar auf ein Form ziehe und dann darauf einen Button kreire, dann taucht der Button auch in den Komponenten meiner Form auf, d.h. das Form ist der owner oder parent von dem Button?

Vllt. musst du das entsprechend Abbilden?

[Metallicwar]

Zitat:

Zitat von Jumpy (Beitrag 1086537)

Wenn ich eine normale Toolbar auf ein Form ziehe und dann darauf einen Button kreire, dann taucht der Button auch in den Komponenten meiner Form auf, d.h. das Form ist der owner oder parent von dem Button?

Vllt. musst du das entsprechend Abbilden?

ja, über eine normale Toolbar zur Laufzeit habe ich es auch schon öfters gemacht, da funktionierts bei mir auch, aber da mach ich nix anderst wie in diesem Fall, nur eben, dass mein Parent, eine neue Komponente ist.

[DeddyH]

Pack doch einmal eine Toolbar auf Dein Formular und definiere dort einen neuen Schalter. In dessen OnClick-Methode lässt Du Dir seinen Parent und seinen Owner ausgeben. Ergebnis: Owner ist das Formular, Parent die Toolbar. So solltest Du das dann auch abbilden.

[Satty67]

Etwas blöd so spät damit zu kommen, aber wäre eine Komponentenvorlagen-Sammlung nicht die einfachere Lösung gewesen?

Also Toolbar mit Buttons bestücken und Standardcode in den Events eingeben. Dann Toolbar und Imagelist selektieren und Komponenten-Vorlage erzeugen.

€: Erkenne gerade, das die gewünschte Aufgabe damit nicht ganz erfüllt wird (zumindest nicht, wenn zur Laufzeit die Buttons ein/ausgeblendet werden sollen). Hab' das etwas falsch interpretiert.

[Metallicwar]

ich bin gerade dabei, mir den Owner und den Parent anzeigen zu lassen. Melde mich wieder!

[Metallicwar]

also der hinzugefügte Button ist jetzte auch anklickbar:

Delphi-Quellcode:

unit Testtoolbar2;

interface

uses
  SysUtils, Classes, Controls, ToolWin, ComCtrls;

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

type
  TTestToolbar = class(TToolBar)
  public
  constructor create(aOwner: TComponent); override;
    //Bars: TTestBars;
    //Buttons: TToolButton;
    { Private-Deklarationen }
  private
    Buttons : TToolbutton;
  end;

  procedure Register;

implementation

constructor TTestToolbar.Create;
begin
  inherited Create(aOwner);
  begin
    //Standardeigenschaften für Toolbar setzen
    Self.ShowCaptions := True;

    Parent := AOwner as TWinControl;
    Buttons := TToolbutton.Create(self.Parent); // <-- SELF.Parent 
    Buttons.Name := 'btnNeu';
    Buttons.Parent := self;
    Buttons.Caption := 'Neu';
  end;
end;

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

end.

nächstes Problem, bei dem ich mir leider nicht zu helfen weiß ist, dass ich zur Laufzeit, wenn ich auf den Toolbutton meiner neuen Komponente klicke, den Fehler erhalte: "Komponente mit der Bezeichnung btnNeu existiert bereits"

[Jumpy]

Buttons := TToolbutton.Create(self.Parent);

müsste mMn sein:

Buttons := TToolbutton.Create(self.Owner);

Das das klappt ist glaub ich "Zufall" da self.Owner = self.Parent (= das Form).

Ziehst du die Toolbar auf ein Panel, könnte das ggf. schief laufen, oder?

-------------

Ist dem Button den schon ein Ereignis zugewiesen?

[Metallicwar]

Zitat:

Ist dem Button den schon ein Ereignis zugewiesen?

ja, ein OnClick!

P.S. mit

Delphi-Quellcode:

Buttons := TToolbutton.Create(self.Owner);

erhalte ich den selben Fehler!

[Jumpy]

Zitat:

P.S. mit Buttons := TToolbutton.Create(self.Owner); erhalte ich den selben Fehler!

Das sollte nicht bei dem Fehler helfen, sondern war eine allgemeine Beobachtung/Frage.

Was den Fehler betrifft:

Wie sieht das Ereignis den aus? Den darin scheints ja zu hängen, wenns während der Laufzeit beim Knopfdruck mecker gibt...
Es klingt ja so, als soll sich der Knop auf Knopfdruck selber neu erzeugen?

[Metallicwar]

Zitat:

Es klingt ja so, als soll sich der Knop auf Knopfdruck selber neu erzeugen?

also --> ich ziehe meine eigene Toolbar auf das Formular, weise dem hinzugefügtem Button der Toolbar, ein OnClick Ereignis zu:

Delphi-Quellcode:

ShowMessage('Test');

Wenn ich zur Laufzeit auf den Button klicke, erhalte ich die Felermeldung.

In diesem Fall, kann mir doch ComponentState weiterhelfen, oder?

[DeddyH]

Lass doch einfach einmal die Namenszuweisung an den Button weg.

[Metallicwar]

Moin Moin, also ich ein großes PRoblem schonmal gelöst, aber schon treten neue Probleme auf. *lach*
Erstmal mein bisheriger Code, ich kann meine Toolbar auf die Form ziehen, kann den Buttons OnClick Ereignisse zuweisen, diese funktionieren auch.

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;
  protected
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
  end;

  procedure Register;

implementation

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 := 'btnSpeichern';
    Buttons.Parent := self;
    Buttons.Caption := 'Speichern';

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

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

    Buttons := TToolbutton.Create(self.Parent);
    Buttons.Name := '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.

Wenn ich nun aber noch eine Toolbar auf die Form ziehe meckert er, dass die Komponente mit dem Namen btnNeu, ... bereits existiert, also werd ich beim programmieren der Toolbar eine function einbauen, die prüft, ob eine Komponente mit diesem Name bereits existiert, wenn ja prüfen ob eine mit dem Namen btnNeu1 existiert, falls ja prüfen ob BtnNeu2 existiert, usw. .Falls nein, den nächst freien Namen verwenden.
Oder ist das anderst und einfacher zu lösen

[himitsu]

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

Delphi-Quellcode:

.Create({Self.}Parent)

und vorallem

Delphi-Quellcode:

.Create({Self.}Owner)

sind total falsch
und müßten in

Delphi-Quellcode:

.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 :warn: (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

Delphi-Quellcode:

.Create(Parent)

habe ich

Delphi-Quellcode:

.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

Delphi-Quellcode:

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?

[Metallicwar]

hier mal der Code in abgespeckter Version (nur ein Button wird erzeugt):

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.

Folgendes PRoblem:
- 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, etc... existiert bereits"

[Bummi]

Ich habe jetzt eine ganze Weile mit dem teil rumexperimentiert und weiß jetzt warum ich das TToolbar bisher nie freiwillig einsetzen wollte.
Der Effekt tritt ja schon auf wenn Du im Formular auf Ansicht als Text und wieder zurückschaltest. Wenn man den Namen weglässt entsteht bei jedem hin und herschalten ein neuer Button, zu Laufzeit kommt dann die Fehlermeldung "Klasse TToolbutton nicht gefunden".
ein :

Delphi-Quellcode:

if not Assigned(FindComponent('Test')) then
    begin

ändert ncihts an dem Verhalten, produziert aber neue Fehler.
Der selbst erstellte Toolbutton ist auch nicht bedienbar....

Muss es tatsächlich ein TToolbar als Vorfahr sein, oder kannst Du auch z.B. auf einem TCustompanel aufsetzen, hier hast Du das ganze unbeeinflussbare Innenleben des Toolbars nicht an der Backe hängen.

[Metallicwar]

Zitat:

Zitat von Bummi (Beitrag 1087776)

Muss es tatsächlich ein TToolbar als Vorfahr sein, oder kannst Du auch z.B. auf einem TCustompanel aufsetzen, hier hast Du das ganze unbeeinflussbare Innenleben des Toolbars nicht an der Backe hängen.

Ja es sollte eine TToolbar sein, da in dem Programm, bisher schon sehr viele Toolbars existieren und durch Einführung eines TCustomPanel ein neuer Standard geschaffen würde. Ich will bei einem Standard bleiben --> Toolbar.
Und wie wäre es über ein TCustompanel möglich neue Toolbuttons auf dem Panel zu platzieren?
Oder versteh ich etwas falsch?

Ich habe am Wochenende nochmal ein bisschen probiert, aber ich finde einfach keine Lösung für mein geschildertes Problem, bin am Verzweifeln :cry:

[Bummi]

Nein, ich bezweifle dass ich den Nerv hätte mich mit dem Toolbar längerfristig rumzuärgern.
Ich wünsche Dir viel Erfolg und bewundere Deine Ausdauer...