Adapt to glib prelude cleanup

bilelmoussaoui · bilelmoussaoui · commit 1d3b10dfe4fe · 2024-02-01T21:47:51.000+01:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/gdk4/src/drag_surface_size.rs b/gdk4/src/drag_surface_size.rs
@@ -1,14 +1,13 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use std::ptr::NonNull;
-
+use crate::prelude::*;
 use glib::translate::*;
 
 #[repr(transparent)]
 #[doc(alias = "GdkDragSurfaceSize")]
-pub struct DragSurfaceSize(NonNull<ffi::GdkDragSurfaceSize>);
+pub struct DragSurfaceSize(std::ptr::NonNull<ffi::GdkDragSurfaceSize>);
 
-impl glib::StaticType for DragSurfaceSize {
+impl StaticType for DragSurfaceSize {
     fn static_type() -> glib::Type {
         unsafe { from_glib(ffi::gdk_drag_surface_size_get_type()) }
     }
diff --git a/gdk4/src/drop.rs b/gdk4/src/drop.rs
@@ -2,9 +2,9 @@
 
 use std::{future, pin::Pin, ptr};
 
-use glib::{object::IsA, translate::*, GString};
+use glib::{translate::*, GString};
 
-use crate::Drop;
+use crate::{prelude::*, Drop};
 
 impl Drop {
     #[doc(alias = "gdk_drop_read_async")]
diff --git a/gdk4/src/event.rs b/gdk4/src/event.rs
@@ -1,10 +1,8 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use std::{fmt, mem};
+use glib::translate::*;
 
-use glib::{translate::*, StaticType};
-
-use crate::{Event, EventType};
+use crate::{prelude::*, Event, EventType};
 
 impl Event {
     #[inline]
@@ -47,7 +45,7 @@ impl Event {
     pub fn angle(&self, event: impl AsRef<Event>) -> Option<f64> {
         skip_assert_initialized!();
         unsafe {
-            let mut angle = mem::MaybeUninit::uninit();
+            let mut angle = std::mem::MaybeUninit::uninit();
             let ret = from_glib(ffi::gdk_events_get_angle(
                 self.to_glib_none().0,
                 event.as_ref().to_glib_none().0,
@@ -67,8 +65,8 @@ impl Event {
     pub fn center(&self, event: impl AsRef<Event>) -> Option<(f64, f64)> {
         skip_assert_initialized!();
         unsafe {
-            let mut x = mem::MaybeUninit::uninit();
-            let mut y = mem::MaybeUninit::uninit();
+            let mut x = std::mem::MaybeUninit::uninit();
+            let mut y = std::mem::MaybeUninit::uninit();
             let ret = from_glib(ffi::gdk_events_get_center(
                 self.to_glib_none().0,
                 event.as_ref().to_glib_none().0,
@@ -90,7 +88,7 @@ impl Event {
     pub fn distance(&self, event: impl AsRef<Event>) -> Option<f64> {
         skip_assert_initialized!();
         unsafe {
-            let mut distance = mem::MaybeUninit::uninit();
+            let mut distance = std::mem::MaybeUninit::uninit();
             let ret = from_glib(ffi::gdk_events_get_distance(
                 self.to_glib_none().0,
                 event.as_ref().to_glib_none().0,
@@ -106,8 +104,8 @@ impl Event {
     }
 }
 
-impl fmt::Debug for Event {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl std::fmt::Debug for Event {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         f.debug_struct("Event")
             .field("event_type", &self.event_type())
             .field("history", &self.history())
diff --git a/gdk4/src/keys.rs b/gdk4/src/keys.rs
@@ -1,6 +1,7 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use glib::{translate::*, value::*, GString, IntoGStr, Type, Value};
+use crate::prelude::*;
+use glib::{translate::*, value::FromValue, GString, Type, Value};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 // rustdoc-stripper-ignore-next
@@ -4708,7 +4709,7 @@ impl From<Key> for Value {
 }
 
 // TODO: Drop once https://github.com/gtk-rs/gtk-rs-core/issues/612
-impl glib::StaticType for Key {
+impl StaticType for Key {
     #[inline]
     fn static_type() -> Type {
         Type::U32
diff --git a/gdk4/src/toplevel_size.rs b/gdk4/src/toplevel_size.rs
@@ -1,16 +1,13 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use std::fmt;
-
+use crate::prelude::*;
 use glib::translate::*;
 
-use std::ptr::NonNull;
-
 #[repr(transparent)]
 #[doc(alias = "GdkToplevelSize")]
-pub struct ToplevelSize(NonNull<ffi::GdkToplevelSize>);
+pub struct ToplevelSize(std::ptr::NonNull<ffi::GdkToplevelSize>);
 
-impl glib::StaticType for ToplevelSize {
+impl StaticType for ToplevelSize {
     fn static_type() -> glib::Type {
         unsafe { from_glib(ffi::gdk_toplevel_size_get_type()) }
     }
@@ -55,8 +52,8 @@ impl ToplevelSize {
     }
 }
 
-impl fmt::Debug for ToplevelSize {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl std::fmt::Debug for ToplevelSize {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         f.debug_struct("ToplevelSize")
             .field("bounds", &self.bounds())
             .finish()
diff --git a/gsk4/src/render_node.rs b/gsk4/src/render_node.rs
@@ -1,8 +1,8 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use glib::{translate::*, StaticType};
+use glib::translate::*;
 
-use crate::{ParseLocation, RenderNode, RenderNodeType};
+use crate::{prelude::*, ParseLocation, RenderNode, RenderNodeType};
 
 impl RenderNode {
     #[inline]
@@ -202,7 +202,7 @@ macro_rules! define_render_node {
 
             #[inline]
             fn value_type(&self) -> glib::Type {
-                use glib::StaticType;
+                use glib::prelude::StaticType;
                 Self::static_type()
             }
         }
diff --git a/gtk4-macros/src/composite_template_derive.rs b/gtk4-macros/src/composite_template_derive.rs
@@ -164,8 +164,8 @@ fn gen_template_child_type_checks(fields: &[AttributedField]) -> TokenStream {
             let ident = &field.ident;
             let type_err = format!("Template child with id `{}` has incompatible type. XML has {{:?}}, struct has {{:?}}", field.id());
             quote! {
-                let ty = <<#ty as ::std::ops::Deref>::Target as #crate_ident::glib::StaticType>::static_type();
-                let child_ty = #crate_ident::glib::object::ObjectExt::type_(::std::ops::Deref::deref(&imp.#ident));
+                let ty = <<#ty as ::std::ops::Deref>::Target as #crate_ident::glib::prelude::StaticType>::static_type();
+                let child_ty = #crate_ident::glib::prelude::ObjectExt::type_(::std::ops::Deref::deref(&imp.#ident));
                 if !child_ty.is_a(ty) {
                     panic!(#type_err, child_ty, ty);
                 }
diff --git a/gtk4/src/cell_area.rs b/gtk4/src/cell_area.rs
@@ -1,6 +1,6 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use glib::{translate::*, value::FromValue, IntoGStr, Value};
+use glib::{translate::*, value::FromValue, Value};
 
 use crate::{prelude::*, CellArea, CellRenderer};
 
diff --git a/gtk4/src/closure_expression.rs b/gtk4/src/closure_expression.rs
@@ -1,8 +1,8 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use glib::{translate::*, value::ValueType, StaticType, Value};
+use glib::{translate::*, Value};
 
-use crate::{ClosureExpression, Expression};
+use crate::{prelude::*, ClosureExpression, Expression};
 
 define_expression!(ClosureExpression, ffi::GtkClosureExpression);
 
diff --git a/gtk4/src/constant_expression.rs b/gtk4/src/constant_expression.rs
@@ -1,8 +1,8 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use glib::{translate::*, value::FromValue, ToValue};
+use glib::{translate::*, value::FromValue};
 
-use crate::ConstantExpression;
+use crate::{prelude::*, ConstantExpression};
 
 define_expression!(ConstantExpression, ffi::GtkConstantExpression);
 
diff --git a/gtk4/src/constraint_layout.rs b/gtk4/src/constraint_layout.rs
@@ -1,6 +1,6 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use glib::{translate::*, IntoStrV};
+use glib::translate::*;
 
 use crate::{prelude::*, Constraint, ConstraintLayout, Widget};
 
diff --git a/gtk4/src/enums.rs b/gtk4/src/enums.rs
@@ -2,7 +2,7 @@
 
 use std::cmp;
 
-use glib::{error::ErrorDomain, translate::*, Quark};
+use glib::{translate::*, Quark};
 
 use crate::{prelude::*, CssParserWarning, Ordering};
 
diff --git a/gtk4/src/expression.rs b/gtk4/src/expression.rs
@@ -1,6 +1,6 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use glib::{translate::*, value::FromValue, Object, StaticType, Type, Value};
+use glib::{translate::*, value::FromValue, Object, Type, Value};
 
 use crate::{prelude::*, Expression};
 
@@ -20,7 +20,7 @@ impl AsRef<Expression> for Expression {
 ///
 /// The user is not supposed to implement this trait.
 pub unsafe trait IsExpression:
-    glib::StaticType + FromGlibPtrFull<*mut ffi::GtkExpression> + 'static
+    StaticType + FromGlibPtrFull<*mut ffi::GtkExpression> + 'static
 {
 }
 
@@ -389,7 +389,7 @@ macro_rules! define_expression {
 
             #[inline]
             fn value_type(&self) -> glib::Type {
-                use glib::StaticType;
+                use glib::prelude::StaticType;
                 Self::static_type()
             }
         }
diff --git a/gtk4/src/expression_watch.rs b/gtk4/src/expression_watch.rs
@@ -49,7 +49,7 @@ impl ExpressionWatch {
 }
 
 #[cfg(feature = "v4_2")]
-impl glib::StaticType for ExpressionWatch {
+impl glib::prelude::StaticType for ExpressionWatch {
     #[doc(alias = "gtk_expression_watch_get_type")]
     #[inline]
     fn static_type() -> glib::Type {
diff --git a/gtk4/src/functions.rs b/gtk4/src/functions.rs
@@ -2,7 +2,7 @@
 
 use std::{boxed::Box as Box_, pin::Pin, sync::OnceLock};
 
-use glib::{translate::*, IntoGStr, Quark, Slice, ToValue};
+use glib::{translate::*, Quark, Slice};
 
 pub use crate::auto::functions::*;
 use crate::{prelude::*, AboutDialog, StyleProvider, Window};
diff --git a/gtk4/src/list_store.rs b/gtk4/src/list_store.rs
diff --git a/gtk4/src/param_spec_expression.rs b/gtk4/src/param_spec_expression.rs
diff --git a/gtk4/src/property_expression.rs b/gtk4/src/property_expression.rs
diff --git a/gtk4/src/response_type.rs b/gtk4/src/response_type.rs
diff --git a/gtk4/src/tree_store.rs b/gtk4/src/tree_store.rs
