async_roundtrip/common/protocols_data/wayland/

wl_display.rs

//! core global object
//!
//! The core global object.  This is a special singleton object.  It
//! is used for internal Wayland protocol features.

use {super::super::all_types::*, ::wl_client::builder::prelude::*};

static INTERFACE: wl_interface = wl_interface {
    name: c"wl_display".as_ptr(),
    version: 1,
    method_count: 2,
    methods: {
        static MESSAGES: [wl_message; 2] = [
            wl_message {
                name: c"sync".as_ptr(),
                signature: c"n".as_ptr(),
                types: {
                    static TYPES: [Option<&'static wl_interface>; 1] =
                        [Some(WlCallback::WL_INTERFACE)];
                    TYPES.as_ptr().cast()
                },
            },
            wl_message {
                name: c"get_registry".as_ptr(),
                signature: c"n".as_ptr(),
                types: {
                    static TYPES: [Option<&'static wl_interface>; 1] =
                        [Some(WlRegistry::WL_INTERFACE)];
                    TYPES.as_ptr().cast()
                },
            },
        ];
        MESSAGES.as_ptr()
    },
    event_count: 2,
    events: {
        static MESSAGES: [wl_message; 2] = [
            wl_message {
                name: c"error".as_ptr(),
                signature: c"ous".as_ptr(),
                types: {
                    static TYPES: [Option<&'static wl_interface>; 3] = [None, None, None];
                    TYPES.as_ptr().cast()
                },
            },
            wl_message {
                name: c"delete_id".as_ptr(),
                signature: c"u".as_ptr(),
                types: {
                    static TYPES: [Option<&'static wl_interface>; 1] = [None];
                    TYPES.as_ptr().cast()
                },
            },
        ];
        MESSAGES.as_ptr()
    },
};

/// An owned wl_display proxy.
///
/// See the documentation of [the module][self] for the interface description.
#[derive(Clone, Eq, PartialEq)]
#[repr(transparent)]
pub struct WlDisplay {
    /// This proxy has the interface INTERFACE.
    proxy: UntypedOwnedProxy,
}

/// A borrowed wl_display proxy.
///
/// See the documentation of [the module][self] for the interface description.
#[derive(Eq, PartialEq)]
#[repr(transparent)]
pub struct WlDisplayRef {
    /// This proxy has the interface INTERFACE.
    proxy: UntypedBorrowedProxy,
}

// SAFETY: WlDisplay is a transparent wrapper around UntypedOwnedProxy
unsafe impl UntypedOwnedProxyWrapper for WlDisplay {}

// SAFETY: - INTERFACE is a valid wl_interface
//         - The only invariant is that self.proxy has a compatible interface
unsafe impl OwnedProxy for WlDisplay {
    const INTERFACE: &'static str = "wl_display";
    const WL_INTERFACE: &'static wl_interface = &INTERFACE;
    const NO_OP_EVENT_HANDLER: Self::NoOpEventHandler =
        private::EventHandler(private::NoOpEventHandler);
    const MAX_VERSION: u32 = 1;

    type Borrowed = WlDisplayRef;
    type Api = private::ProxyApi;
    type NoOpEventHandler = private::EventHandler<private::NoOpEventHandler>;
}

// SAFETY: WlDisplayRef is a transparent wrapper around UntypedBorrowedProxy
unsafe impl UntypedBorrowedProxyWrapper for WlDisplayRef {}

// SAFETY: - The only invariant is that self.proxy has a compatible interface
unsafe impl BorrowedProxy for WlDisplayRef {
    type Owned = WlDisplay;
}

impl Deref for WlDisplay {
    type Target = WlDisplayRef;

    fn deref(&self) -> &Self::Target {
        proxy::low_level::deref(self)
    }
}

mod private {
    pub struct ProxyApi;

    #[allow(dead_code)]
    pub struct EventHandler<H>(pub(super) H);

    #[allow(dead_code)]
    pub struct NoOpEventHandler;
}

impl Debug for WlDisplay {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "wl_display#{}", self.proxy.id())
    }
}

impl Debug for WlDisplayRef {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "wl_display#{}", self.proxy.id())
    }
}

impl PartialEq<WlDisplayRef> for WlDisplay {
    fn eq(&self, other: &WlDisplayRef) -> bool {
        self.proxy == other.proxy
    }
}

impl PartialEq<WlDisplay> for WlDisplayRef {
    fn eq(&self, other: &WlDisplay) -> bool {
        self.proxy == other.proxy
    }
}

#[allow(dead_code)]
impl WlDisplay {
    /// Since when the sync request is available.
    #[allow(dead_code)]
    pub const REQ__SYNC__SINCE: u32 = 1;

    /// asynchronous roundtrip
    ///
    /// The sync request asks the server to emit the 'done' event
    /// on the returned wl_callback object.  Since requests are
    /// handled in-order and events are delivered in-order, this can
    /// be used as a barrier to ensure all previous requests and the
    /// resulting events have been handled.
    ///
    /// The object returned by this request will be destroyed by the
    /// compositor after the callback is fired and as such the client must not
    /// attempt to use it after that point.
    ///
    /// The callback_data passed in the callback is undefined and should be ignored.
    #[inline]
    pub fn sync(&self) -> WlCallback {
        let mut args = [wl_argument { n: 0 }];
        // SAFETY: - self.proxy has the interface INTERFACE
        //         - 0 < INTERFACE.method_count = 2
        //         - the request signature is `n`
        //         - OwnedProxy::WL_INTERFACE is always a valid interface
        let data = unsafe {
            self.proxy
                .send_constructor::<false>(0, &mut args, WlCallback::WL_INTERFACE, None)
        };
        // SAFETY: data has the interface WlCallback::WL_INTERFACE
        unsafe { proxy::low_level::from_untyped_owned(data) }
    }

    /// Since when the get_registry request is available.
    #[allow(dead_code)]
    pub const REQ__GET_REGISTRY__SINCE: u32 = 1;

    /// get global registry object
    ///
    /// This request creates a registry object that allows the client
    /// to list and bind the global objects available from the
    /// compositor.
    ///
    /// It should be noted that the server side resources consumed in
    /// response to a get_registry request can only be released when the
    /// client disconnects, not when the client side proxy is destroyed.
    /// Therefore, clients should invoke get_registry as infrequently as
    /// possible to avoid wasting memory.
    #[inline]
    pub fn get_registry(&self) -> WlRegistry {
        let mut args = [wl_argument { n: 0 }];
        // SAFETY: - self.proxy has the interface INTERFACE
        //         - 1 < INTERFACE.method_count = 2
        //         - the request signature is `n`
        //         - OwnedProxy::WL_INTERFACE is always a valid interface
        let data = unsafe {
            self.proxy
                .send_constructor::<false>(1, &mut args, WlRegistry::WL_INTERFACE, None)
        };
        // SAFETY: data has the interface WlRegistry::WL_INTERFACE
        unsafe { proxy::low_level::from_untyped_owned(data) }
    }
}

#[allow(dead_code)]
impl WlDisplayRef {
    /// asynchronous roundtrip
    ///
    /// The sync request asks the server to emit the 'done' event
    /// on the returned wl_callback object.  Since requests are
    /// handled in-order and events are delivered in-order, this can
    /// be used as a barrier to ensure all previous requests and the
    /// resulting events have been handled.
    ///
    /// The object returned by this request will be destroyed by the
    /// compositor after the callback is fired and as such the client must not
    /// attempt to use it after that point.
    ///
    /// The callback_data passed in the callback is undefined and should be ignored.
    ///
    /// # Arguments
    ///
    /// - `_queue`: The queue that the returned proxy is assigned to.
    #[inline]
    pub fn sync(&self, _queue: &Queue) -> WlCallback {
        let mut args = [wl_argument { n: 0 }];
        // SAFETY: - self.proxy has the interface INTERFACE
        //         - 0 < INTERFACE.method_count = 2
        //         - the request signature is `n`
        //         - OwnedProxy::WL_INTERFACE is always a valid interface
        let data = unsafe {
            self.proxy
                .send_constructor(_queue, 0, &mut args, WlCallback::WL_INTERFACE, None)
        };
        // SAFETY: data has the interface WlCallback::WL_INTERFACE
        unsafe { proxy::low_level::from_untyped_owned(data) }
    }

    /// get global registry object
    ///
    /// This request creates a registry object that allows the client
    /// to list and bind the global objects available from the
    /// compositor.
    ///
    /// It should be noted that the server side resources consumed in
    /// response to a get_registry request can only be released when the
    /// client disconnects, not when the client side proxy is destroyed.
    /// Therefore, clients should invoke get_registry as infrequently as
    /// possible to avoid wasting memory.
    ///
    /// # Arguments
    ///
    /// - `_queue`: The queue that the returned proxy is assigned to.
    #[inline]
    pub fn get_registry(&self, _queue: &Queue) -> WlRegistry {
        let mut args = [wl_argument { n: 0 }];
        // SAFETY: - self.proxy has the interface INTERFACE
        //         - 1 < INTERFACE.method_count = 2
        //         - the request signature is `n`
        //         - OwnedProxy::WL_INTERFACE is always a valid interface
        let data = unsafe {
            self.proxy
                .send_constructor(_queue, 1, &mut args, WlRegistry::WL_INTERFACE, None)
        };
        // SAFETY: data has the interface WlRegistry::WL_INTERFACE
        unsafe { proxy::low_level::from_untyped_owned(data) }
    }
}

impl WlDisplay {
    /// Since when the error event is available.
    #[allow(dead_code)]
    pub const EVT__ERROR__SINCE: u32 = 1;

    /// Since when the delete_id event is available.
    #[allow(dead_code)]
    pub const EVT__DELETE_ID__SINCE: u32 = 1;
}

/// An event handler for [WlDisplay] proxies.
#[allow(dead_code)]
pub trait WlDisplayEventHandler {
    type Data: 'static;

    /// fatal error event
    ///
    /// The error event is sent out when a fatal (non-recoverable)
    /// error has occurred.  The object_id argument is the object
    /// where the error occurred, most often in response to a request
    /// to that object.  The code identifies the error and is defined
    /// by the object interface.  As such, each interface defines its
    /// own set of error codes.  The message is a brief description
    /// of the error, for (debugging) convenience.
    ///
    /// # Arguments
    ///
    /// - `object_id`: object where the error occurred
    /// - `code`: error code
    /// - `message`: error description
    ///
    /// All borrowed proxies passed to this function are guaranteed to be
    /// immutable and non-null.
    #[inline]
    fn error(
        &self,
        _data: &mut Self::Data,
        _slf: &WlDisplayRef,
        object_id: Option<&UntypedBorrowedProxy>,
        code: u32,
        message: &str,
    ) {
        let _ = object_id;
        let _ = code;
        let _ = message;
    }

    /// acknowledge object ID deletion
    ///
    /// This event is used internally by the object ID management
    /// logic. When a client deletes an object that it had created,
    /// the server will send this event to acknowledge that it has
    /// seen the delete request. When the client receives this event,
    /// it will know that it can safely reuse the object ID.
    ///
    /// # Arguments
    ///
    /// - `id`: deleted object ID
    #[inline]
    fn delete_id(&self, _data: &mut Self::Data, _slf: &WlDisplayRef, id: u32) {
        let _ = id;
    }
}

impl WlDisplayEventHandler for private::NoOpEventHandler {
    type Data = ();
}

// SAFETY: - INTERFACE is a valid wl_interface
//         - mutable_type always returns the same value
unsafe impl<H> EventHandler for private::EventHandler<H>
where
    H: WlDisplayEventHandler,
{
    const WL_INTERFACE: &'static wl_interface = &INTERFACE;

    #[inline]
    fn mutable_type() -> Option<(TypeId, &'static str)> {
        let id = TypeId::of::<H::Data>();
        let name = std::any::type_name::<H::Data>();
        Some((id, name))
    }

    #[allow(unused_variables)]
    unsafe fn handle_event(
        &self,
        queue: &Queue,
        data: *mut u8,
        slf: &UntypedBorrowedProxy,
        opcode: u32,
        args: *mut wl_argument,
    ) {
        // SAFETY: This function requires that slf has the interface INTERFACE
        let slf = unsafe { proxy::low_level::from_untyped_borrowed::<WlDisplayRef>(slf) };
        // SAFETY: This function requires that data is `&mut T` where `T`
        //         has the type id returned by `Self::mutable_type`, i.e.,
        //         `T = H::Data`.
        let data: &mut H::Data = unsafe { &mut *data.cast() };
        match opcode {
            0 => {
                // SAFETY: INTERFACE requires that there are 3 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 3]>() };
                // SAFETY: - INTERFACE requires that args[0] contains an object
                let arg0 = unsafe {
                    if let Some(p) = NonNull::new(args[0].o.cast()) {
                        Some(UntypedBorrowedProxy::new_immutable(queue.libwayland(), p))
                    } else {
                        None
                    }
                };
                let arg0 = arg0.as_ref();
                // SAFETY: - INTERFACE requires that args[1] contains a uint
                let arg1 = unsafe { args[1].u };
                // SAFETY: - INTERFACE requires that args[2] contains a string
                //         - if the pointer is not null, then it is a c string
                let arg2 = unsafe { convert_string_arg("wl_display", "message", args[2].s) };
                self.0.error(data, slf, arg0, arg1, arg2);
            }
            1 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                self.0.delete_id(data, slf, arg0);
            }
            _ => {
                invalid_opcode("wl_display", opcode);
            }
        }
    }
}

impl<H> CreateEventHandler<H> for private::ProxyApi
where
    H: WlDisplayEventHandler,
{
    type EventHandler = private::EventHandler<H>;

    #[inline]
    fn create_event_handler(handler: H) -> Self::EventHandler {
        private::EventHandler(handler)
    }
}

impl WlDisplay {
    /// Since when the error.invalid_object enum variant is available.
    #[allow(dead_code)]
    pub const ENM__ERROR_INVALID_OBJECT__SINCE: u32 = 1;
    /// Since when the error.invalid_method enum variant is available.
    #[allow(dead_code)]
    pub const ENM__ERROR_INVALID_METHOD__SINCE: u32 = 1;
    /// Since when the error.no_memory enum variant is available.
    #[allow(dead_code)]
    pub const ENM__ERROR_NO_MEMORY__SINCE: u32 = 1;
    /// Since when the error.implementation enum variant is available.
    #[allow(dead_code)]
    pub const ENM__ERROR_IMPLEMENTATION__SINCE: u32 = 1;
}

/// global error values
///
/// These errors are global and can be emitted in response to any
/// server request.
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[allow(dead_code)]
pub struct WlDisplayError(pub u32);

impl WlDisplayError {
    /// server couldn't find object
    #[allow(dead_code)]
    pub const INVALID_OBJECT: Self = Self(0);

    /// method doesn't exist on the specified interface or malformed request
    #[allow(dead_code)]
    pub const INVALID_METHOD: Self = Self(1);

    /// server is out of memory
    #[allow(dead_code)]
    pub const NO_MEMORY: Self = Self(2);

    /// implementation error in compositor
    #[allow(dead_code)]
    pub const IMPLEMENTATION: Self = Self(3);
}

impl Debug for WlDisplayError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let name = match *self {
            Self::INVALID_OBJECT => "INVALID_OBJECT",
            Self::INVALID_METHOD => "INVALID_METHOD",
            Self::NO_MEMORY => "NO_MEMORY",
            Self::IMPLEMENTATION => "IMPLEMENTATION",
            _ => return Debug::fmt(&self.0, f),
        };
        f.write_str(name)
    }
}

/// Functional event handlers.
pub mod event_handlers {
    use super::*;

    /// Event handler for error events.
    pub struct Error<T, F>(F, PhantomData<fn(&mut T)>);
    impl<T, F> WlDisplayEventHandler for Error<T, F>
    where
        T: 'static,
        F: Fn(&mut T, &WlDisplayRef, Option<&UntypedBorrowedProxy>, u32, &str),
    {
        type Data = T;

        #[inline]
        fn error(
            &self,
            _data: &mut T,
            _slf: &WlDisplayRef,
            object_id: Option<&UntypedBorrowedProxy>,
            code: u32,
            message: &str,
        ) {
            self.0(_data, _slf, object_id, code, message)
        }
    }

    /// Event handler for delete_id events.
    pub struct DeleteId<T, F>(F, PhantomData<fn(&mut T)>);
    impl<T, F> WlDisplayEventHandler for DeleteId<T, F>
    where
        T: 'static,
        F: Fn(&mut T, &WlDisplayRef, u32),
    {
        type Data = T;

        #[inline]
        fn delete_id(&self, _data: &mut T, _slf: &WlDisplayRef, id: u32) {
            self.0(_data, _slf, id)
        }
    }

    impl WlDisplay {
        /// Creates an event handler for error events.
        ///
        /// The event handler ignores all other events.
        #[allow(dead_code)]
        pub fn on_error<T, F>(f: F) -> Error<T, F>
        where
            T: 'static,
            F: Fn(&mut T, &WlDisplayRef, Option<&UntypedBorrowedProxy>, u32, &str),
        {
            Error(f, PhantomData)
        }

        /// Creates an event handler for delete_id events.
        ///
        /// The event handler ignores all other events.
        #[allow(dead_code)]
        pub fn on_delete_id<T, F>(f: F) -> DeleteId<T, F>
        where
            T: 'static,
            F: Fn(&mut T, &WlDisplayRef, u32),
        {
            DeleteId(f, PhantomData)
        }
    }
}