Merge pull request #433 from sdroege/single-boxed-signals

Update for signals using the concrete closure type instead of double-…

Author: sdroege

src/object.rs

@@ -1010,22 +1010,22 @@ impl<T: ObjectType> ObjectExt for T {
     unsafe fn connect_notify_unsafe<'a, P: Into<Option<&'a str>>, F: Fn(&Self, &::ParamSpec)>(&self, name: P, f: F) -> SignalHandlerId {
         use std::mem::transmute;
 
-        unsafe extern "C" fn notify_trampoline<P>(this: *mut gobject_ffi::GObject, param_spec: *mut gobject_ffi::GParamSpec, f: glib_ffi::gpointer)
+        unsafe extern "C" fn notify_trampoline<P, F: Fn(&P, &::ParamSpec)>(this: *mut gobject_ffi::GObject, param_spec: *mut gobject_ffi::GParamSpec, f: glib_ffi::gpointer)
         where P: ObjectType {
-            let f: &&(Fn(&P, &::ParamSpec) + 'static) = transmute(f);
+            let f: &F = transmute(f);
             f(&Object::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(param_spec))
         }
 
         let name = name.into();
         let signal_name = if let Some(name) = name {
-            format!("notify::{}", name)
+            format!("notify::{}\0", name)
         } else {
-            "notify".into()
+            "notify\0".into()
         };
 
-        let f: Box<Box<Fn(&Self, &::ParamSpec)>> = Box::new(Box::new(f));
-        ::signal::connect(self.as_object_ref().to_glib_none().0, &signal_name,
-            transmute(notify_trampoline::<Self> as usize), Box::into_raw(f) as *mut _)
+        let f: Box<F> = Box::new(f);
+        ::signal::connect_raw(self.as_object_ref().to_glib_none().0, signal_name.as_ptr() as *const _,
+            Some(mem::transmute(notify_trampoline::<Self, F> as usize)), Box::into_raw(f))
     }
 
     fn notify<'a, N: Into<&'a str>>(&self, property_name: N) {

src/signal.rs

@@ -7,9 +7,10 @@
 use libc::{c_char, c_void, c_ulong};
 
 use gobject_ffi::{self, GCallback};
-use ffi::gboolean;
+use ffi::{gboolean, gpointer};
 use object::ObjectType;
 use translate::{from_glib, FromGlib, ToGlib, ToGlibPtr};
+use std::mem;
 
 /// The id of a signal that is returned by `connect`.
 #[derive(Debug, Eq, PartialEq)]
@@ -48,15 +49,12 @@ impl ToGlib for Inhibit {
     }
 }
 
-pub unsafe fn connect(receiver: *mut gobject_ffi::GObject, signal_name: &str, trampoline: GCallback,
-                      closure: *mut Box<Fn() + 'static>) -> SignalHandlerId {
-    connect_raw(receiver, signal_name.to_glib_none().0, trampoline, closure)
-}
-
-pub unsafe fn connect_raw(receiver: *mut gobject_ffi::GObject, signal_name: *const c_char, trampoline: GCallback,
-                      closure: *mut Box<Fn() + 'static>) -> SignalHandlerId {
+pub unsafe fn connect_raw<F>(receiver: *mut gobject_ffi::GObject, signal_name: *const c_char, trampoline: GCallback,
+                      closure: *mut F) -> SignalHandlerId {
+    assert_eq!(mem::size_of::<*mut F>(), mem::size_of::<gpointer>());
+    assert!(trampoline.is_some());
     let handle = gobject_ffi::g_signal_connect_data(receiver, signal_name,
-        trampoline, closure as *mut _, Some(destroy_closure), 0);
+        trampoline, closure as *mut _, Some(destroy_closure::<F>), 0);
     assert!(handle > 0);
     from_glib(handle)
 }
@@ -86,7 +84,7 @@ pub fn signal_stop_emission_by_name<T: ObjectType>(instance: &T, signal_name: &s
     }
 }
 
-unsafe extern "C" fn destroy_closure(ptr: *mut c_void, _: *mut gobject_ffi::GClosure) {
+unsafe extern "C" fn destroy_closure<F>(ptr: *mut c_void, _: *mut gobject_ffi::GClosure) {
     // destroy
-    Box::<Box<Fn()>>::from_raw(ptr as *mut _);
+    Box::<F>::from_raw(ptr as *mut _);
 }