Optionen-Schaltfläche in TOpenDialog

[Moaddin]

Hallo,
ich weiß, dass dieses Thema hier schon mehrfach behandelt wurde, doch keine Antwort hat mein Problem wirklich gelöst.
Ich möchte im Öffnen-Dialog eine Extra-Schaltfläche einbinden, um ein Fenster zu öffnen, in der ich bestimmte Dinge einstellen kann.
Dazu habe ich mich in Ableitungen von Komponenten eingearbeitet, bin bisher soweit gekommen, dass die Schalfläche zwar erscheint, ich aber jetzt nicht weit, wie ich auf ihr OnClick-Ereignis reagieren kann. Ich stelle mir vor, dass ich als Ereignis des TOpenOptionsDialog etwas wie ein OnOptionsClick-Ereignis habe, worein ich dann eintragen kann, dass dieses oder jenes Formular angezeigt werden soll. Doch komme ich irgendwie nicht recht weiter. :wall:

Bin für jeden Hinweis dankbar. :bounce1:

Hier noch der Code der Komponente:

Delphi-Quellcode:

unit mOpenOptions;

interface

uses
  Messages, Windows, SysUtils, Classes, Controls, StdCtrls, Graphics,
  ExtCtrls, Buttons, Dialogs, ExtDlgs, ComCtrls;

type
  TOptionsClick = procedure(Sender: TObject) of object;

  TOpenOptionsDialog = class(TOpenDialog)
  private
    FExtraPanel:   TPanel;
    FOptionsClick: TOptionsClick;           
    FOptionen:     TButton;
    { Private-Deklarationen }
  protected
    procedure DoClose; override;
    procedure DoShow; override;
    { Protected-Deklarationen }
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    function Execute: Boolean; override;
    { Public-Deklarationen }
  published
    property OnOptionsClick: TOptionsClick read FOptionsClick write FOptionsClick;
    { Published-Deklarationen }
  end;

type
  TSaveOptionsDialog = class(TOpenOptionsDialog)
  private                                   
    { Private-Deklarationen }
  protected
    { Protected-Deklarationen }
  public
    function Execute: Boolean; override;
    { Public-Deklarationen }
  published
    { Published-Deklarationen }
  end;

procedure Register;

implementation

{$R *.res}

uses
  Consts, Forms, CommDlg, Dlgs;

constructor TOpenOptionsDialog.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);

  FExtraPanel := TPanel.Create(Self);
  FExtraPanel.Name := 'ExtraPanel';
  FExtraPanel.Caption := '';
  FExtraPanel.BevelOuter := bvNone;
  FExtraPanel.BorderWidth := 2;
  FExtraPanel.TabOrder := 1;

  FOptionen := TButton.Create(Self);
  FOptionen.Name := 'BtOptionen';
  FOptionen.Caption := 'Optionen...';
  FOptionen.Parent := FExtraPanel;
  FOptionen.SetBounds(195, 0, 75, 24);

end;

destructor TOpenOptionsDialog.Destroy;
begin
  FOptionen.Free;
  FExtraPanel.Free;
  inherited Destroy;
end;

procedure TOpenOptionsDialog.DoClose;
begin
  inherited DoClose;
  Application.HideHint;                 // Hide any hint windows left behind
end;

procedure TOpenOptionsDialog.DoShow;
var SepRect, StaticRect: TRect;
begin
  StaticRect := GetStaticRect;    // Set ExtraText area to bottom of static area
  SepRect.Top := StaticRect.Bottom;
  SepRect.Bottom := SepRect.Top+30;
  SepRect.Right := StaticRect.Right;  //-6
  SepRect.Left := StaticRect.Left;
  FExtraPanel.ParentWindow := Handle;
  FExtraPanel.BoundsRect := SepRect;
  inherited DoShow;
end;

function TOpenOptionsDialog.Execute: Boolean;
begin
  if NewStyleControls and not (ofOldStyleDialog in Options) then
    Template := 'EXTDLGTEMPLATE'
  else
    Template := nil;
  Result := inherited Execute;
end;

function TSaveOptionsDialog.Execute: Boolean;
begin
  if NewStyleControls and not (ofOldStyleDialog in Options) then
    Template := 'EXTDLGTEMPLATE'
  else
    Template := nil;
  Result := DoExecute(@GetSaveFileName);
end;

procedure Register;
begin
  RegisterComponents('Moaddin', [TOpenOptionsDialog]);
  RegisterComponents('Moaddin', [TSaveOptionsDialog]);
end;

end.

Ich denke, es hat irgendwas mit

Delphi-Quellcode:

FOptionen.OnClick

zu tun, weiß aber nicht, wo ich das hinschreiben soll und/oder was zu ergänzen wäre...

Zwei weitere, weniger wichtige Probleme, die mich aber schon länger aufgehalten haben, sind folgende:
Bei Größen-Änderung des OpenDialog hätte ich gerne, dass die Optionsschaltfläche sich mit nach rechts bewegt(genau unter Öffnen und Abbrechen). Bleibe aber immer wieder daran hängen, dass es weder OnClick noch OnResize-Ereignisse des Dialoges gibt, mit denen ich dies verknüpfen könnte.
Zweitens wenn ich meine Komponente anstatt von OpenDialog von OpenPictureDialog ableite, werden meine Modifikationen überhaupt nicht angezeigt. Wirft für mich auch ein weiteres Rätsel auf. :?: :cry: :?:

Noch ein Hinweis: ich benutze Delphi 2005 Personal

[Luckie]

Warum weist du deiner Schaltfläche kein Klick-Ereignis zu? :?

[Moaddin]

Erstmal danke für die Antwort..
Kann ja sein dass ich im Moment ein Brett vor dem Kopf habe... Wie sähe denn der genaue Code dazu aus und wo muss der stehen???
Please help me...

[Luckie]

Siehe Suche: Buttons dynamisch erstellen:
http://www.delphipraxis.net/internal...=508206#508206

[Christian Seehase]

Moin Moaddin,

Du hattest ja schon FOptionen.OnClick geschrieben.
OnClick ist eine Eigenschaft, wie Caption, der dann noch die entsprechende Methode zugewiesen werden muss.
OnClick ist vom Typ TNotifyEvent, also genügt es, wenn Dein OnOptionsClick (und natürlich das Feld FOptionsClick) vom Typ TNotifyEvent sind.

Jetzt musst Du Deiner Klasse nur noch eine entsprechene Methode einbauen, z.B.

Delphi-Quellcode:

private
  procedure MyOnClick(Sender: TObject);
//...

und FOptionen.OnClick zuweisen.

Soweit, wenn Du die Methode in Deiner eigenen Klasse haben willst.

Willst Du sie von Extern zuweisen, müsstest Du write FOptionClick durch eine Setter-Methode austauschen, in der dann der zugewiesene Wert an die Eigenschaft übergeben wird.

Delphi-Quellcode:

procedure TOpenOptionsDialog.SetClick(const Value: TNotifyEvent);
begin
  FButton.OnClick := Value;
end;

[Moaddin]

Hmm... hört sich alles ganz toll an...
Ich komme auch ein Stückchen weiter... Ich kann jetzt beispielsweise

Delphi-Quellcode:

type
  TOpenOptionsDialog = class(TOpenDialog)
  private
    FOptionsClick: TNotifyEvent;
    FOptionen:     TButton;
    procedure OptionsClick(Sender: TObject);
  published
    property OnOptionsClick: TNotifyEvent read FOptionsClick write FOptionsClick;
  end;

procedure TOpenOptionsDialog.OptionsClick(Sender: TObject);
begin
  FOptionen.Caption := 'Hallo';
end;

dieses hier schreibe, kann ich genau das machen was in der procedure OptionsClick angegeben ist (hier im Beispiel Caption auf Hallo setzen.). Das ist aber nicht das, was mir eigentlich vorschwebt.
Da es sich hier um eine Komponente handelt, will ich nachher im eigentlichen Programm selbst bestimmen können, was passiert, wenn ich auf den Button klicke. Der Hinweis mit SetOptionsClick bringt mich auch nicht ganz weiter, da ich hier eine Fehlermeldung bekomme.

Delphi-Quellcode:

  published
    property OnOptionsClick: TNotifyEvent read FOptionsClick write SetOptionsClick;

procedure TOpenOptionsDialog.SetOptionsClick(const Value: TNotifyEvent);
begin
  FOptionen.OnClick := Value;
end;

[Fehler] mOpenOptions.pas(27): E2168 Feld- oder Methodenbezeichner erwartet

Langsam bin ich echt ratlos. Was mache ich nur falsch?

[Christian Seehase]

Moin Moaddin,

das hier

Delphi-Quellcode:

procedure TOpenOptionsDialog.SetOptionsClick(const Value: TNotifyEvent);

ist eine Methode der Klasse TOpenOptionsDialog, muss also dort auch eingebunden werden:

Delphi-Quellcode:

TOpenOptoinsDialog = class...
private
// Felddeklarationen

  procedure SetOptionsClick(const Value: TNotifyEvent);
//....
protected
//...
public
//...

[Moaddin]

Hallo Christian,
vielen Dank für deine bisherige Hilfe.

Ich habe alle Schritte befolgt, es tut sich jedoch weiterhin nichts. Für mich ist auch keine klare Verknüpfung von dem Button.OnClick und der property zu erkennen. Desweiteren, wenn ich im Objektinspektor auf dieses Ereignis zugreife (OptionsClick) wird diese zwar erzeugt und ich kann auch etwas hineinschreiben, doch im Inspektor wird der Prozedurname nicht, wie üblich bei anderen Ereignissen, angezeigt. Auch wenn ich ihn manuell dort eingebe, leert sich das Feld von alleine.
So sieht mein Code jetzt aus (Ausschnittsweise). Sollte es eigentlich so funktionieren oder fehlt da noch etwas?

Delphi-Quellcode:

type
  TOpenOptionsDialog = class(TOpenDialog)
  private
    FOptionsClick: TNotifyEvent;
    FOptionen:     TButton;
    procedure SetOptionsClick(const Value: TNotifyEvent);
  published
    property OnOptionsClick: TNotifyEvent read FOptionsClick write SetOptionsClick;
  end;

procedure TOpenOptionsDialog.SetOptionsClick(const Value: TNotifyEvent);
begin
  FOptionen.OnClick := Value;
end;

Viele Grüße
Moaddin