add impl From<T> for Value for manually implemented types

Author: jf2048

cairo/src/context.rs

@@ -71,6 +71,14 @@ impl fmt::Display for RectangleList {
 #[repr(transparent)]
 pub struct Context(ptr::NonNull<cairo_t>);
 
+#[cfg(feature = "use_glib")]
+impl IntoGlibPtr<*mut ffi::cairo_t> for Context {
+    #[inline]
+    unsafe fn into_glib_ptr(self) -> *mut ffi::cairo_t {
+        (&*std::mem::ManuallyDrop::new(self)).to_glib_none().0
+    }
+}
+
 #[cfg(feature = "use_glib")]
 impl<'a> ToGlibPtr<'a, *mut ffi::cairo_t> for &'a Context {
     type Storage = &'a Context;

cairo/src/device.rs

@@ -311,6 +311,14 @@ impl Device {
     }
 }
 
+#[cfg(feature = "use_glib")]
+impl IntoGlibPtr<*mut ffi::cairo_device_t> for Device {
+    #[inline]
+    unsafe fn into_glib_ptr(self) -> *mut ffi::cairo_device_t {
+        std::mem::ManuallyDrop::new(self).to_glib_none().0
+    }
+}
+
 #[cfg(feature = "use_glib")]
 impl<'a> ToGlibPtr<'a, *mut ffi::cairo_device_t> for Device {
     type Storage = &'a Device;

cairo/src/enums.rs

@@ -42,6 +42,13 @@ macro_rules! gvalue_impl {
                 <Self as glib::StaticType>::static_type()
             }
         }
+
+        impl From<$name> for glib::Value {
+            #[inline]
+            fn from(v: $name) -> Self {
+                glib::value::ToValue::to_value(&v)
+            }
+        }
     };
 }
 

cairo/src/lib.rs

@@ -86,6 +86,20 @@ macro_rules! gvalue_impl {
             }
         }
 
+        impl From<$name> for glib::Value {
+            fn from(v: $name) -> Self {
+                unsafe {
+                    let mut value =
+                        glib::Value::from_type(<$name as glib::StaticType>::static_type());
+                    glib::gobject_ffi::g_value_take_boxed(
+                        value.to_glib_none_mut().0,
+                        glib::translate::IntoGlibPtr::into_glib_ptr(v) as *mut _,
+                    );
+                    value
+                }
+            }
+        }
+
         impl glib::value::ToValueOptional for $name {
             fn to_value_optional(s: Option<&Self>) -> glib::Value {
                 let mut value = glib::Value::for_value_type::<Self>();

cairo/src/region.rs

@@ -15,6 +15,14 @@ use crate::ffi::cairo_region_t;
 #[repr(transparent)]
 pub struct Region(ptr::NonNull<cairo_region_t>);
 
+#[cfg(feature = "use_glib")]
+impl IntoGlibPtr<*mut ffi::cairo_region_t> for Region {
+    #[inline]
+    unsafe fn into_glib_ptr(self) -> *mut ffi::cairo_region_t {
+        (&*std::mem::ManuallyDrop::new(self)).to_glib_none().0
+    }
+}
+
 #[cfg(feature = "use_glib")]
 #[doc(hidden)]
 impl<'a> ToGlibPtr<'a, *mut ffi::cairo_region_t> for &'a Region {

cairo/src/surface.rs

@@ -289,6 +289,14 @@ impl Surface {
     }
 }
 
+#[cfg(feature = "use_glib")]
+impl IntoGlibPtr<*mut ffi::cairo_surface_t> for Surface {
+    #[inline]
+    unsafe fn into_glib_ptr(self) -> *mut ffi::cairo_surface_t {
+        std::mem::ManuallyDrop::new(self).to_glib_none().0
+    }
+}
+
 #[cfg(feature = "use_glib")]
 impl<'a> ToGlibPtr<'a, *mut ffi::cairo_surface_t> for Surface {
     type Storage = &'a Surface;

cairo/src/surface_macros.rs

@@ -35,6 +35,14 @@ macro_rules! declare_surface {
             }
         }
 
+        #[cfg(feature = "use_glib")]
+        impl IntoGlibPtr<*mut ffi::cairo_surface_t> for $surf_name {
+            #[inline]
+            unsafe fn into_glib_ptr(self) -> *mut ffi::cairo_surface_t {
+                std::mem::ManuallyDrop::new(self).to_glib_none().0
+            }
+        }
+
         #[cfg(feature = "use_glib")]
         impl<'a> ToGlibPtr<'a, *mut ffi::cairo_surface_t> for $surf_name {
             type Storage = &'a Surface;

glib-macros/src/boxed_derive.rs

@@ -161,6 +161,19 @@ pub fn impl_boxed(input: &syn::DeriveInput) -> TokenStream {
             }
         }
 
+        impl ::std::convert::From<#name> for #crate_ident::Value {
+            fn from(v: #name) -> Self {
+                unsafe {
+                    let mut value = #crate_ident::Value::from_type(<#name as #crate_ident::StaticType>::static_type());
+                    #crate_ident::gobject_ffi::g_value_take_boxed(
+                        #crate_ident::translate::ToGlibPtrMut::to_glib_none_mut(&mut value).0,
+                        #crate_ident::translate::IntoGlibPtr::<*mut #name>::into_glib_ptr(v) as *mut _,
+                    );
+                    value
+                }
+            }
+        }
+
         #impl_to_value_optional
 
         #impl_from_value
@@ -188,6 +201,13 @@ pub fn impl_boxed(input: &syn::DeriveInput) -> TokenStream {
             }
         }
 
+        impl #crate_ident::translate::IntoGlibPtr<*mut #name> for #name {
+            #[inline]
+            unsafe fn into_glib_ptr(self) -> *mut #name {
+                ::std::boxed::Box::into_raw(::std::boxed::Box::new(self)) as *mut _
+            }
+        }
+
         impl<'a> #crate_ident::translate::ToGlibPtr<'a, *const #name> for #name {
             type Storage = &'a Self;
 

glib-macros/src/enum_derive.rs

@@ -146,6 +146,13 @@ pub fn impl_enum(input: &syn::DeriveInput) -> TokenStream {
             }
         }
 
+        impl ::std::convert::From<#name> for #crate_ident::Value {
+            #[inline]
+            fn from(v: #name) -> Self {
+                #crate_ident::value::ToValue::to_value(&v)
+            }
+        }
+
         impl #crate_ident::StaticType for #name {
             fn static_type() -> #crate_ident::Type {
                 static ONCE: ::std::sync::Once = ::std::sync::Once::new();

glib-macros/src/flags_attribute.rs

@@ -174,6 +174,13 @@ pub fn impl_flags(attrs: &NestedMeta, input: &DeriveInput) -> TokenStream {
             }
         }
 
+        impl ::std::convert::From<#name> for #crate_ident::Value {
+            #[inline]
+            fn from(v: #name) -> Self {
+                #crate_ident::value::ToValue::to_value(&v)
+            }
+        }
+
         impl #crate_ident::StaticType for #name {
             fn static_type() -> #crate_ident::Type {
                 static ONCE: ::std::sync::Once = ::std::sync::Once::new();