examples: don't expose C API

Author: Cogitri

examples/virtual_methods/base_button/imp.rs

@@ -1,26 +1,25 @@
 use super::BaseButtonExt;
 use gtk::{
     gio,
-    glib::{self, translate::from_glib_borrow, Error},
+    glib::{self, Error},
     prelude::*,
     subclass::prelude::*,
 };
 use std::{future::Future, pin::Pin};
 
-pub type BaseButtonInstance = <BaseButton as super::ObjectSubclass>::Instance;
+pub type BaseButtonInstance = super::BaseButton;
 pub type PinnedFuture = Pin<Box<dyn Future<Output = Result<(), Error>> + 'static>>;
 
 /// GObject glue code for our BaseButtonClass which holds the function pointers to our virtual functions.
 #[repr(C)]
 pub struct BaseButtonClass {
     pub parent_class: gtk::ffi::GtkButtonClass,
-    pub sync_method:
-        Option<unsafe extern "C" fn(*mut BaseButtonInstance, extra_text: *mut Option<String>)>,
-    pub async_method: Option<unsafe extern "C" fn(*mut BaseButtonInstance) -> PinnedFuture>,
+    pub sync_method: Option<unsafe fn(&BaseButtonInstance, extra_text: Option<String>)>,
+    pub async_method: Option<unsafe fn(&BaseButtonInstance) -> PinnedFuture>,
 }
 
 unsafe impl ClassStruct for BaseButtonClass {
-    type Type = super::imp::BaseButton;
+    type Type = BaseButton;
 }
 
 impl std::ops::Deref for BaseButtonClass {
@@ -38,42 +37,31 @@ impl std::ops::DerefMut for BaseButtonClass {
 }
 
 #[derive(Debug, Default)]
-pub struct BaseButton {}
+pub struct BaseButton;
 
 // Virtual method default implementation trampolines
-unsafe extern "C" fn sync_method_default_trampoline(
-    this: *mut BaseButtonInstance,
-    extra_text: *mut Option<String>,
-) {
-    let imp = (*this).impl_();
-    imp.sync_method(&from_glib_borrow(this), Box::from_raw(extra_text))
+unsafe fn sync_method_default_trampoline(this: &BaseButtonInstance, extra_text: Option<String>) {
+    BaseButton::from_instance(this).sync_method(this, extra_text)
 }
 
-unsafe extern "C" fn async_method_default_trampoline(
-    this: *mut BaseButtonInstance,
-) -> PinnedFuture {
-    let imp = (*this).impl_();
-    imp.async_method(&from_glib_borrow(this))
+unsafe fn async_method_default_trampoline(this: &BaseButtonInstance) -> PinnedFuture {
+    BaseButton::from_instance(this).async_method(this)
 }
 
-pub unsafe extern "C" fn base_button_sync_method(
-    this: *mut BaseButtonInstance,
-    extra_text: *mut Option<String>,
-) {
-    let klass = glib::subclass::types::InstanceStruct::class(&*this);
-
+pub unsafe fn base_button_sync_method(this: &BaseButtonInstance, extra_text: Option<String>) {
+    let klass = &*(this.class() as *const _ as *const BaseButtonClass);
     (klass.sync_method.unwrap())(this, extra_text)
 }
 
-pub unsafe extern "C" fn base_button_async_method(this: *mut BaseButtonInstance) -> PinnedFuture {
-    let klass = glib::subclass::types::InstanceStruct::class(&*this);
+pub unsafe fn base_button_async_method(this: &BaseButtonInstance) -> PinnedFuture {
+    let klass = &*(this.class() as *const _ as *const BaseButtonClass);
     klass.async_method.unwrap()(this)
 }
 
 /// Default implementations of our sync_method and async_method.
 impl BaseButton {
-    fn sync_method(&self, obj: &super::BaseButton, extra_text: Box<Option<String>>) {
-        if let Some(text) = *extra_text {
+    fn sync_method(&self, obj: &super::BaseButton, extra_text: Option<String>) {
+        if let Some(text) = extra_text {
             obj.set_label(&format!("BaseButton sync: {}", text));
         } else {
             obj.set_label("BaseButton sync");
@@ -107,7 +95,7 @@ impl ObjectSubclass for BaseButton {
 impl ObjectImpl for BaseButton {
     fn constructed(&self, obj: &Self::Type) {
         // For demo purposes, call the sync_method during construction to set the button label
-        obj.sync_method(Box::new(Some(String::from("Sync extra text"))));
+        obj.sync_method(Some(String::from("Sync extra text")));
     }
 }
 

examples/virtual_methods/base_button/mod.rs

@@ -2,56 +2,72 @@
 mod imp;
 
 pub use self::imp::PinnedFuture;
-use gtk::glib::{
-    self,
+use gtk::{
+    glib::{self, subclass::prelude::*},
+    prelude::*,
     subclass::prelude::*,
-    translate::{from_glib_borrow, ToGlibPtr},
 };
-use gtk::{prelude::*, subclass::prelude::*};
 
 glib::wrapper! {
     pub struct BaseButton(ObjectSubclass<imp::BaseButton>)
         @extends gtk::Widget, gtk::Button;
 }
 
+impl BaseButton {
+    pub fn new() -> Self {
+        glib::Object::new(&[]).expect("Failed to create BaseButton")
+    }
+}
+
+impl Default for BaseButton {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// Public trait that implements our functions for everything that derives from BaseButton
 pub trait BaseButtonExt {
-    fn sync_method(&self, extra_text: Box<Option<String>>);
+    fn sync_method(&self, extra_text: Option<String>);
     fn async_method(&self) -> PinnedFuture;
 }
 
 /// We call into imp::BaseButton_$method_name for each function. These will retrieve the
 /// correct class (the base class for the BaseButton or the derived class for DerivedButton)
 /// and call the correct implementation of the function.
 impl<O: IsA<BaseButton>> BaseButtonExt for O {
-    fn sync_method(&self, extra_text: Box<Option<String>>) {
-        unsafe {
-            imp::base_button_sync_method(self.as_ref().to_glib_none().0, Box::into_raw(extra_text))
-        }
+    fn sync_method(&self, extra_text: Option<String>) {
+        unsafe { imp::base_button_sync_method(self.upcast_ref::<BaseButton>(), extra_text) }
     }
 
     fn async_method(&self) -> PinnedFuture {
-        unsafe { imp::base_button_async_method(self.as_ref().to_glib_none().0) }
+        unsafe { imp::base_button_async_method(self.upcast_ref::<BaseButton>()) }
     }
 }
 
 /// The BaseButtonImpl that each derived private struct has to implement. See derived_button/imp.rs for how
 /// to override functions.
 pub trait BaseButtonImpl: ButtonImpl + ObjectImpl + 'static {
-    fn sync_method(&self, obj: &BaseButton, extra_text: Box<Option<String>>) {
+    fn sync_method(&self, obj: &BaseButton, extra_text: Option<String>) {
         self.parent_sync_method(obj, extra_text)
     }
 
     fn async_method(&self, obj: &BaseButton) -> PinnedFuture {
         self.parent_async_method(obj)
     }
+}
 
-    fn parent_sync_method(&self, obj: &BaseButton, extra_text: Box<Option<String>>) {
+pub trait BaseButtonImplExt: ObjectSubclass {
+    fn parent_sync_method(&self, obj: &BaseButton, extra_text: Option<String>);
+    fn parent_async_method(&self, obj: &BaseButton) -> PinnedFuture;
+}
+
+impl<T: BaseButtonImpl> BaseButtonImplExt for T {
+    fn parent_sync_method(&self, obj: &BaseButton, extra_text: Option<String>) {
         unsafe {
             let data = Self::type_data();
             let parent_class = data.as_ref().parent_class() as *mut imp::BaseButtonClass;
             if let Some(ref f) = (*parent_class).sync_method {
-                f(obj.to_glib_none().0, Box::into_raw(extra_text))
+                f(obj, extra_text)
             } else {
                 unimplemented!()
             }
@@ -63,7 +79,7 @@ pub trait BaseButtonImpl: ButtonImpl + ObjectImpl + 'static {
             let data = Self::type_data();
             let parent_class = data.as_ref().parent_class() as *mut imp::BaseButtonClass;
             if let Some(ref f) = (*parent_class).async_method {
-                f(obj.to_glib_none().0)
+                f(obj)
             } else {
                 unimplemented!()
             }
@@ -74,7 +90,7 @@ pub trait BaseButtonImpl: ButtonImpl + ObjectImpl + 'static {
 /// Make the BaseButton subclassable
 unsafe impl<T: BaseButtonImpl> IsSubclassable<T> for BaseButton {
     fn class_init(class: &mut glib::Class<Self>) {
-        <gtk::Widget as IsSubclassable<T>>::class_init(class);
+        <gtk::Button as IsSubclassable<T>>::class_init(class.upcast_ref_mut());
 
         let klass = class.as_mut();
         klass.sync_method = Some(sync_method_trampoline::<T>);
@@ -86,25 +102,21 @@ unsafe impl<T: BaseButtonImpl> IsSubclassable<T> for BaseButton {
     }
 }
 
-// Virtual method default implementation trampolines
-unsafe extern "C" fn sync_method_trampoline<T: ObjectSubclass>(
-    this: *mut imp::BaseButtonInstance,
-    extra_text: *mut Option<String>,
-) where
-    T: BaseButtonImpl,
+// Virtual method implementation trampolines
+unsafe fn sync_method_trampoline<T>(this: &BaseButton, extra_text: Option<String>)
+where
+    T: ObjectSubclass + BaseButtonImpl,
 {
-    let instance = &*(this as *const T::Instance);
+    let instance = &*(this as *const _ as *const T::Instance);
     let imp = instance.impl_();
-    imp.sync_method(&from_glib_borrow(this), Box::from_raw(extra_text))
+    imp.sync_method(this, extra_text)
 }
 
-unsafe extern "C" fn async_method_trampoline<T: ObjectSubclass>(
-    this: *mut imp::BaseButtonInstance,
-) -> PinnedFuture
+unsafe fn async_method_trampoline<T>(this: &BaseButton) -> PinnedFuture
 where
-    T: BaseButtonImpl,
+    T: ObjectSubclass + BaseButtonImpl,
 {
-    let instance = &*(this as *const T::Instance);
+    let instance = &*(this as *const _ as *const T::Instance);
     let imp = instance.impl_();
-    imp.async_method(&from_glib_borrow(this))
+    imp.async_method(this)
 }

examples/virtual_methods/derived_button/imp.rs

@@ -17,8 +17,8 @@ impl ButtonImpl for DerivedButton {}
 
 /// Implement the base trait and override the functions
 impl BaseButtonImpl for DerivedButton {
-    fn sync_method(&self, obj: &BaseButton, extra_text: Box<Option<String>>) {
-        if let Some(text) = *extra_text {
+    fn sync_method(&self, obj: &BaseButton, extra_text: Option<String>) {
+        if let Some(text) = extra_text {
             obj.set_label(&format!("DerivedButton sync {}", text));
         } else {
             obj.set_label("DerivedButton sync");

examples/virtual_methods/derived_button/mod.rs

@@ -6,3 +6,15 @@ glib::wrapper! {
     pub struct DerivedButton(ObjectSubclass<imp::DerivedButton>)
         @extends gtk::Widget, gtk::Button, crate::base_button::BaseButton;
 }
+
+impl DerivedButton {
+    pub fn new() -> Self {
+        glib::Object::new(&[]).expect("Failed to create DerivedButton")
+    }
+}
+
+impl Default for DerivedButton {
+    fn default() -> Self {
+        Self::new()
+    }
+}

examples/virtual_methods/main.rs

@@ -1,9 +1,11 @@
 mod base_button;
 mod derived_button;
-mod virtual_methods_window;
 
-use crate::virtual_methods_window::VirtualMethodsAppWindow;
-use gtk::prelude::*;
+use crate::base_button::BaseButtonExt;
+use gtk::{
+    glib::{self, clone},
+    prelude::*,
+};
 
 fn main() {
     let application = gtk::Application::new(
@@ -12,7 +14,28 @@ fn main() {
     );
 
     application.connect_activate(|app| {
-        let win = VirtualMethodsAppWindow::new(app);
+        let win = gtk::ApplicationWindow::new(app);
+        let boxed = gtk::Box::new(gtk::Orientation::Horizontal, 6);
+        let base_button = base_button::BaseButton::new();
+        let derived_button = derived_button::DerivedButton::new();
+
+        base_button.connect_clicked(|b| {
+            let ctx = glib::MainContext::default();
+            let b = b.clone();
+            ctx.spawn_local(clone!(@weak b => async move {
+                b.async_method().await.unwrap();
+            }));
+        });
+        derived_button.connect_clicked(|b| {
+            let ctx = glib::MainContext::default();
+            ctx.spawn_local(clone!(@weak b => async move {
+                b.async_method().await.unwrap();
+            }));
+        });
+
+        boxed.append(&base_button);
+        boxed.append(&derived_button);
+        win.set_child(Some(&boxed));
         win.show();
     });