nm_rs/auto/

device_wifi.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir
// from gtk-girs (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT
#![allow(deprecated)]

use crate::{AccessPoint, Device, DeviceWifiCapabilities, NM80211Mode, Object, ffi};
use glib::{
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::{boxed::Box as Box_, pin::Pin};

glib::wrapper! {
    ///
    ///
    /// ## Properties
    ///
    ///
    /// #### `access-points`
    ///  List of all Wi-Fi access points the device can see.
    ///
    /// Readable
    ///
    ///
    /// #### `active-access-point`
    ///  The active #NMAccessPoint of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `bitrate`
    ///  The bit rate of the device in kbit/s.
    ///
    /// Readable
    ///
    ///
    /// #### `last-scan`
    ///  The timestamp (in CLOCK_BOOTTIME seconds) for the last finished
    /// network scan. A value of -1 means the device never scanned for
    /// access points.
    ///
    /// Readable
    ///
    ///
    /// #### `mode`
    ///  The mode of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `perm-hw-address`
    ///  The hardware (MAC) address of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `wireless-capabilities`
    ///  The wireless capabilities of the device.
    ///
    /// Readable
    /// <details><summary><h4>Device</h4></summary>
    ///
    ///
    /// #### `active-connection`
    ///  The #NMActiveConnection object that "owns" this device during activation.
    ///
    /// Readable
    ///
    ///
    /// #### `autoconnect`
    ///  Whether the device can auto-activate a connection.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `available-connections`
    ///  The available connections of the device
    ///
    /// Readable
    ///
    ///
    /// #### `capabilities`
    ///  The capabilities of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `device-type`
    ///  The numeric type of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `dhcp4-config`
    ///  The IPv4 #NMDhcpConfig of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `dhcp6-config`
    ///  The IPv6 #NMDhcpConfig of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `driver`
    ///  The driver of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `driver-version`
    ///  The version of the device driver.
    ///
    /// Readable
    ///
    ///
    /// #### `firmware-missing`
    ///  When [`true`] indicates the device is likely missing firmware required
    /// for its operation.
    ///
    /// Readable
    ///
    ///
    /// #### `firmware-version`
    ///  The firmware version of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `hw-address`
    ///  The hardware address of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `interface`
    ///  The interface of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `interface-flags`
    ///  The interface flags.
    ///
    /// Readable
    ///
    ///
    /// #### `ip-interface`
    ///  The IP interface of the device which should be used for all IP-related
    /// operations like addressing and routing.
    ///
    /// Readable
    ///
    ///
    /// #### `ip4-config`
    ///  The #NMIP4Config of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `ip4-connectivity`
    ///  The IPv4 connectivity state of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `ip6-config`
    ///  The IPv6 #NMIPConfig of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `ip6-connectivity`
    ///  The IPv6 connectivity state of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `lldp-neighbors`
    ///  The LLDP neighbors.
    ///
    /// Readable
    ///
    ///
    /// #### `managed`
    ///  Whether the device is managed by NetworkManager.
    ///
    /// Readable
    ///
    ///
    /// #### `metered`
    ///  Whether the device is metered.
    ///
    /// Readable
    ///
    ///
    /// #### `mtu`
    ///  The MTU of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `nm-plugin-missing`
    ///  When [`true`] indicates that the NetworkManager plugin for the device
    /// is not installed.
    ///
    /// Readable
    ///
    ///
    /// #### `path`
    ///  The device path as exposed by the udev property ID_PATH.
    ///
    /// The string is backslash escaped (C escaping) for invalid
    /// characters. The escaping can be reverted with g_strcompress(),
    /// however the result may not be valid UTF-8.
    ///
    /// Readable
    ///
    ///
    /// #### `physical-port-id`
    ///  The physical port ID of the device. (See
    /// nm_device_get_physical_port_id().)
    ///
    /// Readable
    ///
    ///
    /// #### `ports`
    ///  The port devices of the controller device. For devices that cannot be
    /// controllers this is likely to be always empty.
    ///
    /// Readable
    ///
    ///
    /// #### `product`
    ///  The product string of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `real`
    ///  Whether the device is real or is a placeholder device that could
    /// be created automatically by NetworkManager if one of its
    /// #NMDevice:available-connections was activated.
    ///
    /// Readable
    ///
    ///
    /// #### `state`
    ///  The state of the device.
    ///
    /// Readable
    ///
    ///
    /// #### `state-reason`
    ///  The reason for the device state.
    ///
    /// Readable
    ///
    ///
    /// #### `udi`
    ///  An operating-system specific device hardware identifier; this is not
    /// unique to a specific hardware device across reboots or hotplugs.  It
    /// is an opaque string which for some device types (Bluetooth, Modem)
    /// contains an identifier provided by the underlying hardware service daemon
    /// such as Bluez or ModemManager, and clients can use this property to
    /// request more information about the device from those services.
    ///
    /// Readable
    ///
    ///
    /// #### `vendor`
    ///  The vendor string of the device.
    ///
    /// Readable
    /// </details>
    /// <details><summary><h4>Object</h4></summary>
    ///
    ///
    /// #### `client`
    ///  The NMClient instance as returned by nm_object_get_client().
    ///
    /// When an NMObject gets removed from the NMClient cache,
    /// the NMObject:path property stays unchanged, but this client
    /// instance gets reset to [`None`]. You can use this property to
    /// track removal of the object from the cache.
    ///
    /// Readable
    ///
    ///
    /// #### `path`
    ///  The D-Bus object path.
    ///
    /// The D-Bus path of an object instance never changes, even if the object
    /// gets removed from the cache. To see whether the object is still in the
    /// cache, check NMObject:client.
    ///
    /// Readable
    /// </details>
    ///
    /// ## Signals
    ///
    ///
    /// #### `access-point-added`
    ///  Notifies that a #NMAccessPoint is added to the Wi-Fi device.
    ///
    ///
    ///
    ///
    /// #### `access-point-removed`
    ///  Notifies that a #NMAccessPoint is removed from the Wi-Fi device.
    ///
    ///
    /// <details><summary><h4>Device</h4></summary>
    ///
    ///
    /// #### `state-changed`
    ///  Notifies the state change of a #NMDevice.
    ///
    ///
    /// </details>
    ///
    /// # Implements
    ///
    /// [`DeviceExt`][trait@crate::prelude::DeviceExt], [`ObjectExt`][trait@crate::prelude::ObjectExt]
    #[doc(alias = "NMDeviceWifi")]
    pub struct DeviceWifi(Object<ffi::NMDeviceWifi, ffi::NMDeviceWifiClass>) @extends Device, Object;

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

impl DeviceWifi {
    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`DeviceWifi`] objects.
    ///
    /// This method returns an instance of [`DeviceWifiBuilder`](crate::builders::DeviceWifiBuilder) which can be used to create [`DeviceWifi`] objects.
    pub fn builder() -> DeviceWifiBuilder {
        DeviceWifiBuilder::new()
    }

    /// Gets a #NMAccessPoint by path.
    /// ## `path`
    /// the object path of the access point
    ///
    /// # Returns
    ///
    /// the access point or [`None`] if none is found.
    #[doc(alias = "nm_device_wifi_get_access_point_by_path")]
    #[doc(alias = "get_access_point_by_path")]
    pub fn access_point_by_path(&self, path: &str) -> AccessPoint {
        unsafe {
            from_glib_none(ffi::nm_device_wifi_get_access_point_by_path(
                self.to_glib_none().0,
                path.to_glib_none().0,
            ))
        }
    }

    /// Gets all the scanned access points of the #NMDeviceWifi.
    ///
    /// # Returns
    ///
    /// a #GPtrArray containing all the
    /// scanned #NMAccessPoints.
    /// The returned array is owned by the client and should not be modified.
    #[doc(alias = "nm_device_wifi_get_access_points")]
    #[doc(alias = "get_access_points")]
    #[doc(alias = "access-points")]
    pub fn access_points(&self) -> Vec<AccessPoint> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::nm_device_wifi_get_access_points(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the active #NMAccessPoint.
    ///
    /// # Returns
    ///
    /// the access point or [`None`] if none is active
    #[doc(alias = "nm_device_wifi_get_active_access_point")]
    #[doc(alias = "get_active_access_point")]
    #[doc(alias = "active-access-point")]
    pub fn active_access_point(&self) -> AccessPoint {
        unsafe {
            from_glib_none(ffi::nm_device_wifi_get_active_access_point(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the bit rate of the #NMDeviceWifi in kbit/s.
    ///
    /// # Returns
    ///
    /// the bit rate (kbit/s)
    #[doc(alias = "nm_device_wifi_get_bitrate")]
    #[doc(alias = "get_bitrate")]
    pub fn bitrate(&self) -> u32 {
        unsafe { ffi::nm_device_wifi_get_bitrate(self.to_glib_none().0) }
    }

    /// Gets the Wi-Fi capabilities of the #NMDeviceWifi.
    ///
    /// # Returns
    ///
    /// the capabilities
    #[doc(alias = "nm_device_wifi_get_capabilities")]
    #[doc(alias = "get_capabilities")]
    pub fn capabilities(&self) -> DeviceWifiCapabilities {
        unsafe { from_glib(ffi::nm_device_wifi_get_capabilities(self.to_glib_none().0)) }
    }

    /// Gets the actual hardware (MAC) address of the #NMDeviceWifi
    ///
    /// # Deprecated since 1.24
    ///
    /// Use nm_device_get_hw_address() instead.
    ///
    /// # Returns
    ///
    /// the actual hardware address. This is the internal string used by the
    /// device, and must not be modified.
    #[cfg_attr(feature = "v1_24", deprecated = "Since 1.24")]
    #[allow(deprecated)]
    #[doc(alias = "nm_device_wifi_get_hw_address")]
    #[doc(alias = "get_hw_address")]
    pub fn hw_address(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::nm_device_wifi_get_hw_address(self.to_glib_none().0)) }
    }

    /// Returns the timestamp (in CLOCK_BOOTTIME milliseconds) for the last finished
    /// network scan. A value of -1 means the device never scanned for access points.
    ///
    /// Use nm_utils_get_timestamp_msec() to obtain current time value suitable for
    /// comparing to this value.
    ///
    /// # Returns
    ///
    /// the last scan time in milliseconds (in clock_gettime(CLOCK_BOOTTIME) scale).
    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    #[doc(alias = "nm_device_wifi_get_last_scan")]
    #[doc(alias = "get_last_scan")]
    #[doc(alias = "last-scan")]
    pub fn last_scan(&self) -> i64 {
        unsafe { ffi::nm_device_wifi_get_last_scan(self.to_glib_none().0) }
    }

    /// Gets the #NMDeviceWifi mode.
    ///
    /// # Returns
    ///
    /// the mode
    #[doc(alias = "nm_device_wifi_get_mode")]
    #[doc(alias = "get_mode")]
    pub fn mode(&self) -> NM80211Mode {
        unsafe { from_glib(ffi::nm_device_wifi_get_mode(self.to_glib_none().0)) }
    }

    /// Gets the permanent hardware (MAC) address of the #NMDeviceWifi
    ///
    /// # Returns
    ///
    /// the permanent hardware address. This is the internal string used by the
    /// device, and must not be modified.
    #[doc(alias = "nm_device_wifi_get_permanent_hw_address")]
    #[doc(alias = "get_permanent_hw_address")]
    pub fn permanent_hw_address(&self) -> glib::GString {
        unsafe {
            from_glib_none(ffi::nm_device_wifi_get_permanent_hw_address(
                self.to_glib_none().0,
            ))
        }
    }

    /// Request NM to scan for access points on @self. Note that the function
    /// returns immediately after requesting the scan, and it may take some time
    /// after that for the scan to complete.
    ///
    /// # Deprecated since 1.22
    ///
    /// Use nm_device_wifi_request_scan_async() or GDBusConnection.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error, in which case @error will be
    /// set.
    #[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    #[allow(deprecated)]
    #[doc(alias = "nm_device_wifi_request_scan")]
    pub fn request_scan(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::nm_device_wifi_request_scan(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Request NM to scan for access points on @self. Note that @callback will be
    /// called immediately after requesting the scan, and it may take some time after
    /// that for the scan to complete.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to be called when the scan has been requested
    #[doc(alias = "nm_device_wifi_request_scan_async")]
    pub fn request_scan_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn request_scan_async_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            ffi::nm_device_wifi_request_scan_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = request_scan_async_trampoline::<P>;
        unsafe {
            ffi::nm_device_wifi_request_scan_async(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn request_scan_future(
        &self,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.request_scan_async(Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    //#[cfg_attr(feature = "v1_22", deprecated = "Since 1.22")]
    //#[cfg(feature = "v1_2")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    //#[allow(deprecated)]
    //#[doc(alias = "nm_device_wifi_request_scan_options")]
    //pub fn request_scan_options(&self, options: /*Ignored*/&glib::Variant, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> {
    //    unsafe { TODO: call ffi:nm_device_wifi_request_scan_options() }
    //}

    //#[cfg(feature = "v1_2")]
    //#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    //#[doc(alias = "nm_device_wifi_request_scan_options_async")]
    //pub fn request_scan_options_async<P: FnOnce(Result<(), glib::Error>) + 'static>(&self, options: /*Ignored*/&glib::Variant, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P) {
    //    unsafe { TODO: call ffi:nm_device_wifi_request_scan_options_async() }
    //}

    /// The hardware (MAC) address of the device.
    #[doc(alias = "perm-hw-address")]
    pub fn perm_hw_address(&self) -> Option<glib::GString> {
        ObjectExt::property(self, "perm-hw-address")
    }

    /// The wireless capabilities of the device.
    #[doc(alias = "wireless-capabilities")]
    pub fn wireless_capabilities(&self) -> DeviceWifiCapabilities {
        ObjectExt::property(self, "wireless-capabilities")
    }

    //#[doc(alias = "access-point-added")]
    //pub fn connect_access_point_added<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId {
    //    Ignored ap: GObject.Object
    //}

    //#[doc(alias = "access-point-removed")]
    //pub fn connect_access_point_removed<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId {
    //    Ignored ap: GObject.Object
    //}

    #[doc(alias = "access-points")]
    pub fn connect_access_points_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_access_points_trampoline<F: Fn(&DeviceWifi) + 'static>(
            this: *mut ffi::NMDeviceWifi,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::access-points".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_access_points_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "active-access-point")]
    pub fn connect_active_access_point_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_active_access_point_trampoline<F: Fn(&DeviceWifi) + 'static>(
            this: *mut ffi::NMDeviceWifi,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::active-access-point".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_active_access_point_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "bitrate")]
    pub fn connect_bitrate_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_bitrate_trampoline<F: Fn(&DeviceWifi) + 'static>(
            this: *mut ffi::NMDeviceWifi,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::bitrate".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_bitrate_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_12")))]
    #[doc(alias = "last-scan")]
    pub fn connect_last_scan_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_last_scan_trampoline<F: Fn(&DeviceWifi) + 'static>(
            this: *mut ffi::NMDeviceWifi,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::last-scan".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_last_scan_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "mode")]
    pub fn connect_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_mode_trampoline<F: Fn(&DeviceWifi) + 'static>(
            this: *mut ffi::NMDeviceWifi,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::mode".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_mode_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "perm-hw-address")]
    pub fn connect_perm_hw_address_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_perm_hw_address_trampoline<F: Fn(&DeviceWifi) + 'static>(
            this: *mut ffi::NMDeviceWifi,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::perm-hw-address".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_perm_hw_address_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "wireless-capabilities")]
    pub fn connect_wireless_capabilities_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_wireless_capabilities_trampoline<
            F: Fn(&DeviceWifi) + 'static,
        >(
            this: *mut ffi::NMDeviceWifi,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::wireless-capabilities".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_wireless_capabilities_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`DeviceWifi`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct DeviceWifiBuilder {
    builder: glib::object::ObjectBuilder<'static, DeviceWifi>,
}

impl DeviceWifiBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    /// Whether the device can auto-activate a connection.
    ///
    /// The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
    pub fn autoconnect(self, autoconnect: bool) -> Self {
        Self {
            builder: self.builder.property("autoconnect", autoconnect),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`DeviceWifi`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> DeviceWifi {
        assert_initialized_main_thread!();
        self.builder.build()
    }
}