How can I get my own GTK callback data when using rust-gnome?
... or how can I subclass the gtk :: Widget?
I have the following dependencies in mine Cargo.toml
:
[dependencies]
num = "*"
gtk = "*"
cairo-rs = "*"
gdk = "*"
time = "*"
I want to create my own kind of widgets (for rendering fractals). I have:
extern crate cairo;
extern crate gtk;
use cairo::Context;
use gtk::signal::Inhibit;
use gtk::signal::WidgetSignals;
use gtk::traits::ContainerTrait;
use gtk::traits::WidgetTrait;
struct MyWidget {
widget: gtk::DrawingArea,
foo: u32,
}
impl MyWidget {
fn new() -> MyWidget {
let result = MyWidget {
widget: gtk::DrawingArea::new().unwrap(),
foo: 17
};
result.widget.connect_draw(move |_w, c| {
// Cannot do: result.redraw(c)
Inhibit(true)
});
result
}
fn modify(&mut self, x: u32) {
self.foo += x;
self.widget.queue_draw();
}
fn redraw(&self, _ : Context) -> Inhibit {
println!("Should redraw for {}", self.foo);
Inhibit(true)
}
}
fn main() {
gtk::init().ok();
let window = gtk::Window::new(gtk::WindowType::TopLevel).unwrap();
let area = MyWidget::new();
window.add(&area.widget);
window.connect_delete_event(|_, _| {
gtk::main_quit();
Inhibit(true)
});
window.connect_key_release_event(move |_w, _event| {
// Cannot do: area.modify(3);
Inhibit(true)
});
window.connect_button_release_event(move |_w, _event| {
// Cannot do: area.modify(17);
Inhibit(true)
});
window.show_all();
gtk::main();
}
But when called redraw
, w is of course, gtk::DrawingArea
not mine FractalWidget
. I was working with a call connect_draw
with a closure but was unable to use result
in it (I tried to Box
get the result and move
insert it into a lambda, but I'm new to this, so I probably haven't tried it somehow).
So my actual question is, is there a way to send more data to the redraw-gnome redraw method (and other similar callbacks), or is there a way to extend the widget structure to contain my own data?
source to share
Ok, here's the code that actually works, mostly using Arc<Mutex<MyWidget>>
insead of plain MyWidget
. This still seems rather clunky as I need an explicit clone before going into the closure and blocking the mutex inside it, but this is probably good stuff (even if there is only one thread for gtk events). Perhaps the verbosity can be corrected by a macro ...
extern crate cairo;
extern crate gtk;
use cairo::Context;
use gtk::signal::Inhibit;
use gtk::signal::WidgetSignals;
use gtk::traits::ContainerTrait;
use gtk::traits::WidgetTrait;
use std::sync::{Arc,Mutex};
struct MyWidget {
widget: gtk::DrawingArea,
foo: u32,
}
impl MyWidget {
fn new() -> Arc<Mutex<MyWidget>> {
let result = Arc::new(Mutex::new(MyWidget {
widget: gtk::DrawingArea::new().unwrap(),
foo: 17
}));
let r2 = result.clone();
result.lock().unwrap().widget.connect_draw(move |_w, c| {
r2.lock().unwrap().redraw(c)
});
result
}
fn modify(&mut self, x: u32) {
self.foo += x;
self.widget.queue_draw();
}
fn redraw(&self, _ : Context) -> Inhibit {
println!("Should redraw for {}", self.foo);
Inhibit(true)
}
}
fn main() {
gtk::init().ok();
let window = gtk::Window::new(gtk::WindowType::TopLevel).unwrap();
let area = MyWidget::new();
window.add(&area.lock().unwrap().widget);
window.connect_delete_event(|_, _| {
gtk::main_quit();
Inhibit(true)
});
let a1 = area.clone();
window.connect_key_release_event(move |_w, _event| {
a1.lock().unwrap().modify(3);
Inhibit(true)
});
let a2 = area.clone();
window.connect_button_release_event(move |_w, _event| {
a2.lock().unwrap().modify(17);
Inhibit(true)
});
window.show_all();
gtk::main();
}
I'll wait at least a few days noting the correct answer in case anyone has a better one.
source to share