gio/auto/

dbus_object_skeleton.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{DBusInterfaceSkeleton, DBusMethodInvocation, DBusObject, ffi};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// A `GDBusObjectSkeleton` instance is essentially a group of D-Bus
    /// interfaces. The set of exported interfaces on the object may be
    /// dynamic and change at runtime.
    ///
    /// This type is intended to be used with [`DBusObjectManager`][crate::DBusObjectManager].
    ///
    /// ## Properties
    ///
    ///
    /// #### `g-object-path`
    ///  The object path where the object is exported.
    ///
    /// Readable | Writeable | Construct
    ///
    /// ## Signals
    ///
    ///
    /// #### `authorize-method`
    ///  Emitted when a method is invoked by a remote caller and used to
    /// determine if the method call is authorized.
    ///
    /// This signal is like #GDBusInterfaceSkeleton's
    /// #GDBusInterfaceSkeleton::g-authorize-method signal,
    /// except that it is for the enclosing object.
    ///
    /// The default class handler just returns [`true`].
    ///
    ///
    /// <details><summary><h4>DBusObject</h4></summary>
    ///
    ///
    /// #### `interface-added`
    ///  Emitted when @interface is added to @object.
    ///
    ///
    ///
    ///
    /// #### `interface-removed`
    ///  Emitted when @interface is removed from @object.
    ///
    ///
    /// </details>
    ///
    /// # Implements
    ///
    /// [`DBusObjectSkeletonExt`][trait@crate::prelude::DBusObjectSkeletonExt], [`trait@glib::ObjectExt`], [`DBusObjectExt`][trait@crate::prelude::DBusObjectExt]
    #[doc(alias = "GDBusObjectSkeleton")]
    pub struct DBusObjectSkeleton(Object<ffi::GDBusObjectSkeleton, ffi::GDBusObjectSkeletonClass>) @implements DBusObject;

    match fn {
        type_ => || ffi::g_dbus_object_skeleton_get_type(),
    }
}

impl DBusObjectSkeleton {
    pub const NONE: Option<&'static DBusObjectSkeleton> = None;

    /// Creates a new #GDBusObjectSkeleton.
    /// ## `object_path`
    /// An object path.
    ///
    /// # Returns
    ///
    /// A #GDBusObjectSkeleton. Free with g_object_unref().
    #[doc(alias = "g_dbus_object_skeleton_new")]
    pub fn new(object_path: &str) -> DBusObjectSkeleton {
        unsafe {
            from_glib_full(ffi::g_dbus_object_skeleton_new(
                object_path.to_glib_none().0,
            ))
        }
    }
}

/// Trait containing all [`struct@DBusObjectSkeleton`] methods.
///
/// # Implementors
///
/// [`DBusObjectSkeleton`][struct@crate::DBusObjectSkeleton]
pub trait DBusObjectSkeletonExt: IsA<DBusObjectSkeleton> + 'static {
    /// Adds @interface_ to @self.
    ///
    /// If @self already contains a #GDBusInterfaceSkeleton with the same
    /// interface name, it is removed before @interface_ is added.
    ///
    /// Note that @self takes its own reference on @interface_ and holds
    /// it until removed.
    /// ## `interface_`
    /// A #GDBusInterfaceSkeleton.
    #[doc(alias = "g_dbus_object_skeleton_add_interface")]
    fn add_interface(&self, interface_: &impl IsA<DBusInterfaceSkeleton>) {
        unsafe {
            ffi::g_dbus_object_skeleton_add_interface(
                self.as_ref().to_glib_none().0,
                interface_.as_ref().to_glib_none().0,
            );
        }
    }

    /// This method simply calls g_dbus_interface_skeleton_flush() on all
    /// interfaces belonging to @self. See that method for when flushing
    /// is useful.
    #[doc(alias = "g_dbus_object_skeleton_flush")]
    fn flush(&self) {
        unsafe {
            ffi::g_dbus_object_skeleton_flush(self.as_ref().to_glib_none().0);
        }
    }

    /// Removes @interface_ from @self.
    /// ## `interface_`
    /// A #GDBusInterfaceSkeleton.
    #[doc(alias = "g_dbus_object_skeleton_remove_interface")]
    fn remove_interface(&self, interface_: &impl IsA<DBusInterfaceSkeleton>) {
        unsafe {
            ffi::g_dbus_object_skeleton_remove_interface(
                self.as_ref().to_glib_none().0,
                interface_.as_ref().to_glib_none().0,
            );
        }
    }

    /// Removes the #GDBusInterface with @interface_name from @self.
    ///
    /// If no D-Bus interface of the given interface exists, this function
    /// does nothing.
    /// ## `interface_name`
    /// A D-Bus interface name.
    #[doc(alias = "g_dbus_object_skeleton_remove_interface_by_name")]
    fn remove_interface_by_name(&self, interface_name: &str) {
        unsafe {
            ffi::g_dbus_object_skeleton_remove_interface_by_name(
                self.as_ref().to_glib_none().0,
                interface_name.to_glib_none().0,
            );
        }
    }

    /// Sets the object path for @self.
    /// ## `object_path`
    /// A valid D-Bus object path.
    #[doc(alias = "g_dbus_object_skeleton_set_object_path")]
    #[doc(alias = "g-object-path")]
    fn set_object_path(&self, object_path: &str) {
        unsafe {
            ffi::g_dbus_object_skeleton_set_object_path(
                self.as_ref().to_glib_none().0,
                object_path.to_glib_none().0,
            );
        }
    }

    /// The object path where the object is exported.
    #[doc(alias = "g-object-path")]
    fn g_object_path(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "g-object-path")
    }

    /// The object path where the object is exported.
    #[doc(alias = "g-object-path")]
    fn set_g_object_path(&self, g_object_path: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "g-object-path", g_object_path)
    }

    /// Emitted when a method is invoked by a remote caller and used to
    /// determine if the method call is authorized.
    ///
    /// This signal is like #GDBusInterfaceSkeleton's
    /// #GDBusInterfaceSkeleton::g-authorize-method signal,
    /// except that it is for the enclosing object.
    ///
    /// The default class handler just returns [`true`].
    /// ## `interface`
    /// The #GDBusInterfaceSkeleton that @invocation is for.
    /// ## `invocation`
    /// A #GDBusMethodInvocation.
    ///
    /// # Returns
    ///
    /// [`true`] if the call is authorized, [`false`] otherwise.
    #[doc(alias = "authorize-method")]
    fn connect_authorize_method<
        F: Fn(&Self, &DBusInterfaceSkeleton, &DBusMethodInvocation) -> bool + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn authorize_method_trampoline<
            P: IsA<DBusObjectSkeleton>,
            F: Fn(&P, &DBusInterfaceSkeleton, &DBusMethodInvocation) -> bool + 'static,
        >(
            this: *mut ffi::GDBusObjectSkeleton,
            interface: *mut ffi::GDBusInterfaceSkeleton,
            invocation: *mut ffi::GDBusMethodInvocation,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    DBusObjectSkeleton::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(interface),
                    &from_glib_borrow(invocation),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"authorize-method".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    authorize_method_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "g-object-path")]
    fn connect_g_object_path_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_g_object_path_trampoline<
            P: IsA<DBusObjectSkeleton>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDBusObjectSkeleton,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(DBusObjectSkeleton::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::g-object-path".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_g_object_path_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<DBusObjectSkeleton>> DBusObjectSkeletonExt for O {}