Merge pull request #777 from sdroege/impl-trait-without-object-reference

Change *Impl trait methods to only take &self and not Self::Type in a…

Author: sdroege

examples/basic_subclass/simple_application/imp.rs

@@ -27,10 +27,8 @@ impl ApplicationImpl for SimpleApplication {
     /// `gio::Application::activate` is what gets called when the
     /// application is launched by the desktop environment and
     /// aksed to present itself.
-    fn activate(&self, app: &Self::Type) {
-        let app = app.downcast_ref::<super::SimpleApplication>().unwrap();
-        let imp = app.imp();
-        let window = imp
+    fn activate(&self) {
+        let window = self
             .window
             .get()
             .expect("Should always be initiliazed in gio_application_startup");
@@ -45,13 +43,11 @@ impl ApplicationImpl for SimpleApplication {
     ///
     /// Due to this, we create and initialize the `SimpleWindow` widget
     /// here. Widgets can't be created before `startup` has been called.
-    fn startup(&self, app: &Self::Type) {
-        self.parent_startup(app);
+    fn startup(&self) {
+        self.parent_startup();
 
-        let app = app.downcast_ref::<super::SimpleApplication>().unwrap();
-        let imp = app.imp();
-        let window = SimpleWindow::new(app);
-        imp.window
+        let window = SimpleWindow::new(&self.instance());
+        self.window
             .set(window)
             .expect("Failed to initialize application window");
     }

examples/basic_subclass/simple_window/imp.rs

@@ -27,8 +27,10 @@ impl ObjectImpl for SimpleWindow {
     // Here we are overriding the glib::Objcet::contructed
     // method. Its what gets called when we create our Object
     // and where we can initialize things.
-    fn constructed(&self, obj: &Self::Type) {
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.parent_constructed();
+
+        let instance = self.instance();
 
         let headerbar = gtk::HeaderBar::new();
         let increment = gtk::Button::with_label("Increment!");
@@ -40,14 +42,13 @@ impl ObjectImpl for SimpleWindow {
 
         // Connect our method `on_increment_clicked` to be called
         // when the increment button is clicked.
-        increment.connect_clicked(clone!(@weak obj => move |_| {
-            let imp = obj.imp();
+        increment.connect_clicked(clone!(@weak self as imp => move |_| {
             imp.on_increment_clicked();
         }));
 
-        obj.add(&label);
-        obj.set_titlebar(Some(&headerbar));
-        obj.set_default_size(640, 480);
+        instance.add(&label);
+        instance.set_titlebar(Some(&headerbar));
+        instance.set_default_size(640, 480);
 
         self.widgets
             .set(WindowWidgets { label })

examples/composite_template/example_application_window/imp.rs

@@ -38,9 +38,9 @@ impl ObjectSubclass for ExampleApplicationWindow {
 }
 
 impl ObjectImpl for ExampleApplicationWindow {
-    fn constructed(&self, obj: &Self::Type) {
-        obj.init_label();
-        self.parent_constructed(obj);
+    fn constructed(&self) {
+        self.instance().init_label();
+        self.parent_constructed();
     }
 }
 

examples/list_box_model/model/imp.rs

@@ -22,13 +22,13 @@ impl ObjectSubclass for Model {
 impl ObjectImpl for Model {}
 
 impl ListModelImpl for Model {
-    fn item_type(&self, _list_model: &Self::Type) -> glib::Type {
+    fn item_type(&self) -> glib::Type {
         RowData::static_type()
     }
-    fn n_items(&self, _list_model: &Self::Type) -> u32 {
+    fn n_items(&self) -> u32 {
         self.0.borrow().len() as u32
     }
-    fn item(&self, _list_model: &Self::Type, position: u32) -> Option<glib::Object> {
+    fn item(&self, position: u32) -> Option<glib::Object> {
         self.0
             .borrow()
             .get(position as usize)

examples/list_box_model/row_data/imp.rs

@@ -51,13 +51,7 @@ impl ObjectImpl for RowData {
         PROPERTIES.as_ref()
     }
 
-    fn set_property(
-        &self,
-        _obj: &Self::Type,
-        _id: usize,
-        value: &glib::Value,
-        pspec: &glib::ParamSpec,
-    ) {
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
         match pspec.name() {
             "name" => {
                 let name = value
@@ -75,7 +69,7 @@ impl ObjectImpl for RowData {
         }
     }
 
-    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
         match pspec.name() {
             "name" => self.name.borrow().to_value(),
             "count" => self.count.borrow().to_value(),

gtk/src/subclass/application.rs

@@ -12,28 +12,28 @@ use crate::Window;
 pub trait GtkApplicationImpl:
     GtkApplicationImplExt + gio::subclass::prelude::ApplicationImpl
 {
-    fn window_added(&self, application: &Self::Type, window: &Window) {
-        self.parent_window_added(application, window)
+    fn window_added(&self, window: &Window) {
+        self.parent_window_added(window)
     }
 
-    fn window_removed(&self, application: &Self::Type, window: &Window) {
-        self.parent_window_removed(application, window)
+    fn window_removed(&self, window: &Window) {
+        self.parent_window_removed(window)
     }
 }
 
 pub trait GtkApplicationImplExt: ObjectSubclass {
-    fn parent_window_added(&self, application: &Self::Type, window: &Window);
-    fn parent_window_removed(&self, application: &Self::Type, window: &Window);
+    fn parent_window_added(&self, window: &Window);
+    fn parent_window_removed(&self, window: &Window);
 }
 
 impl<T: GtkApplicationImpl> GtkApplicationImplExt for T {
-    fn parent_window_added(&self, application: &Self::Type, window: &Window) {
+    fn parent_window_added(&self, window: &Window) {
         unsafe {
             let data = T::type_data();
             let parent_class = data.as_ref().parent_class() as *mut ffi::GtkApplicationClass;
             if let Some(f) = (*parent_class).window_added {
                 f(
-                    application
+                    self.instance()
                         .unsafe_cast_ref::<Application>()
                         .to_glib_none()
                         .0,
@@ -43,13 +43,13 @@ impl<T: GtkApplicationImpl> GtkApplicationImplExt for T {
         }
     }
 
-    fn parent_window_removed(&self, application: &Self::Type, window: &Window) {
+    fn parent_window_removed(&self, window: &Window) {
         unsafe {
             let data = T::type_data();
             let parent_class = data.as_ref().parent_class() as *mut ffi::GtkApplicationClass;
             if let Some(f) = (*parent_class).window_removed {
                 f(
-                    application
+                    self.instance()
                         .unsafe_cast_ref::<Application>()
                         .to_glib_none()
                         .0,
@@ -113,17 +113,15 @@ unsafe extern "C" fn application_window_added<T: GtkApplicationImpl>(
 ) {
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
-    let wrap: Borrowed<Application> = from_glib_borrow(ptr);
 
-    imp.window_added(wrap.unsafe_cast_ref(), &from_glib_borrow(wptr))
+    imp.window_added(&from_glib_borrow(wptr))
 }
 unsafe extern "C" fn application_window_removed<T: GtkApplicationImpl>(
     ptr: *mut ffi::GtkApplication,
     wptr: *mut ffi::GtkWindow,
 ) {
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
-    let wrap: Borrowed<Application> = from_glib_borrow(ptr);
 
-    imp.window_removed(wrap.unsafe_cast_ref(), &from_glib_borrow(wptr))
+    imp.window_removed(&from_glib_borrow(wptr))
 }

gtk/src/subclass/button.rs

@@ -8,37 +8,37 @@ use super::bin::BinImpl;
 use crate::Button;
 
 pub trait ButtonImpl: ButtonImplExt + BinImpl {
-    fn activate(&self, button: &Self::Type) {
-        self.parent_activate(button)
+    fn activate(&self) {
+        self.parent_activate()
     }
 
-    fn clicked(&self, button: &Self::Type) {
-        self.parent_clicked(button)
+    fn clicked(&self) {
+        self.parent_clicked()
     }
 }
 
 pub trait ButtonImplExt: ObjectSubclass {
-    fn parent_activate(&self, button: &Self::Type);
-    fn parent_clicked(&self, button: &Self::Type);
+    fn parent_activate(&self);
+    fn parent_clicked(&self);
 }
 
 impl<T: ButtonImpl> ButtonImplExt for T {
-    fn parent_activate(&self, button: &Self::Type) {
+    fn parent_activate(&self) {
         unsafe {
             let data = T::type_data();
             let parent_class = data.as_ref().parent_class() as *mut ffi::GtkButtonClass;
             if let Some(f) = (*parent_class).activate {
-                f(button.unsafe_cast_ref::<Button>().to_glib_none().0)
+                f(self.instance().unsafe_cast_ref::<Button>().to_glib_none().0)
             }
         }
     }
 
-    fn parent_clicked(&self, button: &Self::Type) {
+    fn parent_clicked(&self) {
         unsafe {
             let data = T::type_data();
             let parent_class = data.as_ref().parent_class() as *mut ffi::GtkButtonClass;
             if let Some(f) = (*parent_class).clicked {
-                f(button.unsafe_cast_ref::<Button>().to_glib_none().0)
+                f(self.instance().unsafe_cast_ref::<Button>().to_glib_none().0)
             }
         }
     }
@@ -61,15 +61,13 @@ unsafe impl<T: ButtonImpl> IsSubclassable<T> for Button {
 unsafe extern "C" fn button_activate<T: ButtonImpl>(ptr: *mut ffi::GtkButton) {
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
-    let wrap: Borrowed<Button> = from_glib_borrow(ptr);
 
-    imp.activate(wrap.unsafe_cast_ref())
+    imp.activate()
 }
 
 unsafe extern "C" fn button_clicked<T: ButtonImpl>(ptr: *mut ffi::GtkButton) {
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
-    let wrap: Borrowed<Button> = from_glib_borrow(ptr);
 
-    imp.clicked(wrap.unsafe_cast_ref())
+    imp.clicked()
 }