在 Rust 中处理 GTK+ 事件的替代方法

目前，我管理 GTK+ 活动Rc and RefCell如下例所示：

extern crate gtk;

use std::cell::RefCell;
use std::rc::Rc;

use gtk::{Button, ButtonExt, ContainerExt, Inhibit, Label, WidgetExt, Window, WindowType};
use gtk::Orientation::Vertical;

struct Model {
    count: i32,
}

fn main() {
    gtk::init().unwrap();

    let window = Window::new(WindowType::Toplevel);

    let model = Rc::new(RefCell::new(Model { count: 0 }));

    let vbox = gtk::Box::new(Vertical, 0);
    window.add(&vbox);

    let label = Label::new(Some("0"));
    vbox.add(&label);

    let button = Button::new_with_label("Increment");
    vbox.add(&button);
    window.show_all();

    window.connect_delete_event(|_, _| {
        gtk::main_quit();
        Inhibit(false)
    });

    {
        let model = model.clone();
        button.connect_clicked(move |_| {
            {
                (*model.borrow_mut()).count += 1;
            }
            label.set_text(&format!("{}", (*model.borrow()).count));
        });
    }

    gtk::main();
}

我对这段代码的主要问题是所需的样板，因为RefCells.

另外，我觉得这是不好的做法，可能会导致恐慌（这不是我的主要问题，所以不建议使用Mutex因为在某些示例中，这可能会导致死锁）。

所以我想我可以用类似于 Elm 的方式处理事件：用一个函数接收可以更新模型的信号。 但是，我无法在 Rust 中实现这一点。 这是一个尝试：

extern crate gtk;

use std::cell::RefCell;
use std::collections::VecDeque;
use std::rc::Rc;

use gtk::{Button, ButtonExt, ContainerExt, Inhibit, Label, WidgetExt, WindowType};
use gtk::Orientation::Vertical;

use Message::Increment;

enum Message {
    Increment,
}

struct Window {
    label: Label,
    model: Model,
    queue: Rc<RefCell<VecDeque<Message>>>,
    view: gtk::Window,
}

impl Window {
    fn new() -> Self {
        let window = gtk::Window::new(WindowType::Toplevel);

        let vbox = gtk::Box::new(Vertical, 0);
        window.add(&vbox);

        let label = Label::new(Some("0"));
        vbox.add(&label);

        let button = Button::new_with_label("Increment");
        vbox.add(&button);
        window.show_all();

        window.connect_delete_event(|_, _| {
            gtk::main_quit();
            Inhibit(false)
        });

        let queue = Rc::new(RefCell::new(VecDeque::new()));

        {
            let queue = queue.clone();
            button.connect_clicked(move |_| {
                (*queue.borrow_mut()).push_back(Increment);
            });
        }

        Window {
            label: label,
            queue: queue,
            model: Model { count: 0 },
            view: window,
        }
    }

    // How to call this method when a message is received?
    fn update(&mut self, message: Message) {
        match message {
            Increment => {
                self.model.count += 1;
                self.label.set_text(&format!("{}", self.model.count));
            },
        }
    }
}

struct Model {
    count: i32,
}

fn main() {
    gtk::init().unwrap();

    let window = Window::new();

    gtk::main();
}

我怎样才能打电话给update()消息时的方法queue更新了吗？

这是一个可行的方法吗？

如果没有，您是否知道可以解决此问题的任何替代方案？

也许一些基于的解决方案future可以使用板条箱吗​​？ 在这种情况下，我如何管理两个主循环（gtk+ 和tokio one).

或者使用渠道的解决方案？

我找到了这个问题的解决方案here.

这是我通过我的例子取得的成果：

extern crate gtk;

use gtk::{Button, ButtonExt, ContainerExt, Inhibit, Label, WidgetExt, WindowType};
use gtk::Orientation::Vertical;

use Message::Increment;

macro_rules! connect {
    ($source:ident :: $event:ident, $target:ident :: $message:expr) => {
        let target = &mut *$target as *mut _;
        $source.$event(move |_| {
            let target: &mut Window = unsafe { &mut *target };
            target.update($message);
        });
    };
}

enum Message {
    Increment,
}

struct Window {
    label: Label,
    model: Model,
    view: gtk::Window,
}

impl Window {
    fn new() -> Box<Self> {
        let window = gtk::Window::new(WindowType::Toplevel);

        let vbox = gtk::Box::new(Vertical, 0);
        window.add(&vbox);

        let label = Label::new(Some("0"));
        vbox.add(&label);

        let button = Button::new_with_label("Increment");
        vbox.add(&button);
        window.show_all();

        window.connect_delete_event(|_, _| {
            gtk::main_quit();
            Inhibit(false)
        });

        let mut window = Box::new(Window {
            label: label,
            model: Model { count: 0 },
            view: window,
        });

        connect!(button::connect_clicked, window::Increment);

        window
    }

    fn update(&mut self, message: Message) {
        match message {
            Increment => {
                self.model.count += 1;
                self.label.set_text(&format!("{}", self.model.count));
            },
        }
    }
}

struct Model {
    count: i32,
}

fn main() {
    gtk::init().unwrap();

    let _window = Window::new();

    gtk::main();
}

你认为这样使用unsafe会导致段错误吗？ 例如，如果button可能会比window, the window释放后可以使用吧？ 有没有办法围绕这个构建一个安全的包装器？

从美学角度来看，有没有办法实现这一点：

connect!(button::clicked, window::Increment);