Hallo

ich habe über

zusammenfalten · markieren

Delphi-Quellcode:

function MyMessageDlg(sMsg: String; aDlgTypt: TMsgDlgType; aButtons: TMsgDlgButtons; sArrCaption: array of String; sDlgCaption: String): Integer;
// *****************************************************************************************************************************************
// Eigene MessageBox mit selbst definierbaren Buttons anzeigen
var
  aMsgdlg: TForm;
  i: Integer;
  btButton: TButton;
  iCaptionIndex: Integer;
  sButton: String;

begin
  aMsgdlg := CreateMessageDialog(sMsg, aDlgTypt, aButtons);
  aMsgdlg.Caption := sDlgCaption;
  aMsgdlg.BiDiMode := bdRightToLeft;
  iCaptionIndex := 0;

  for i := 0 to aMsgdlg.ComponentCount - 1 Do
  begin
    if (aMsgdlg.components[i] is TButton) then
    begin
      btButton := TButton(aMsgdlg.components[i]);
      if (iCaptionIndex <= High(sArrCaption)) and (sArrCaption[iCaptionIndex] <> '') then
        btButton.Caption := sArrCaption[iCaptionIndex];
      inc(iCaptionIndex);
    end;
  end;

  Result := aMsgdlg.Showmodal;

  sButton := sArrCaption[Index of clickt Button]
end;

eine MessageDialog, bei dem ich die Texte der Buttons definieren kann.

Jetzt könnte ich natürlich über ein Loop ermitteln welchen Index der letztlich angeklickte Button in TMsgDlgButtons hat.

Gibt es eine einfachere Möglichkeit den Index zu bekommen?

Ziel ist es den gewählten Text des Buttons zu ermitteln.

Beispiel
lDialogResult := MyMessageDlg('Test der eigenen Button.', mtConfirmation, [mbYes, mbNo, mbOk, mbCancel], ['ButtonYes', 'ButtonNo', 'ButtonOK'], 'Dialog Test');

sButton soll beim Klick auf [ButtonYes] => Result = mrYes = 6 => sButton = 'ButtonYes' liefern

In aButtons liegen [mbYes, mbNo, mbOk, mbCancel] => richtiger Index für Klick auf [mbYes] wäre 0

1. Du könntest dem .Tag des Buttons einen eindeutigen Wert zuweisen und falls du ein OnClick Ereignis für
den Button hast dieses dort abfragen.

2. Was generelles zu deiner Function: warum nutzt du für den Kopf Kommentar nicht XMLDOC?
Dann könntest du dir diesen Kommentar an jeder beliebigen Aufrufstelle beim Drüberfahren mit
der Maus über den Aufruf anzeigen lassen.

Hier ein Beispiel, die einzelnen "Templates" kann man mittels Strg-J einfügen (Strg-J drücken, dann den ersten Buchstaben des gewünschten Templates)

markieren

Delphi-Quellcode:

/// <summary>
/// Eigene MessageBox mit selbst definierbaren Buttons anzeigen
/// </summary>
/// <param name="sMsg">
/// Anzuzeigende Nachricht
/// </param>
// für alle anderen Params auch jeweils <param name="...
function MyMessageDlg(sMsg: String; aDlgTypt: TMsgDlgType; aButtons: TMsgDlgButtons; sArrCaption: array of String; sDlgCaption: String): Integer;
// *****************************************************************************************************************************************

3. Bei Funktions/Methodendefinitionen mit String Parametern solltest du vor jeden String Parameter const schreiben.
Das macht den Aufruf ein wenig performanter. Geht natürlich nur für parameter die innerhalb der Funtkion/Methode
nicht verändert werden.

Grüße
TurboMagic

Danke für die Tips.

Wie das mit dem Tag funtionieren sollte ist mir nicht ganz klar. Beim Klick auf [ButtonYes] liefert aMsgdlg.Showmodal ja das Ergebnis mrYes = 6. Wie soll ich mit diesem Result auf den Tag des Buttons kommen. Wenn ich den Button hätte, könnte ich ja auch gleich auf Button.Caption zugreifen.

Ich hatte gehofft es gibt so was wie Index := aButtons.IndexOf(Result) um den Index zu ermitteln.

Dass Const den Aufruf beschleunigt ist mir neu. Spielt hier keine wesentlich Rolle, aber ich denke ich habe andere Aufrufe wo das helfen könnte.

Grüße
Gerd

Ist es so umständlich einfach TTaskDialog zu benutzen?

In zu alten Windowsen oder saudämlich eingestellten neueren Windowsen
nutzt der zwar auch CreateMessageDialog, aber so muß man sich nicht selber um die Länge der Buttons kümmern.



TTaskDialog.Buttons

PS: Rate mal, warum Buttons ein ModalResult-Property besitzen.

Mmmh, weil ich TTaskDialog noch nicht kannte? Ich habs ausprobiert und das ist genau das richtige.

Habe festgestellt, dass der Index mir eh nur zufällig genutzt hätte. Ich war der irrigen Meinung, dass die Buttons in der Reihenfolge angezeigt werden, wie sie in MyMessageDlg('Test der eigenen Button.', mtConfirmation, [mbYes, mbNo, mbOk, mbCancel], ['ButtonYes', 'ButtonNo', 'ButtonOK'], 'Dialog Test') gelistet sind. Da das aber ja gar nicht der Fall ist, wäre es eher Zufall gewesen, wenn das Result dem Index in aButtons entsprochen hätte.

Danke
Gerd

Ein kleines Problem ist doch aufgetreten.

Wenn der Benutzer das Fenster einfach nur wieder schließt, möchte ich festlegen, welches ModalResult zurück geliefert wird. In meinem Beispiel sollte das Cancel sein, wenn es diesen Button gibt
Mein Code sieht so aus

zusammenfalten · markieren

Delphi-Quellcode:

function MyMessageDlg(const sMsg: String; aDlgTypt: TMsgDlgType; sArrCaption: array of String;
  sDlgCaption: String = ''): Integer;
// *****************************************************************************************************************************************
var
  aMsgdlg: TForm;
  i: Integer;
  sButton: String;
  TaskDialog: TTaskDialog;

begin
  // create a custom task dialog
  TaskDialog := TTaskDialog.Create(Application);
  try
    TaskDialog.Caption := sDlgCaption;
    TaskDialog.Title := sMsg;
    TaskDialog.CommonButtons := [];

    TaskDialog.ModalResult := 0;

    // add customized buttons to the task dialog
    for i := low(sArrCaption) to High(sArrCaption) do
    begin
      with TTaskDialogButtonItem(TaskDialog.Buttons.Add) do
      begin
        Caption := sArrCaption[i];
        ModalResult := i;
        if LowerCase(Caption) = 'cancel' then
          TaskDialog.ModalResult := i;
      end;
    end;

    // display the dialog box and read the ModalResult
    if TaskDialog.Execute then
      Result := TaskDialog.ModalResult;
  finally
    TaskDialog.Free;
  end;

  sButton := '';
  if High(sArrCaption) > 0 then
    sButton := sArrCaption[Result];
end;

lDialogResult := MyMessageDlg('Test der eigenen Button.', mtConfirmation, ['ButtonYes', 'ButtonNo', 'ButtonOK', 'Cancel'], 'Dialog Test');

Klicke ich aber auf das 'Schließen Kreuz' im Header, wird immer ModalResult = 2 geliefert. Das entspricht dem standardmässigen mrCancel.
Kann ich das ändern oder wäre es besserer Stil, wenn ich meine eigenen Results mit einem Offset versehe so dass sie nicht die Standards verbiegen?

Wenn du mal diese Komponente auf die Form pappst und dort befüllst, dann bemerkst du ....

nja, also standardmäßig werden die CustomButtons einfach ab 100 gezählt und kommen somit den Standard-ModalResult-Buttons/Konstanten nicht in die Quere.



PS: Ich hab bei uns in der Firma das auch in eine Funktion gekapselt,
aber dort kann man die Buttons als StringArray oder kommaseparierten String reingeben,
also ['Yes', 'No'] oder 'Yes,No', bzw. 'Yes=Irgendwas,No=Anderes'.
Das Erste ist der Button mit oder ohne "mr" und gefolgt optional eine alternative Caption.
Aber man könnte es auch umdrehen, also 'Irgendwas,Anderes' oder 'Irgendwas=Yes,Anderes=105' (wenn nichts angegeben ab 100 durchnummerieren)

In Vcl.Consts gibt es die Captions der Default-Buttons. (SYesButton usw.)
For ModalResult gibt es nichts, und leider kann man in Vcl.Buttons mal auch wieder nicht auf gewisse Konstanten zugreifen. (BitBtnResNames, BitBtnCaptions und BitBtnModalResults)




Das ModalResult des Dialogs setzt man eigentlich nicht. (außer während des Anzeigens, zum manuellen Schließen des Dialogs)
Es kann auch Probleme geben.

Du hast Glück, dass oftmals (leider nicht bei allen Komponenten) das ModalResult der Form beim Start des ShowModal auf 0 gesetzt wird. (ich war mal auf eine Komponente gestoßen, wo es am Ende gesetzt wurde)
Denn dieses Form.ModalResult wird zum Abbruch des ShowModal benutzt. (wenn <>0 dann verlasse die Schleife)
* erstmal blöd, weil wenn man es nach oder vor dem Anzeigen setzt, dann geht beim nächsten Anzeigen der Dialog sofort wieder zu
* und außerdem kann man den letzten ModalResult dann "nach" dem Anzeigen nicht nochmals auslesen

Hier mal das was himitsu meinte und einer kleinen event-erweiterung

zusammenfalten · markieren

Delphi-Quellcode:

type
  TOnMsgDlgClick = procedure (Sender: TObject; const ATag: Integer) of object;
  TForm1 = class(TForm)
    ...
  strict private
  private
    procedure DlgClickEvent(Sender: TObject; const ATag: Integer);
  public
    FOnMsgDlgClick: TOnMsgDlgClick;
  public
    function MyMessageDlg(const sMsg: String; const aDlgTypt: TMsgDlgType; const sArrCaption: array of String; const sDlgCaption: String; var ClickEvent: TOnMsgDlgClick): Integer;
  public
    property ClickDlgEvent: TOnMsgDlgClick read FOnMsgDlgClick write FOnMsgDlgClick;
  end;

implementation

procedure TForm1.FormCreate(Sender: TObject);
begin
  FOnMsgDlgClick := DlgClickEvent;
end;

procedure TForm1.DlgClickEvent(Sender: TObject; const ATag: Integer);
begin
  // ab 1000 ist es ein button, alles darunter ist ein reguläres modal result, somit kannst du hier easy entscheiden was passieren soll bei einem button click
  // "case of" würde ich benutzen ...
  ShowMessage(IntToStr(ATag));
end;

function TForm1.MyMessageDlg(const sMsg: String; const aDlgTypt: TMsgDlgType; const sArrCaption: array of String; const sDlgCaption: String; var ClickEvent: TOnMsgDlgClick): Integer;
// *****************************************************************************************************************************************
var
  aMsgdlg: TForm;
  i: Integer;
  sButton: String;
  TaskDialog: TTaskDialog;
begin
  FOnMsgDlgClick := ClickEvent;
  // create a custom task dialog
  TaskDialog := TTaskDialog.Create(Application);
  try
    TaskDialog.Caption := sDlgCaption;
    TaskDialog.Title := sMsg;
    TaskDialog.CommonButtons := [];
    TaskDialog.ModalResult := 0;

    // add customized buttons to the task dialog
    for i := low(sArrCaption) to High(sArrCaption) do
    begin
      with TTaskDialogButtonItem(TaskDialog.Buttons.Add) do
      begin
        Caption := sArrCaption[i];
        ModalResult := i * 1000;
      end;
    end;

    // display the dialog box and read the ModalResult
    if TaskDialog.Execute then
      begin
        if Assigned(FOnMsgDlgClick) then
          FOnMsgDlgClick(Self, TaskDialog.ModalResult);
        Result := TaskDialog.ModalResult;
      end;
  finally
    TaskDialog.Free;
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  lDialogResult: Integer;
begin
  lDialogResult := MyMessageDlg('Test der eigenen Button.', mtConfirmation, ['ButtonYes', 'ButtonNo', 'ButtonOK', 'Cancel'], 'Dialog Test', FOnMsgDlgClick);
end;

Hallo zusammen,

habe es genauso gemacht. War mir letztlcih auch lieber als die Standard-Results zu überschreiben

PS: + statt * ModalResult := i + 100; Danke, Grüße und schöne Weihnachten
Gerd