Update to current git

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Author: elmarco

src/bar/imp.rs

@@ -27,7 +27,7 @@ impl ObjectImpl for Bar {
     fn properties() -> &'static [glib::ParamSpec] {
         use once_cell::sync::Lazy;
         static PROPERTIES: Lazy<Vec<glib::ParamSpec>> = Lazy::new(|| {
-            vec![glib::ParamSpec::double(
+            vec![glib::ParamSpec::new_double(
                 "number",
                 "Number",
                 "Some number",
@@ -48,7 +48,7 @@ impl ObjectImpl for Bar {
         value: &glib::Value,
         pspec: &glib::ParamSpec,
     ) {
-        match pspec.get_name() {
+        match pspec.name() {
             "number" => {
                 let number = value.get().unwrap().unwrap();
                 self.set_number(obj, number);
@@ -57,9 +57,9 @@ impl ObjectImpl for Bar {
         }
     }
 
-    fn get_property(&self, obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
-        match pspec.get_name() {
-            "number" => self.get_number(obj).to_value(),
+    fn property(&self, obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+        match pspec.name() {
+            "number" => self.number(obj).to_value(),
             _ => unimplemented!(),
         }
     }
@@ -77,7 +77,7 @@ impl Bar {
         this.notify("number");
     }
 
-    fn get_number(&self, _this: &super::Bar) -> f64 {
+    fn number(&self, _this: &super::Bar) -> f64 {
         *self.number.borrow_mut()
     }
 }
@@ -93,16 +93,16 @@ pub(crate) mod ffi {
     /// Must be a BarInstance object.
     #[no_mangle]
     pub unsafe extern "C" fn ex_bar_get_number(this: *mut ExBar) -> f64 {
-        let imp = glib::subclass::types::InstanceStruct::get_impl(&*this);
-        imp.get_number(&from_glib_borrow(this))
+        let imp = glib::subclass::types::InstanceStruct::impl_(&*this);
+        imp.number(&from_glib_borrow(this))
     }
 
     /// # Safety
     ///
     /// Must be a BarInstance object.
     #[no_mangle]
     pub unsafe extern "C" fn ex_bar_set_number(this: *mut ExBar, num: f64) {
-        let imp = glib::subclass::types::InstanceStruct::get_impl(&*this);
+        let imp = glib::subclass::types::InstanceStruct::impl_(&*this);
         imp.set_number(&from_glib_borrow(this), num);
     }
 
@@ -122,6 +122,6 @@ pub(crate) mod ffi {
 
     #[no_mangle]
     pub extern "C" fn ex_bar_get_type() -> glib::ffi::GType {
-        <super::Bar as glib::subclass::types::ObjectSubclassType>::get_type().to_glib()
+        <super::Bar as glib::subclass::types::ObjectSubclassType>::type_().to_glib()
     }
 }

src/bar/mod.rs

@@ -21,7 +21,7 @@ glib::wrapper! {
     pub struct Bar(Object<ffi::ExBar, ffi::ExBarClass>) @extends Foo, @implements Nameable;
 
     match fn {
-        get_type => || ffi::ex_bar_get_type(),
+        type_ => || ffi::ex_bar_get_type(),
     }
 }
 
@@ -39,11 +39,11 @@ impl Bar {
         unsafe { ffi::ex_bar_set_number(self.to_glib_none().0, num) }
     }
 
-    pub fn get_number(&self) -> f64 {
+    pub fn number(&self) -> f64 {
         unsafe { ffi::ex_bar_get_number(self.to_glib_none().0) }
     }
 
-    pub fn get_property_number(&self) -> f64 {
+    pub fn property_number(&self) -> f64 {
         let mut value = glib::Value::from(&0.0f64);
         unsafe {
             glib::gobject_ffi::g_object_get_property(
@@ -106,19 +106,19 @@ mod tests {
     fn test_counter() {
         let bar = Bar::new(Some("bar's name"));
 
-        assert_eq!(bar.get_counter(), 0);
+        assert_eq!(bar.counter(), 0);
         assert_eq!(bar.increment(1), 2);
-        assert_eq!(bar.get_counter(), 2);
+        assert_eq!(bar.counter(), 2);
         assert_eq!(bar.increment(10), 22);
-        assert_eq!(bar.get_counter(), 22);
+        assert_eq!(bar.counter(), 22);
     }
 
     #[test]
     fn test_name() {
         let bar = Bar::new(Some("bar's name"));
 
-        assert_eq!(bar.get_name(), Some("bar's name".into()));
-        assert_eq!(bar.get_property_name(), Some("bar's name".into()));
+        assert_eq!(bar.name(), Some("bar's name".into()));
+        assert_eq!(bar.property_name(), Some("bar's name".into()));
     }
 
     #[test]
@@ -132,15 +132,15 @@ mod tests {
         });
 
         assert_eq!(*counter.borrow(), 0);
-        assert_eq!(bar.get_number(), 0.0);
-        assert_eq!(bar.get_property_number(), 0.0);
+        assert_eq!(bar.number(), 0.0);
+        assert_eq!(bar.property_number(), 0.0);
         bar.set_number(10.0);
         assert_eq!(*counter.borrow(), 1);
-        assert_eq!(bar.get_number(), 10.0);
-        assert_eq!(bar.get_property_number(), 10.0);
+        assert_eq!(bar.number(), 10.0);
+        assert_eq!(bar.property_number(), 10.0);
         bar.set_property_number(20.0);
         assert_eq!(*counter.borrow(), 2);
-        assert_eq!(bar.get_number(), 20.0);
-        assert_eq!(bar.get_property_number(), 20.0);
+        assert_eq!(bar.number(), 20.0);
+        assert_eq!(bar.property_number(), 20.0);
     }
 }

src/color/mod.rs

@@ -61,10 +61,10 @@ mod tests {
         assert_eq!(t.name(), "ExColor");
 
         let e = glib::EnumClass::new(t).unwrap();
-        let v = e.get_value(1).unwrap();
-        assert_eq!(v.get_name(), "Green");
-        assert_eq!(v.get_nick(), "green");
+        let v = e.value(1).unwrap();
+        assert_eq!(v.name(), "Green");
+        assert_eq!(v.nick(), "green");
 
-        assert_eq!(e.get_value(42), None);
+        assert_eq!(e.value(42), None);
     }
 }

src/flags/mod.rs

@@ -49,9 +49,9 @@ mod tests {
         assert!(t.is_a(glib::Type::FLAGS));
         assert_eq!(t.name(), "ExFlags");
         let e = glib::FlagsClass::new(t).unwrap();
-        let v = e.get_value(1).unwrap();
-        assert_eq!(v.get_name(), "Some");
-        assert_eq!(v.get_nick(), "some");
+        let v = e.value(1).unwrap();
+        assert_eq!(v.name(), "Some");
+        assert_eq!(v.nick(), "some");
 
     }
 }

src/foo/imp.rs

@@ -76,7 +76,7 @@ impl ObjectImpl for Foo {
                 let inc = args[2].get::<i32>().unwrap().unwrap();
 
                 unsafe {
-                    let klass = &*(obj.get_object_class() as *const _ as *const FooClass);
+                    let klass = &*(obj.object_class() as *const _ as *const FooClass);
                     if let Some(ref func) = klass.incremented {
                         func(obj.as_ptr() as *mut ffi::ExFoo, val, inc);
                     }
@@ -93,7 +93,7 @@ impl ObjectImpl for Foo {
     fn properties() -> &'static [glib::ParamSpec] {
         use once_cell::sync::Lazy;
         static PROPERTIES: Lazy<Vec<glib::ParamSpec>> = Lazy::new(|| {
-            vec![glib::ParamSpec::string(
+            vec![glib::ParamSpec::new_string(
                 "name",
                 "Name",
                 "Name of this object",
@@ -112,7 +112,7 @@ impl ObjectImpl for Foo {
         value: &glib::Value,
         pspec: &glib::ParamSpec,
     ) {
-        match pspec.get_name() {
+        match pspec.name() {
             "name" => {
                 let name = value.get().unwrap();
                 self.set_name(obj, name);
@@ -121,17 +121,17 @@ impl ObjectImpl for Foo {
         }
     }
 
-    fn get_property(&self, obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
-        match pspec.get_name() {
-            "name" => self.get_name(obj).to_value(),
+    fn property(&self, obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+        match pspec.name() {
+            "name" => self.name(obj).to_value(),
             _ => unimplemented!(),
         }
     }
 }
 
 impl NameableImpl for Foo {
-    fn get_name(&self, nameable: &Self::Type) -> Option<String> {
-        self.get_name(nameable.dynamic_cast_ref().unwrap())
+    fn name(&self, nameable: &Self::Type) -> Option<String> {
+        self.name(nameable.dynamic_cast_ref().unwrap())
     }
 }
 
@@ -154,11 +154,11 @@ impl Foo {
         // signal that could be overriden by subclasses
     }
 
-    fn get_counter(&self, _this: &super::Foo) -> i32 {
+    fn counter(&self, _this: &super::Foo) -> i32 {
         *self.counter.borrow()
     }
 
-    fn get_name(&self, _this: &super::Foo) -> Option<String> {
+    fn name(&self, _this: &super::Foo) -> Option<String> {
         self.name.borrow().clone()
     }
 
@@ -179,7 +179,7 @@ pub(crate) mod ffi {
     /// Must be a ExFoo object.
     #[no_mangle]
     pub unsafe extern "C" fn ex_foo_increment(this: *mut ExFoo, inc: i32) -> i32 {
-        let klass = glib::subclass::types::InstanceStruct::get_class(&*this);
+        let klass = glib::subclass::types::InstanceStruct::class(&*this);
 
         (klass.increment.unwrap())(this, inc)
     }
@@ -190,17 +190,17 @@ pub(crate) mod ffi {
     /// Must be a FooInstance object.
     #[no_mangle]
     pub unsafe extern "C" fn ex_foo_get_counter(this: *mut ExFoo) -> i32 {
-        let imp = glib::subclass::types::InstanceStruct::get_impl(&*this);
-        imp.get_counter(&from_glib_borrow(this))
+        let imp = glib::subclass::types::InstanceStruct::impl_(&*this);
+        imp.counter(&from_glib_borrow(this))
     }
 
     /// # Safety
     ///
     /// Must be a FooInstance object.
     #[no_mangle]
     pub unsafe extern "C" fn ex_foo_get_name(this: *mut ExFoo) -> *mut c_char {
-        let imp = glib::subclass::types::InstanceStruct::get_impl(&*this);
-        imp.get_name(&from_glib_borrow(this)).to_glib_full()
+        let imp = glib::subclass::types::InstanceStruct::impl_(&*this);
+        imp.name(&from_glib_borrow(this)).to_glib_full()
     }
 
     // GObject glue
@@ -219,17 +219,17 @@ pub(crate) mod ffi {
 
     #[no_mangle]
     pub extern "C" fn ex_foo_get_type() -> glib::ffi::GType {
-        <super::Foo as glib::subclass::types::ObjectSubclassType>::get_type().to_glib()
+        <super::Foo as glib::subclass::types::ObjectSubclassType>::type_().to_glib()
     }
 }
 
 // Virtual method default implementation trampolines
 unsafe extern "C" fn increment_default_trampoline(this: *mut ffi::ExFoo, inc: i32) -> i32 {
-    let imp = (*this).get_impl();
+    let imp = (*this).impl_();
     imp.increment(&from_glib_borrow(this), inc)
 }
 
 unsafe extern "C" fn incremented_default_trampoline(this: *mut ffi::ExFoo, val: i32, inc: i32) {
-    let imp = (*this).get_impl();
+    let imp = (*this).impl_();
     imp.incremented(&from_glib_borrow(this), val, inc);
 }

src/foo/mod.rs

@@ -20,7 +20,7 @@ glib::wrapper! {
     pub struct Foo(Object<ffi::ExFoo, ffi::ExFooClass>) @implements Nameable;
 
     match fn {
-        get_type => || ffi::ex_foo_get_type(),
+        type_ => || ffi::ex_foo_get_type(),
     }
 }
 
@@ -37,10 +37,10 @@ impl Foo {
 
 pub trait FooExt {
     fn increment(&self, inc: i32) -> i32;
-    fn get_counter(&self) -> i32;
-    fn get_name(&self) -> Option<String>;
+    fn counter(&self) -> i32;
+    fn name(&self) -> Option<String>;
 
-    fn get_property_name(&self) -> Option<String>;
+    fn property_name(&self) -> Option<String>;
 
     fn connect_incremented<F: Fn(&Self, i32, i32) + 'static>(&self, f: F) -> SignalHandlerId;
 }
@@ -50,15 +50,15 @@ impl<O: IsA<Foo>> FooExt for O {
         unsafe { ffi::ex_foo_increment(self.as_ref().to_glib_none().0, inc) }
     }
 
-    fn get_counter(&self) -> i32 {
+    fn counter(&self) -> i32 {
         unsafe { ffi::ex_foo_get_counter(self.as_ref().to_glib_none().0) }
     }
 
-    fn get_name(&self) -> Option<String> {
+    fn name(&self) -> Option<String> {
         unsafe { from_glib_full(ffi::ex_foo_get_name(self.as_ref().to_glib_none().0)) }
     }
 
-    fn get_property_name(&self) -> Option<String> {
+    fn property_name(&self) -> Option<String> {
         let mut value = glib::Value::from(None::<&str>);
         unsafe {
             glib::gobject_ffi::g_object_get_property(
@@ -112,7 +112,7 @@ pub trait FooImpl: ObjectImpl + 'static {
     fn parent_increment(&self, obj: &Foo, inc: i32) -> i32 {
         unsafe {
             let data = Self::type_data();
-            let parent_class = data.as_ref().get_parent_class() as *mut ffi::ExFooClass;
+            let parent_class = data.as_ref().parent_class() as *mut ffi::ExFooClass;
             if let Some(ref f) = (*parent_class).increment {
                 f(obj.to_glib_none().0, inc)
             } else {
@@ -124,7 +124,7 @@ pub trait FooImpl: ObjectImpl + 'static {
     fn parent_incremented(&self, obj: &Foo, val: i32, inc: i32) {
         unsafe {
             let data = Self::type_data();
-            let parent_class = data.as_ref().get_parent_class() as *mut ffi::ExFooClass;
+            let parent_class = data.as_ref().parent_class() as *mut ffi::ExFooClass;
             if let Some(ref f) = (*parent_class).incremented {
                 f(obj.to_glib_none().0, val, inc)
             }
@@ -151,7 +151,7 @@ where
     T: FooImpl,
 {
     let instance = &*(this as *const T::Instance);
-    let imp = instance.get_impl();
+    let imp = instance.impl_();
     imp.increment(&from_glib_borrow(this), inc)
 }
 
@@ -163,7 +163,7 @@ unsafe extern "C" fn incremented_trampoline<T: ObjectSubclass>(
     T: FooImpl,
 {
     let instance = &*(this as *const T::Instance);
-    let imp = instance.get_impl();
+    let imp = instance.impl_();
     imp.incremented(&from_glib_borrow(this), val, inc);
 }
 
@@ -190,20 +190,20 @@ mod tests {
             *incremented_clone.borrow_mut() = (val, inc);
         });
 
-        assert_eq!(foo.get_counter(), 0);
+        assert_eq!(foo.counter(), 0);
         assert_eq!(foo.increment(1), 1);
         assert_eq!(*incremented.borrow(), (1, 1));
-        assert_eq!(foo.get_counter(), 1);
+        assert_eq!(foo.counter(), 1);
         assert_eq!(foo.increment(10), 11);
         assert_eq!(*incremented.borrow(), (11, 10));
-        assert_eq!(foo.get_counter(), 11);
+        assert_eq!(foo.counter(), 11);
     }
 
     #[test]
     fn test_name() {
         let foo = Foo::new(Some("foo's name"));
 
-        assert_eq!(foo.get_name(), Some("foo's name".into()));
-        assert_eq!(foo.get_property_name(), Some("foo's name".into()));
+        assert_eq!(foo.name(), Some("foo's name".into()));
+        assert_eq!(foo.property_name(), Some("foo's name".into()));
     }
 }