Komponentenentwicklung - Event weiterleiten - Denkfehler?

[stahli]

[Trotz rotem Kasten aus Zeitgründen mal rausgehauen...]

Da musst man noch unterscheiden.


1) Soll es eine fixe Behandlung geben?

Dann kannst Du eine Methode
procedure MyInnerControlClick(Sender: TObject);
dem
InnerControl.OnClick
einfach zuweisen.

Dein InnerControl muss dann den Context kennen, in dem es existiert und Zugriff auf die benötigten Daten haben.


2) Soll eine freie Behandlung definierbar sein?

Dann musst Du Dir anschauen, wie OnClick implementiert ist und das mit OnInnerClick nachbauen.
Dann kannst Du in Deinem Projektcode die Behandlung individuell regeln.
Das ist natürlich komplexer.
(Das ich so etwas gemacht habe ist Jahre her. Ich könnte bei Bedarf mal suchen, ob ich dazu noch etwas finde.)

[Aviator]

Danke für die Antworten. Ich konkretisiere das Ganze aber mal noch ein bisschen.

Ausgehend von der Idee der TVirtualBreadCrumb Komponente von Codehunter habe ich meine eigene BreadCrumbBar schreiben wollen. Hintergrund ist der, dass ich nicht nur auf den VST reagieren, sondern bei Bedarf auch eine eigene Struktur aufbauen können will. Eine Frage habe ich diesbezüglich auch bereits in seinem Thread geschrieben.

Konkret geht es jetzt darum, dass ich eine folgende Klassenstruktur habe:

Delphi-Quellcode:

TBreadCrumbButtonBase = class(TCustomControl)
[...] // BasisButton von dem alle anderen Buttons abgeleitet werden
end;

Delphi-Quellcode:

TBreadCrumbRootButton = class(TBreadCrumbButtonBase)
[...] // Button der angezeigt wird, wenn nicht alle Breadcrumbs in die Bar passen
end;

Delphi-Quellcode:

TBreadCrumbButton = class(TBreadCrumbButtonBase)
[...] // Das ist der DropDown Button der hinter dem BreadCrumb hängt
end;

Delphi-Quellcode:

TBreadCrumb = class(TCustomControl)
private
  FButton: TBreadCrumbButton;  // Hier der verschachtelte BreadCrumbButon auf dessen Klick ich reagieren will um ein Menü anzuzeigen
end;

An dieser Stelle kommt jetzt noch meine Basis BreadCrumbBar von der alle anderen Bars die speziell reagieren sollen abgeleitet werden können.

Delphi-Quellcode:

TCustomBreadCrumbBar = class (TCustomControl)
private
  FRootButton: TBreadCrumbRootButton;
  FBreadCrumbs: TBreadCrumbs;
[...] 
end;

Hier die konkrete Implementierung der BreadCrumbBar die es zulässt, dass ich eigene Buttons hinzufügen kann wie ich das möchte.

Delphi-Quellcode:

TBreadCrumbBar = class(TCustomBreadCrumbBar)
[...]
end;

Später soll es dann noch eine andere Ableitung geben, die die Buttons dann selbst erstellt (abhängig von einem VirtualTreeView). Diese Ableitung wird dann noch erweitert, dass ich zusätzlich zu den VirtualTreeView Buttons auch eigene vorne dran stellen kann.

Da wie beim Windows Explorer beim Klick auf den TBreadCrumbButton ein Menü erscheinen soll welches diverse Auswahlmöglichkeiten bietet, muss ich ja das ClickEvent des TBreadCrumbButtons durchschleifen damit dies auf meiner GUI Form ankommt.

Und hier setzt meine Frage an. Wie kann ich das Vorhaben vereinfachen?

Diese vielen Klassen habe ich eben gemacht, damit ich nur noch eine TBreadCrumb Instanz erzeugen muss und dadurch dann entsprechend auch der DropDownButton erzeugt wird und sich auch alles selbst zeichnet. Deshalb auch TCustomControl. Wenn ich alles in der TCustomBreadCrumbBar zeichnen würde, dann müsste ich die Mausposition auswerten und errechnen, an welcher Stelle ich geklickt habe um entsprechend reagieren zu können. Durch die vielen Komponenten habe ich eben schon diverse Features die ich nicht mehr selbst implementieren muss.

Ich hoffe ich habe es jetzt ausführlicher und damit etwas verständlicher beschrieben.

[stahli]

So ganz kann ich nicht folgen, aber mal ein Versuch (etwas PseudoCode):

Delphi-Quellcode:

TBreadCrumb = class(TCustomControl)
private
   FButton: TBreadCrumbButton; // Hier der verschachtelte BreadCrumbButon auf dessen Klick ich reagieren will um ein Menü anzuzeigen
   procedure BreadCrumbButtonClick(Sender...);
end; 

constructor TBreadCrumb.Create(...)
begin
  inherited;
  FButton := TBreadCrumbButton.Create(Self);
  fButton.Parent := Self;
  fButton.OnClick := BreadCrumbButtonClick;
end; 

procedure TBreadCrumb.BreadCrumbButtonClick(...)
var
  P: TPoint;
begin
  P := TPoint.Create(IrgendEinX, IrgendEinY);
  P := ClientToSreen(P);
  PopupMenueÖffnenMitBestimmtenEintraegenAnPos(P);
end;

Ich weiß nicht, ob Dich das weiter bringt.
Zumindest kann der Button selbst auf den Klick reagieren.
Was er dann machen soll, wird sicher schon schwieriger.
Dazu muss er halt wissen, für welche Aufgabe er in welchem aktuellen Kontext steht.


Frag doch sonst mal CodeHunter, ob er Dir weiter helfen kann, er hat ja da offenbar schon etwas vorgelegt...

[Uwe Raabe]

Wenn du die gekapselte Komponente als SubKomponente anlegst, bekommst du die Eigenschaften und Events im Objektinspektor angezeigt. Hier als Beispiel ein Panel mit einem Button drauf.

Delphi-Quellcode:

unit PanelExt;

interface

uses
  System.SysUtils, System.Classes, Vcl.Controls, Vcl.ExtCtrls, Vcl.StdCtrls;

type
  TPanelExt = class(TPanel)
  private
    FButton: TButton;
  protected
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    property Button: TButton read FButton;
  end;

procedure Register;

implementation

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

constructor TPanelExt.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FButton := TButton.Create(Self);
  FButton.SetSubComponent(true);
  FButton.Parent := Self;
  FButton.Name := 'TestButton';
end;

destructor TPanelExt.Destroy;
begin
  FButton.Free;
  inherited Destroy;
end;

end.

[Aviator]

Zitat von stahli:

Ich weiß nicht, ob Dich das weiter bringt.
[...]
Frag doch sonst mal CodeHunter, ob er Dir weiter helfen kann, er hat ja da offenbar schon etwas vorgelegt...

Naja. Im Prinzip hast du jetzt mehr oder weniger nur das bestätigt, was ich schon wusste bzw. wie ich es die ganze Zeit umsetze. Nur ich dachte eben, dass es eine optimalere Variante gibt. Eventuell habe ich ja auch mein Klassendesign etwas falsch durchdacht.

Codehunter hat das alles etwas anders umgesetzt. Sein SourceCode ist ja bei der Komponente dabei. Den habe ich mir natürlich angeschaut.

Zitat von Uwe Raabe:

Wenn du die gekapselte Komponente als SubKomponente anlegst, bekommst du die Eigenschaften und Events im Objektinspektor angezeigt. Hier als Beispiel ein Panel mit einem Button drauf.

Klingt zumindest mal interessant. Werde mal schauen, ob ich das mit meiner Komponente so hinbiegen kann, dass es mir das bringt was ich mir wünsche.