Merge pull request #268 from sophie-h/run-future

Add Dialog::run_future()

Author: sdroege

examples/src/bin/dialog.rs

@@ -0,0 +1,69 @@
+//! # Dialog Example
+//!
+//! Example of how to obtain the response to a dialog as a future
+
+use gtk::glib::clone;
+use gtk::prelude::*;
+
+use std::env::args;
+use std::rc::Rc;
+
+async fn dialog<W: IsA<gtk::Window>>(window: Rc<W>) {
+    let question_dialog = gtk::MessageDialogBuilder::new()
+        .transient_for(&*window)
+        .modal(true)
+        .buttons(gtk::ButtonsType::OkCancel)
+        .text("What is your answer?")
+        .build();
+
+    let answer = question_dialog.run_future().await;
+    question_dialog.close();
+    question_dialog.hide();
+
+    let info_dialog = gtk::MessageDialogBuilder::new()
+        .transient_for(&*window)
+        .modal(true)
+        .buttons(gtk::ButtonsType::Close)
+        .text("You answered")
+        .secondary_text(&format!("Your answer: {:?}", answer))
+        .build();
+
+    info_dialog.run_future().await;
+    info_dialog.close();
+}
+
+fn build_ui(application: &gtk::Application) {
+    let button = gtk::ButtonBuilder::new()
+        .label("Open Dialog")
+        .halign(gtk::Align::Center)
+        .valign(gtk::Align::Center)
+        .visible(true)
+        .build();
+
+    let window = Rc::new(
+        gtk::ApplicationWindowBuilder::new()
+            .application(application)
+            .title("Dialog Example")
+            .default_width(350)
+            .default_height(70)
+            .child(&button)
+            .visible(true)
+            .build(),
+    );
+
+    button.connect_clicked(clone!(@strong window =>
+        move |_| {
+            gtk::glib::MainContext::default().spawn_local(dialog(Rc::clone(&window)));
+        }
+    ));
+}
+
+fn main() {
+    let application = gtk::ApplicationBuilder::new()
+        .application_id("com.github.gtk-rs.examples.dialog")
+        .build();
+
+    application.connect_activate(build_ui);
+
+    application.run(&args().collect::<Vec<_>>());
+}

gtk/Cargo.toml

@@ -54,6 +54,7 @@ git = "https://github.com/gtk-rs/lgpl-docs"
 libc = "0.2"
 bitflags = "1.0"
 field-offset = "0.3"
+futures-channel = "0.3"
 once_cell = "1.0"
 atk = { path = "../atk" }
 ffi = { package = "gtk-sys", path = "sys" }

gtk/src/dialog.rs

@@ -5,10 +5,15 @@ use crate::Dialog;
 use crate::DialogFlags;
 use crate::ResponseType;
 use crate::Widget;
+use crate::WidgetExt;
 use crate::Window;
 use glib::object::Cast;
 use glib::translate::*;
 use glib::IsA;
+use glib::ObjectExt;
+use std::cell::Cell;
+use std::future::Future;
+use std::pin::Pin;
 use std::ptr;
 
 impl Dialog {
@@ -38,13 +43,58 @@ impl Dialog {
 pub trait DialogExtManual: 'static {
     #[doc(alias = "gtk_dialog_add_buttons")]
     fn add_buttons(&self, buttons: &[(&str, ResponseType)]);
+
+    // rustdoc-stripper-ignore-next
+    /// Shows the dialog and returns a `Future` that resolves to the
+    /// `ResponseType` on response.
+    ///
+    /// ```no_run
+    /// use gtk::prelude::*;
+    ///
+    /// # async fn run() {
+    /// let dialog = gtk::MessageDialogBuilder::new()
+    ///    .buttons(gtk::ButtonsType::OkCancel)
+    ///    .text("What is your answer?")
+    ///    .build();
+    ///
+    /// let answer = dialog.run_future().await;
+    /// dialog.close();
+    /// println!("Answer: {:?}", answer);
+    /// # }
+    /// ```
+    fn run_future<'a>(&'a self) -> Pin<Box<dyn Future<Output = ResponseType> + 'a>>;
 }
 
-impl<O: IsA<Dialog>> DialogExtManual for O {
+impl<O: IsA<Dialog> + IsA<Widget>> DialogExtManual for O {
     fn add_buttons(&self, buttons: &[(&str, ResponseType)]) {
         for &(text, id) in buttons {
             //FIXME: self.add_button don't work on 1.8
             O::add_button(self, text, id);
         }
     }
+
+    fn run_future<'a>(&'a self) -> Pin<Box<dyn Future<Output = ResponseType> + 'a>> {
+        Box::pin(async move {
+            let (sender, receiver) = futures_channel::oneshot::channel();
+
+            let sender = Cell::new(Some(sender));
+
+            let response_handler = self.connect_response(move |_, response_type| {
+                if let Some(m) = sender.replace(None) {
+                    let _result = m.send(response_type);
+                }
+            });
+
+            self.show();
+
+            if let Ok(response) = receiver.await {
+                if response != ResponseType::DeleteEvent {
+                    self.disconnect(response_handler);
+                }
+                response
+            } else {
+                ResponseType::None
+            }
+        })
+    }
 }