nameable: port to the latest gtk-rs-core GInterface changes

Author: Paolo Borelli

src/nameable/imp.rs

@@ -3,61 +3,65 @@ use glib::translate::*;
 
 use std::ffi::c_char;
 
-// Instance struct
-pub struct Nameable;
+// Type implementing ObjectInterface. Use a uninhabited enum to make the type uninstantiatable.
+pub enum Nameable {}
 
-// Interface struct aka "vtable"
-//
-// Here we would store virtual methods and similar
-#[derive(Clone, Copy)]
-#[repr(C)]
-pub struct NameableInterface {
-    pub parent_iface: glib::gobject_ffi::GTypeInterface,
-    pub get_name: Option<unsafe extern "C" fn(*mut Nameable) -> *mut c_char>,
+// Default implementation of the interface methods (note: these are optional)
+impl Nameable {
+    fn name_default() -> Option<String> {
+        None
+    }
 }
 
 #[glib::object_interface]
-unsafe impl ObjectInterface for NameableInterface {
+impl ObjectInterface for Nameable {
     const NAME: &'static str = "ExNameable";
+    type Instance = ffi::ExNameable;
+    type Interface = ffi::ExNameableInterface;
     type Prerequisites = (glib::Object,);
 
     // Interface struct initialization, called from GObject
-    fn interface_init(&mut self) {
+    fn interface_init(iface: &mut Self::Interface) {
+        // Optionally set the default implementation
+        iface.get_name = Some(get_name_default_trampoline);
+
         // TODO: Could also add signals here, and interface properties via
         // g_object_interface_install_property()
-        self.get_name = Some(get_name_default_trampoline);
     }
 }
 
-//
-// Virtual method implementations / trampolines to safe implementations
-//
-// The default implementations are optional!
-//
-unsafe extern "C" fn get_name_default_trampoline(this: *mut Nameable) -> *mut c_char {
-    NameableInterface::name_default(&from_glib_borrow(this)).to_glib_full()
-}
-
-//
-// Safe implementations. These take the wrapper type, and not &Self, as first argument
-//
-impl NameableInterface {
-    fn name_default(_this: &super::Nameable) -> Option<String> {
-        None
-    }
+// trampoline to safe implementation
+unsafe extern "C" fn get_name_default_trampoline(_this: *mut ffi::ExNameable) -> *mut c_char {
+    Nameable::name_default().to_glib_full()
 }
 
 pub(crate) mod ffi {
     use super::*;
+    use glib::object::ObjectExt;
     use std::ffi::c_char;
     use std::ptr;
 
-    pub type ExNameable = super::Nameable;
-    pub type ExNameableInterface = super::NameableInterface;
+    // Instance struct, to be used as pointer to "self" in ffi methods
+    #[repr(C)]
+    pub struct ExNameable(std::ffi::c_void);
+
+    // Interface struct aka "vtable"
+    //
+    // Here we would store virtual methods and similar
+    #[derive(Clone, Copy)]
+    #[repr(C)]
+    pub struct ExNameableInterface {
+        pub parent_iface: glib::gobject_ffi::GTypeInterface,
+        pub get_name: Option<unsafe extern "C" fn(*mut ExNameable) -> *mut c_char>,
+    }
+
+    unsafe impl InterfaceStruct for ExNameableInterface {
+        type Type = super::Nameable;
+    }
 
     #[no_mangle]
     pub extern "C" fn ex_nameable_get_type() -> glib::ffi::GType {
-        <super::NameableInterface as ObjectInterfaceType>::type_().into_glib()
+        <super::Nameable as ObjectInterfaceType>::type_().into_glib()
     }
 
     // Virtual method callers
@@ -66,8 +70,12 @@ pub(crate) mod ffi {
     /// Must be a Nameable interface.
     #[no_mangle]
     pub unsafe extern "C" fn ex_nameable_get_name(this: *mut ExNameable) -> *mut c_char {
-        let wrapper = super::super::from_glib_borrow::<_, super::super::Nameable>(this);
-        let iface = <super::NameableInterface as ObjectInterfaceExt>::from_obj(&*wrapper);
-        iface.get_name.map(|f| f(this)).unwrap_or(ptr::null_mut())
+        let wrapper = from_glib_borrow::<_, super::super::Nameable>(this);
+        let iface = wrapper.interface::<super::super::Nameable>().unwrap();
+        iface
+            .as_ref()
+            .get_name
+            .map(|f| f(this))
+            .unwrap_or(ptr::null_mut())
     }
 }

src/nameable/mod.rs

@@ -8,28 +8,56 @@ mod ffi;
 
 use glib::{prelude::*, subclass::prelude::*, translate::*};
 
+#[cfg(feature = "bindings")]
 glib::wrapper! {
-    pub struct Nameable(Interface<ffi::ExNameable, ffi::ExNameableInterface>);
+    pub struct Nameable(Interface<ffi::Nameable, ffi::Interface>);
 
     match fn {
         type_ => || ffi::ex_nameable_get_type(),
     }
 }
 
-pub trait NameableExt {
-    fn name(&self) -> Option<String>;
+#[cfg(not(feature = "bindings"))]
+glib::wrapper! {
+    pub struct Nameable(ObjectInterface<imp::Nameable>);
 }
 
-impl<O: IsA<Nameable>> NameableExt for O {
+pub trait NameableExt: IsA<Nameable> {
     fn name(&self) -> Option<String> {
-        unsafe { from_glib_full(ffi::ex_nameable_get_name(self.as_ref().to_glib_none().0)) }
+        let iface = self.interface::<Nameable>().unwrap();
+        unsafe {
+            from_glib_full(((iface.as_ref()).get_name.unwrap())(
+                self.upcast_ref::<Nameable>().to_glib_none().0,
+            ))
+        }
     }
 }
 
+impl<O: IsA<Nameable>> NameableExt for O {}
+
 pub trait NameableImpl: ObjectImpl {
-    fn name(&self) -> Option<String>;
+    fn name(&self) -> Option<String> {
+        self.parent_name()
+    }
 }
 
+pub trait NameableImplExt: NameableImpl {
+    fn parent_name(&self) -> Option<String> {
+        let data = Self::type_data();
+        let parent_iface = unsafe {
+            &*(data.as_ref().parent_interface::<Nameable>() as *const ffi::ExNameableInterface)
+        };
+
+        unsafe {
+            from_glib_full((parent_iface.get_name.unwrap())(
+                self.obj().unsafe_cast_ref::<Nameable>().to_glib_none().0,
+            ))
+        }
+    }
+}
+
+impl<T: NameableImpl> NameableImplExt for T {}
+
 unsafe impl<T: ObjectSubclass + NameableImpl> IsImplementable<T> for Nameable {
     fn interface_init(iface: &mut glib::Interface<Self>) {
         let iface = iface.as_mut();