feat: support message dialogs with 3 buttons (#2641)

* feat: support message dialogs with 3 buttons

* change file

* From<String>

* untagged & YesNoCancel

* revert package.json

* Update plugins/dialog/src/desktop.rs

Co-authored-by: Tony <68118705+Legend-Master@users.noreply.github.com>

* no optional

* Update desktop.rs

* Update plugins/dialog/src/models.rs

Co-authored-by: Tony <68118705+Legend-Master@users.noreply.github.com>

* change to an enum

* convert back into union

* regen

* update @since

* map buttons for linux

* enhance type

* Add examples

---------

Co-authored-by: Tony <68118705+Legend-Master@users.noreply.github.com>
Co-authored-by: Lucas Nogueira <lucas@tauri.app>
Co-authored-by: Tony <legendmastertony@gmail.com>

plugins/dialog/src/commands.rs

@@ -9,8 +9,8 @@ use tauri::{command, Manager, Runtime, State, Window};
 use tauri_plugin_fs::FsExt;
 
 use crate::{
-    Dialog, FileDialogBuilder, FilePath, MessageDialogButtons, MessageDialogKind, Result, CANCEL,
-    NO, OK, YES,
+    Dialog, FileDialogBuilder, FilePath, MessageDialogBuilder, MessageDialogButtons,
+    MessageDialogKind, MessageDialogResult, Result, CANCEL, NO, OK, YES,
 };
 
 #[derive(Serialize)]
@@ -248,7 +248,7 @@ fn message_dialog<R: Runtime>(
     message: String,
     kind: Option<MessageDialogKind>,
     buttons: MessageDialogButtons,
-) -> bool {
+) -> MessageDialogBuilder<R> {
     let mut builder = dialog.message(message);
 
     builder = builder.buttons(buttons);
@@ -266,7 +266,7 @@ fn message_dialog<R: Runtime>(
         builder = builder.kind(kind);
     }
 
-    builder.blocking_show()
+    builder
 }
 
 #[command]
@@ -277,19 +277,15 @@ pub(crate) async fn message<R: Runtime>(
     message: String,
     kind: Option<MessageDialogKind>,
     ok_button_label: Option<String>,
-) -> Result<bool> {
-    Ok(message_dialog(
-        window,
-        dialog,
-        title,
-        message,
-        kind,
-        if let Some(ok_button_label) = ok_button_label {
-            MessageDialogButtons::OkCustom(ok_button_label)
-        } else {
-            MessageDialogButtons::Ok
-        },
-    ))
+    buttons: Option<MessageDialogButtons>,
+) -> Result<MessageDialogResult> {
+    let buttons = buttons.unwrap_or(if let Some(ok_button_label) = ok_button_label {
+        MessageDialogButtons::OkCustom(ok_button_label)
+    } else {
+        MessageDialogButtons::Ok
+    });
+
+    Ok(message_dialog(window, dialog, title, message, kind, buttons).blocking_show_with_result())
 }
 
 #[command]
@@ -302,7 +298,7 @@ pub(crate) async fn ask<R: Runtime>(
     yes_button_label: Option<String>,
     no_button_label: Option<String>,
 ) -> Result<bool> {
-    Ok(message_dialog(
+    let dialog = message_dialog(
         window,
         dialog,
         title,
@@ -318,7 +314,9 @@ pub(crate) async fn ask<R: Runtime>(
         } else {
             MessageDialogButtons::YesNo
         },
-    ))
+    );
+
+    Ok(dialog.blocking_show())
 }
 
 #[command]
@@ -331,7 +329,7 @@ pub(crate) async fn confirm<R: Runtime>(
     ok_button_label: Option<String>,
     cancel_button_label: Option<String>,
 ) -> Result<bool> {
-    Ok(message_dialog(
+    let dialog = message_dialog(
         window,
         dialog,
         title,
@@ -347,5 +345,7 @@ pub(crate) async fn confirm<R: Runtime>(
         } else {
             MessageDialogButtons::OkCancel
         },
-    ))
+    );
+
+    Ok(dialog.blocking_show())
 }

plugins/dialog/src/desktop.rs

@@ -13,7 +13,7 @@ use rfd::{AsyncFileDialog, AsyncMessageDialog};
 use serde::de::DeserializeOwned;
 use tauri::{plugin::PluginApi, AppHandle, Runtime};
 
-use crate::{models::*, FileDialogBuilder, FilePath, MessageDialogBuilder, OK};
+use crate::{models::*, FileDialogBuilder, FilePath, MessageDialogBuilder};
 
 pub fn init<R: Runtime, C: DeserializeOwned>(
     app: &AppHandle<R>,
@@ -115,6 +115,10 @@ impl From<MessageDialogButtons> for rfd::MessageButtons {
             MessageDialogButtons::YesNo => Self::YesNo,
             MessageDialogButtons::OkCustom(ok) => Self::OkCustom(ok),
             MessageDialogButtons::OkCancelCustom(ok, cancel) => Self::OkCancelCustom(ok, cancel),
+            MessageDialogButtons::YesNoCancel => Self::YesNoCancel,
+            MessageDialogButtons::YesNoCancelCustom(yes, no, cancel) => {
+                Self::YesNoCancelCustom(yes, no, cancel)
+            }
         }
     }
 }
@@ -208,28 +212,46 @@ pub fn save_file<R: Runtime, F: FnOnce(Option<FilePath>) + Send + 'static>(
 }
 
 /// Shows a message dialog
-pub fn show_message_dialog<R: Runtime, F: FnOnce(bool) + Send + 'static>(
+pub fn show_message_dialog<R: Runtime, F: FnOnce(MessageDialogResult) + Send + 'static>(
     dialog: MessageDialogBuilder<R>,
-    f: F,
+    callback: F,
 ) {
-    use rfd::MessageDialogResult;
-
-    let ok_label = match &dialog.buttons {
-        MessageDialogButtons::OkCustom(ok) => Some(ok.clone()),
-        MessageDialogButtons::OkCancelCustom(ok, _) => Some(ok.clone()),
-        _ => None,
-    };
-    let f = move |res| {
-        f(match res {
-            MessageDialogResult::Ok | MessageDialogResult::Yes => true,
-            MessageDialogResult::Custom(s) => ok_label.map_or(s == OK, |ok_label| ok_label == s),
-            _ => false,
-        });
-    };
+    let f = move |res: rfd::MessageDialogResult| callback(res.into());
 
     let handle = dialog.dialog.app_handle().to_owned();
     let _ = handle.run_on_main_thread(move || {
+        let buttons = dialog.buttons.clone();
         let dialog = AsyncMessageDialog::from(dialog).show();
-        std::thread::spawn(move || f(tauri::async_runtime::block_on(dialog)));
+        std::thread::spawn(move || {
+            let result = tauri::async_runtime::block_on(dialog);
+            // on Linux rfd does not return rfd::MessageDialogResult::Custom, so we must map manually
+            let result = match (result, buttons) {
+                (rfd::MessageDialogResult::Ok, MessageDialogButtons::OkCustom(s)) => {
+                    rfd::MessageDialogResult::Custom(s)
+                }
+                (
+                    rfd::MessageDialogResult::Ok,
+                    MessageDialogButtons::OkCancelCustom(ok, _cancel),
+                ) => rfd::MessageDialogResult::Custom(ok),
+                (
+                    rfd::MessageDialogResult::Cancel,
+                    MessageDialogButtons::OkCancelCustom(_ok, cancel),
+                ) => rfd::MessageDialogResult::Custom(cancel),
+                (
+                    rfd::MessageDialogResult::Yes,
+                    MessageDialogButtons::YesNoCancelCustom(yes, _no, _cancel),
+                ) => rfd::MessageDialogResult::Custom(yes),
+                (
+                    rfd::MessageDialogResult::No,
+                    MessageDialogButtons::YesNoCancelCustom(_yes, no, _cancel),
+                ) => rfd::MessageDialogResult::Custom(no),
+                (
+                    rfd::MessageDialogResult::Cancel,
+                    MessageDialogButtons::YesNoCancelCustom(_yes, _no, cancel),
+                ) => rfd::MessageDialogResult::Custom(cancel),
+                (result, _) => result,
+            };
+            f(result);
+        });
     });
 }

plugins/dialog/src/lib.rs

@@ -216,6 +216,7 @@ pub(crate) struct MessageDialogPayload<'a> {
     message: &'a String,
     kind: &'a MessageDialogKind,
     ok_button_label: Option<&'a str>,
+    no_button_label: Option<&'a str>,
     cancel_button_label: Option<&'a str>,
 }
 
@@ -238,13 +239,17 @@ impl<R: Runtime> MessageDialogBuilder<R> {
 
     #[cfg(mobile)]
     pub(crate) fn payload(&self) -> MessageDialogPayload<'_> {
-        let (ok_button_label, cancel_button_label) = match &self.buttons {
-            MessageDialogButtons::Ok => (Some(OK), None),
-            MessageDialogButtons::OkCancel => (Some(OK), Some(CANCEL)),
-            MessageDialogButtons::YesNo => (Some(YES), Some(NO)),
-            MessageDialogButtons::OkCustom(ok) => (Some(ok.as_str()), Some(CANCEL)),
+        let (ok_button_label, no_button_label, cancel_button_label) = match &self.buttons {
+            MessageDialogButtons::Ok => (Some(OK), None, None),
+            MessageDialogButtons::OkCancel => (Some(OK), None, Some(CANCEL)),
+            MessageDialogButtons::YesNo => (Some(YES), Some(NO), None),
+            MessageDialogButtons::YesNoCancel => (Some(YES), Some(NO), Some(CANCEL)),
+            MessageDialogButtons::OkCustom(ok) => (Some(ok.as_str()), None, None),
             MessageDialogButtons::OkCancelCustom(ok, cancel) => {
-                (Some(ok.as_str()), Some(cancel.as_str()))
+                (Some(ok.as_str()), None, Some(cancel.as_str()))
+            }
+            MessageDialogButtons::YesNoCancelCustom(yes, no, cancel) => {
+                (Some(yes.as_str()), Some(no.as_str()), Some(cancel.as_str()))
             }
         };
         MessageDialogPayload {
@@ -252,6 +257,7 @@ impl<R: Runtime> MessageDialogBuilder<R> {
             message: &self.message,
             kind: &self.kind,
             ok_button_label,
+            no_button_label,
             cancel_button_label,
         }
     }
@@ -295,16 +301,55 @@ impl<R: Runtime> MessageDialogBuilder<R> {
     }
 
     /// Shows a message dialog
+    ///
+    /// Returns `true` if the user pressed the OK/Yes button,
     pub fn show<F: FnOnce(bool) + Send + 'static>(self, f: F) {
+        let ok_label = match &self.buttons {
+            MessageDialogButtons::OkCustom(ok) => Some(ok.clone()),
+            MessageDialogButtons::OkCancelCustom(ok, _) => Some(ok.clone()),
+            MessageDialogButtons::YesNoCancelCustom(yes, _, _) => Some(yes.clone()),
+            _ => None,
+        };
+
+        show_message_dialog(self, move |res| {
+            let sucess = match res {
+                MessageDialogResult::Ok | MessageDialogResult::Yes => true,
+                MessageDialogResult::Custom(s) => {
+                    ok_label.map_or(s == OK, |ok_label| ok_label == s)
+                }
+                _ => false,
+            };
+
+            f(sucess)
+        })
+    }
+
+    /// Shows a message dialog and returns the button that was pressed.
+    ///
+    /// Returns a [`MessageDialogResult`] enum that indicates which button was pressed.
+    pub fn show_with_result<F: FnOnce(MessageDialogResult) + Send + 'static>(self, f: F) {
         show_message_dialog(self, f)
     }
 
     /// Shows a message dialog.
+    ///
+    /// Returns `true` if the user pressed the OK/Yes button,
+    ///
     /// This is a blocking operation,
     /// and should *NOT* be used when running on the main thread context.
     pub fn blocking_show(self) -> bool {
         blocking_fn!(self, show)
     }
+
+    /// Shows a message dialog and returns the button that was pressed.
+    ///
+    /// Returns a [`MessageDialogResult`] enum that indicates which button was pressed.
+    ///
+    /// This is a blocking operation,
+    /// and should *NOT* be used when running on the main thread context.
+    pub fn blocking_show_with_result(self) -> MessageDialogResult {
+        blocking_fn!(self, show_with_result)
+    }
 }
 #[derive(Debug, Serialize)]
 pub(crate) struct Filter {

plugins/dialog/src/mobile.rs

@@ -8,7 +8,7 @@ use tauri::{
     AppHandle, Runtime,
 };
 
-use crate::{FileDialogBuilder, FilePath, MessageDialogBuilder};
+use crate::{FileDialogBuilder, FilePath, MessageDialogBuilder, MessageDialogResult};
 
 #[cfg(target_os = "android")]
 const PLUGIN_IDENTIFIER: &str = "app.tauri.dialog";
@@ -107,13 +107,11 @@ pub fn save_file<R: Runtime, F: FnOnce(Option<FilePath>) + Send + 'static>(
 
 #[derive(Debug, Deserialize)]
 struct ShowMessageDialogResponse {
-    #[allow(dead_code)]
-    cancelled: bool,
-    value: bool,
+    value: String,
 }
 
 /// Shows a message dialog
-pub fn show_message_dialog<R: Runtime, F: FnOnce(bool) + Send + 'static>(
+pub fn show_message_dialog<R: Runtime, F: FnOnce(MessageDialogResult) + Send + 'static>(
     dialog: MessageDialogBuilder<R>,
     f: F,
 ) {
@@ -122,6 +120,8 @@ pub fn show_message_dialog<R: Runtime, F: FnOnce(bool) + Send + 'static>(
             .dialog
             .0
             .run_mobile_plugin::<ShowMessageDialogResponse>("showMessageDialog", dialog.payload());
-        f(res.map(|r| r.value).unwrap_or_default())
+
+        let res = res.map(|res| res.value.into());
+        f(res.unwrap_or_default())
     });
 }

plugins/dialog/src/models.rs

@@ -52,7 +52,7 @@ impl Serialize for MessageDialogKind {
 
 /// Set of button that will be displayed on the dialog
 #[non_exhaustive]
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub enum MessageDialogButtons {
     #[default]
     /// A single `Ok` button with OS default dialog text
@@ -61,8 +61,49 @@ pub enum MessageDialogButtons {
     OkCancel,
     /// 2 buttons `Yes` and `No` with OS default dialog texts
     YesNo,
+    /// 3 buttons `Yes`, `No` and `Cancel` with OS default dialog texts
+    YesNoCancel,
     /// A single `Ok` button with custom text
     OkCustom(String),
     /// 2 buttons `Ok` and `Cancel` with custom texts
     OkCancelCustom(String, String),
+    /// 3 buttons `Yes`, `No` and `Cancel` with custom texts
+    YesNoCancelCustom(String, String, String),
+}
+
+/// Result of a message dialog
+#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
+pub enum MessageDialogResult {
+    Yes,
+    No,
+    Ok,
+    #[default]
+    Cancel,
+    #[serde(untagged)]
+    Custom(String),
+}
+
+#[cfg(desktop)]
+impl From<rfd::MessageDialogResult> for MessageDialogResult {
+    fn from(result: rfd::MessageDialogResult) -> Self {
+        match result {
+            rfd::MessageDialogResult::Yes => Self::Yes,
+            rfd::MessageDialogResult::No => Self::No,
+            rfd::MessageDialogResult::Ok => Self::Ok,
+            rfd::MessageDialogResult::Cancel => Self::Cancel,
+            rfd::MessageDialogResult::Custom(s) => Self::Custom(s),
+        }
+    }
+}
+
+impl From<String> for MessageDialogResult {
+    fn from(value: String) -> Self {
+        match value.as_str() {
+            "Yes" => Self::Yes,
+            "No" => Self::No,
+            "Ok" => Self::Ok,
+            "Cancel" => Self::Cancel,
+            _ => Self::Custom(value),
+        }
+    }
 }