wayland_client_protocol/

wayland_client_protocol.rs

// GENERATED FILE -- DO NOT EDIT
//
// Copyright © 2008-2011 Kristian Høgsberg
// Copyright © 2010-2011 Intel Corporation
// Copyright © 2012-2013 Collabora, Ltd.
// 
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation files
// (the "Software"), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
// 
// The above copyright notice and this permission notice (including the
// next paragraph) shall be included in all copies or substantial
// portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

#![allow(warnings)]
#![allow(clippy::all)]
use anyhow;
#[allow(unused_imports)]
use fuchsia_wayland_core::{Array, Enum, Fixed, NewId, NewObject};
use fuchsia_wayland_core::{ArgKind, Arg, FromArgs, IntoMessage, Message,
                            MessageGroupSpec, MessageHeader, MessageSpec, MessageType,
                            ObjectId, EncodeError, DecodeError, Interface};
pub mod wl_display {
use super::*;

/// core global object
///
/// The core global object.  This is a special singleton object.  It
/// is used for internal Wayland protocol features.
#[derive(Debug)]
pub struct WlDisplay;

impl Interface for WlDisplay {
    const NAME: &'static str = "wl_display";
    const VERSION: u32 = 1;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // sync
        MessageSpec(&[
            ArgKind::NewId,
        ]),
        // get_registry
        MessageSpec(&[
            ArgKind::NewId,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // error
        MessageSpec(&[
            ArgKind::Object,
            ArgKind::Uint,
            ArgKind::String,
        ]),
        // delete_id
        MessageSpec(&[
            ArgKind::Uint,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// 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 the event serial.
    Sync {
        /// callback object for the sync request
        callback: NewId,
    },

    /// 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.
    GetRegistry {
        /// global registry object
        registry: NewId,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::Sync {
                ref callback,
            } => {
                format!("wl_display@{:?}::sync(callback: {:?})", this, callback)
            }
            Request::GetRegistry {
                ref registry,
            } => {
                format!("wl_display@{:?}::get_registry(registry: {:?})", this, registry)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::Sync { .. } => c"wl_display::sync",
            Request::GetRegistry { .. } => c"wl_display::get_registry",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// 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.
    Error {
        /// object where the error occurred
        object_id: ObjectId,
        /// error code
        code: u32,
        /// error description
        message: String,
    },

    /// 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.
    DeleteId {
        /// deleted object ID
        id: u32,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Error {
                ref object_id,
                ref code,
                ref message,
            } => {
                format!("wl_display@{:?}::error(object_id: {:?}, code: {:?}, message: {:?})", this, object_id, code, message)
            }
            Event::DeleteId {
                ref id,
            } => {
                format!("wl_display@{:?}::delete_id(id: {:?})", this, id)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Error { .. } => c"wl_display::error",
            Event::DeleteId { .. } => c"wl_display::delete_id",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::Sync {
            callback,
        } => {
            msg.write_arg(Arg::NewId(callback))?;
            header.opcode = 0;
        },
        Request::GetRegistry {
            registry,
        } => {
            msg.write_arg(Arg::NewId(registry))?;
            header.opcode = 1;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* error */ => {
            let mut iter = args.into_iter();
            Ok(Event::Error {
                object_id: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_object()?,
                code: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                message: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_string()?,

            })
        },
        1 /* delete_id */ => {
            let mut iter = args.into_iter();
            Ok(Event::DeleteId {
                id: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}

/// global error values
///
/// These errors are global and can be emitted in response to any
/// server request.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Error {
    /// server couldn't find object,
    InvalidObject = 0,
    /// method doesn't exist on the specified interface or malformed request,
    InvalidMethod = 1,
    /// server is out of memory,
    NoMemory = 2,
    /// implementation error in compositor,
    Implementation = 3,
}

impl Error {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Error::InvalidObject),
        1 => Some(Error::InvalidMethod),
        2 => Some(Error::NoMemory),
        3 => Some(Error::Implementation),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Error {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_display

pub use crate::wl_display::WlDisplay;
pub use crate::wl_display::Request as WlDisplayRequest;
pub use crate::wl_display::Event as WlDisplayEvent;
pub mod wl_registry {
use super::*;

/// global registry object
///
/// The singleton global registry object.  The server has a number of
/// global objects that are available to all clients.  These objects
/// typically represent an actual object in the server (for example,
/// an input device) or they are singleton objects that provide
/// extension functionality.
/// 
/// When a client creates a registry object, the registry object
/// will emit a global event for each global currently in the
/// registry.  Globals come and go as a result of device or
/// monitor hotplugs, reconfiguration or other events, and the
/// registry will send out global and global_remove events to
/// keep the client up to date with the changes.  To mark the end
/// of the initial burst of events, the client can use the
/// wl_display.sync request immediately after calling
/// wl_display.get_registry.
/// 
/// A client can bind to a global object by using the bind
/// request.  This creates a client-side handle that lets the object
/// emit events to the client and lets the client invoke requests on
/// the object.
#[derive(Debug)]
pub struct WlRegistry;

impl Interface for WlRegistry {
    const NAME: &'static str = "wl_registry";
    const VERSION: u32 = 1;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // bind
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::String,
            ArgKind::Uint,
            ArgKind::NewId,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // global
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::String,
            ArgKind::Uint,
        ]),
        // global_remove
        MessageSpec(&[
            ArgKind::Uint,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// bind an object to the display
    ///
    /// Binds a new, client-created object to the server using the
    /// specified name as the identifier.
    Bind {
        /// unique numeric name of the object
        name: u32,
        id_interface_name: String,
        id_interface_version: u32,
        /// bounded object
        id: NewId,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::Bind {
                ref name,
                ref id_interface_name,
                ref id_interface_version,
                ref id,
            } => {
                format!("wl_registry@{:?}::bind(name: {:?}, id_interface_name: {:?}, id_interface_version: {:?}, id: {:?})", this, name, id_interface_name, id_interface_version, id)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::Bind { .. } => c"wl_registry::bind",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// announce global object
    ///
    /// Notify the client of global objects.
    /// 
    /// The event notifies the client that a global object with
    /// the given name is now available, and it implements the
    /// given version of the given interface.
    Global {
        /// numeric name of the global object
        name: u32,
        /// interface implemented by the object
        interface: String,
        /// interface version
        version: u32,
    },

    /// announce removal of global object
    ///
    /// Notify the client of removed global objects.
    /// 
    /// This event notifies the client that the global identified
    /// by name is no longer available.  If the client bound to
    /// the global using the bind request, the client should now
    /// destroy that object.
    /// 
    /// The object remains valid and requests to the object will be
    /// ignored until the client destroys it, to avoid races between
    /// the global going away and a client sending a request to it.
    GlobalRemove {
        /// numeric name of the global object
        name: u32,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Global {
                ref name,
                ref interface,
                ref version,
            } => {
                format!("wl_registry@{:?}::global(name: {:?}, interface: {:?}, version: {:?})", this, name, interface, version)
            }
            Event::GlobalRemove {
                ref name,
            } => {
                format!("wl_registry@{:?}::global_remove(name: {:?})", this, name)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Global { .. } => c"wl_registry::global",
            Event::GlobalRemove { .. } => c"wl_registry::global_remove",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::Bind {
            name,
            id_interface_name,
            id_interface_version,
            id,
        } => {
            msg.write_arg(Arg::Uint(name))?;
            msg.write_arg(Arg::String(id_interface_name))?;
            msg.write_arg(Arg::Uint(id_interface_version))?;
            msg.write_arg(Arg::NewId(id))?;
            header.opcode = 0;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* global */ => {
            let mut iter = args.into_iter();
            Ok(Event::Global {
                name: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                interface: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_string()?,
                version: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,

            })
        },
        1 /* global_remove */ => {
            let mut iter = args.into_iter();
            Ok(Event::GlobalRemove {
                name: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
} // mod wl_registry

pub use crate::wl_registry::WlRegistry;
pub use crate::wl_registry::Request as WlRegistryRequest;
pub use crate::wl_registry::Event as WlRegistryEvent;
pub mod wl_callback {
use super::*;

/// callback object
///
/// Clients can handle the 'done' event to get notified when
/// the related request is done.
#[derive(Debug)]
pub struct WlCallback;

impl Interface for WlCallback {
    const NAME: &'static str = "wl_callback";
    const VERSION: u32 = 1;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // done
        MessageSpec(&[
            ArgKind::Uint,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// done event
    ///
    /// Notify the client when the related request is done.
    Done {
        /// request-specific data for the callback
        callback_data: u32,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Done {
                ref callback_data,
            } => {
                format!("wl_callback@{:?}::done(callback_data: {:?})", this, callback_data)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Done { .. } => c"wl_callback::done",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* done */ => {
            let mut iter = args.into_iter();
            Ok(Event::Done {
                callback_data: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
} // mod wl_callback

pub use crate::wl_callback::WlCallback;
pub use crate::wl_callback::Request as WlCallbackRequest;
pub use crate::wl_callback::Event as WlCallbackEvent;
pub mod wl_compositor {
use super::*;

/// the compositor singleton
///
/// A compositor.  This object is a singleton global.  The
/// compositor is in charge of combining the contents of multiple
/// surfaces into one displayable output.
#[derive(Debug)]
pub struct WlCompositor;

impl Interface for WlCompositor {
    const NAME: &'static str = "wl_compositor";
    const VERSION: u32 = 4;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // create_surface
        MessageSpec(&[
            ArgKind::NewId,
        ]),
        // create_region
        MessageSpec(&[
            ArgKind::NewId,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// create new surface
    ///
    /// Ask the compositor to create a new surface.
    CreateSurface {
        /// the new surface
        id: NewId,
    },

    /// create new region
    ///
    /// Ask the compositor to create a new region.
    CreateRegion {
        /// the new region
        id: NewId,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::CreateSurface {
                ref id,
            } => {
                format!("wl_compositor@{:?}::create_surface(id: {:?})", this, id)
            }
            Request::CreateRegion {
                ref id,
            } => {
                format!("wl_compositor@{:?}::create_region(id: {:?})", this, id)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::CreateSurface { .. } => c"wl_compositor::create_surface",
            Request::CreateRegion { .. } => c"wl_compositor::create_region",
        }
    }
}
#[derive(Debug)]
pub enum Event {
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::CreateSurface {
            id,
        } => {
            msg.write_arg(Arg::NewId(id))?;
            header.opcode = 0;
        },
        Request::CreateRegion {
            id,
        } => {
            msg.write_arg(Arg::NewId(id))?;
            header.opcode = 1;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
} // mod wl_compositor

pub use crate::wl_compositor::WlCompositor;
pub use crate::wl_compositor::Request as WlCompositorRequest;
pub use crate::wl_compositor::Event as WlCompositorEvent;
pub mod wl_shm_pool {
use super::*;

/// a shared memory pool
///
/// The wl_shm_pool object encapsulates a piece of memory shared
/// between the compositor and client.  Through the wl_shm_pool
/// object, the client can allocate shared memory wl_buffer objects.
/// All objects created through the same pool share the same
/// underlying mapped memory. Reusing the mapped memory avoids the
/// setup/teardown overhead and is useful when interactively resizing
/// a surface or for many small buffers.
#[derive(Debug)]
pub struct WlShmPool;

impl Interface for WlShmPool {
    const NAME: &'static str = "wl_shm_pool";
    const VERSION: u32 = 1;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // create_buffer
        MessageSpec(&[
            ArgKind::NewId,
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Uint,
        ]),
        // destroy
        MessageSpec(&[
        ]),
        // resize
        MessageSpec(&[
            ArgKind::Int,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// create a buffer from the pool
    ///
    /// Create a wl_buffer object from the pool.
    /// 
    /// The buffer is created offset bytes into the pool and has
    /// width and height as specified.  The stride argument specifies
    /// the number of bytes from the beginning of one row to the beginning
    /// of the next.  The format is the pixel format of the buffer and
    /// must be one of those advertised through the wl_shm.format event.
    /// 
    /// A buffer will keep a reference to the pool it was created from
    /// so it is valid to destroy the pool immediately after creating
    /// a buffer from it.
    CreateBuffer {
        /// buffer to create
        id: NewId,
        /// buffer byte offset within the pool
        offset: i32,
        /// buffer width, in pixels
        width: i32,
        /// buffer height, in pixels
        height: i32,
        /// number of bytes from the beginning of one row to the beginning of the next row
        stride: i32,
        /// buffer pixel format
        format: crate::wl_shm::Format,
    },

    /// destroy the pool
    ///
    /// Destroy the shared memory pool.
    /// 
    /// The mmapped memory will be released when all
    /// buffers that have been created from this pool
    /// are gone.
    Destroy,

    /// change the size of the pool mapping
    ///
    /// This request will cause the server to remap the backing memory
    /// for the pool from the file descriptor passed when the pool was
    /// created, but using the new size.  This request can only be
    /// used to make the pool bigger.
    Resize {
        /// new size of the pool, in bytes
        size: i32,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::CreateBuffer {
                ref id,
                ref offset,
                ref width,
                ref height,
                ref stride,
                ref format,
            } => {
                format!("wl_shm_pool@{:?}::create_buffer(id: {:?}, offset: {:?}, width: {:?}, height: {:?}, stride: {:?}, format: {:?})", this, id, offset, width, height, stride, format)
            }
            Request::Destroy {
            } => {
                format!("wl_shm_pool@{:?}::destroy()", this)
            }
            Request::Resize {
                ref size,
            } => {
                format!("wl_shm_pool@{:?}::resize(size: {:?})", this, size)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::CreateBuffer { .. } => c"wl_shm_pool::create_buffer",
            Request::Destroy { .. } => c"wl_shm_pool::destroy",
            Request::Resize { .. } => c"wl_shm_pool::resize",
        }
    }
}
#[derive(Debug)]
pub enum Event {
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::CreateBuffer {
            id,
            offset,
            width,
            height,
            stride,
            format,
        } => {
            msg.write_arg(Arg::NewId(id))?;
            msg.write_arg(Arg::Int(offset))?;
            msg.write_arg(Arg::Int(width))?;
            msg.write_arg(Arg::Int(height))?;
            msg.write_arg(Arg::Int(stride))?;
            msg.write_arg(Arg::Uint(format.bits()))?;
            header.opcode = 0;
        },
        Request::Destroy {
        } => {
            header.opcode = 1;
        },
        Request::Resize {
            size,
        } => {
            msg.write_arg(Arg::Int(size))?;
            header.opcode = 2;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
} // mod wl_shm_pool

pub use crate::wl_shm_pool::WlShmPool;
pub use crate::wl_shm_pool::Request as WlShmPoolRequest;
pub use crate::wl_shm_pool::Event as WlShmPoolEvent;
pub mod wl_shm {
use super::*;

/// shared memory support
///
/// A singleton global object that provides support for shared
/// memory.
/// 
/// Clients can create wl_shm_pool objects using the create_pool
/// request.
/// 
/// At connection setup time, the wl_shm object emits one or more
/// format events to inform clients about the valid pixel formats
/// that can be used for buffers.
#[derive(Debug)]
pub struct WlShm;

impl Interface for WlShm {
    const NAME: &'static str = "wl_shm";
    const VERSION: u32 = 1;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // create_pool
        MessageSpec(&[
            ArgKind::NewId,
            ArgKind::Handle,
            ArgKind::Int,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // format
        MessageSpec(&[
            ArgKind::Uint,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// create a shm pool
    ///
    /// Create a new wl_shm_pool object.
    /// 
    /// The pool can be used to create shared memory based buffer
    /// objects.  The server will mmap size bytes of the passed file
    /// descriptor, to use as backing memory for the pool.
    CreatePool {
        /// pool to create
        id: NewId,
        /// file descriptor for the pool
        fd: zx::Handle,
        /// pool size, in bytes
        size: i32,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::CreatePool {
                ref id,
                ref fd,
                ref size,
            } => {
                format!("wl_shm@{:?}::create_pool(id: {:?}, fd: <handle>, size: {:?})", this, id, size)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::CreatePool { .. } => c"wl_shm::create_pool",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// pixel format description
    ///
    /// Informs the client about a valid pixel format that
    /// can be used for buffers. Known formats include
    /// argb8888 and xrgb8888.
    Format {
        /// buffer pixel format
        format: Enum<Format>,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Format {
                ref format,
            } => {
                format!("wl_shm@{:?}::format(format: {:?})", this, format)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Format { .. } => c"wl_shm::format",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::CreatePool {
            id,
            fd,
            size,
        } => {
            msg.write_arg(Arg::NewId(id))?;
            msg.write_arg(Arg::Handle(fd))?;
            msg.write_arg(Arg::Int(size))?;
            header.opcode = 0;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* format */ => {
            let mut iter = args.into_iter();
            Ok(Event::Format {
                format: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match Format::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}

/// wl_shm error values
///
/// These errors can be emitted in response to wl_shm requests.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Error {
    /// buffer format is not known,
    InvalidFormat = 0,
    /// invalid size or stride during pool or buffer creation,
    InvalidStride = 1,
    /// mmapping the file descriptor failed,
    InvalidFd = 2,
}

impl Error {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Error::InvalidFormat),
        1 => Some(Error::InvalidStride),
        2 => Some(Error::InvalidFd),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Error {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}

/// pixel formats
///
/// This describes the memory layout of an individual pixel.
/// 
/// All renderers should support argb8888 and xrgb8888 but any other
/// formats are optional and may not be supported by the particular
/// renderer in use.
/// 
/// The drm format codes match the macros defined in drm_fourcc.h, except
/// argb8888 and xrgb8888. The formats actually supported by the compositor
/// will be reported by the format event.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Format {
    /// 32-bit ARGB format, [31:0] A:R:G:B 8:8:8:8 little endian,
    Argb8888 = 0,
    /// 32-bit RGB format, [31:0] x:R:G:B 8:8:8:8 little endian,
    Xrgb8888 = 1,
    /// 8-bit color index format, [7:0] C,
    C8 = 538982467,
    /// 8-bit RGB format, [7:0] R:G:B 3:3:2,
    Rgb332 = 943867730,
    /// 8-bit BGR format, [7:0] B:G:R 2:3:3,
    Bgr233 = 944916290,
    /// 16-bit xRGB format, [15:0] x:R:G:B 4:4:4:4 little endian,
    Xrgb4444 = 842093144,
    /// 16-bit xBGR format, [15:0] x:B:G:R 4:4:4:4 little endian,
    Xbgr4444 = 842089048,
    /// 16-bit RGBx format, [15:0] R:G:B:x 4:4:4:4 little endian,
    Rgbx4444 = 842094674,
    /// 16-bit BGRx format, [15:0] B:G:R:x 4:4:4:4 little endian,
    Bgrx4444 = 842094658,
    /// 16-bit ARGB format, [15:0] A:R:G:B 4:4:4:4 little endian,
    Argb4444 = 842093121,
    /// 16-bit ABGR format, [15:0] A:B:G:R 4:4:4:4 little endian,
    Abgr4444 = 842089025,
    /// 16-bit RBGA format, [15:0] R:G:B:A 4:4:4:4 little endian,
    Rgba4444 = 842088786,
    /// 16-bit BGRA format, [15:0] B:G:R:A 4:4:4:4 little endian,
    Bgra4444 = 842088770,
    /// 16-bit xRGB format, [15:0] x:R:G:B 1:5:5:5 little endian,
    Xrgb1555 = 892424792,
    /// 16-bit xBGR 1555 format, [15:0] x:B:G:R 1:5:5:5 little endian,
    Xbgr1555 = 892420696,
    /// 16-bit RGBx 5551 format, [15:0] R:G:B:x 5:5:5:1 little endian,
    Rgbx5551 = 892426322,
    /// 16-bit BGRx 5551 format, [15:0] B:G:R:x 5:5:5:1 little endian,
    Bgrx5551 = 892426306,
    /// 16-bit ARGB 1555 format, [15:0] A:R:G:B 1:5:5:5 little endian,
    Argb1555 = 892424769,
    /// 16-bit ABGR 1555 format, [15:0] A:B:G:R 1:5:5:5 little endian,
    Abgr1555 = 892420673,
    /// 16-bit RGBA 5551 format, [15:0] R:G:B:A 5:5:5:1 little endian,
    Rgba5551 = 892420434,
    /// 16-bit BGRA 5551 format, [15:0] B:G:R:A 5:5:5:1 little endian,
    Bgra5551 = 892420418,
    /// 16-bit RGB 565 format, [15:0] R:G:B 5:6:5 little endian,
    Rgb565 = 909199186,
    /// 16-bit BGR 565 format, [15:0] B:G:R 5:6:5 little endian,
    Bgr565 = 909199170,
    /// 24-bit RGB format, [23:0] R:G:B little endian,
    Rgb888 = 875710290,
    /// 24-bit BGR format, [23:0] B:G:R little endian,
    Bgr888 = 875710274,
    /// 32-bit xBGR format, [31:0] x:B:G:R 8:8:8:8 little endian,
    Xbgr8888 = 875709016,
    /// 32-bit RGBx format, [31:0] R:G:B:x 8:8:8:8 little endian,
    Rgbx8888 = 875714642,
    /// 32-bit BGRx format, [31:0] B:G:R:x 8:8:8:8 little endian,
    Bgrx8888 = 875714626,
    /// 32-bit ABGR format, [31:0] A:B:G:R 8:8:8:8 little endian,
    Abgr8888 = 875708993,
    /// 32-bit RGBA format, [31:0] R:G:B:A 8:8:8:8 little endian,
    Rgba8888 = 875708754,
    /// 32-bit BGRA format, [31:0] B:G:R:A 8:8:8:8 little endian,
    Bgra8888 = 875708738,
    /// 32-bit xRGB format, [31:0] x:R:G:B 2:10:10:10 little endian,
    Xrgb2101010 = 808669784,
    /// 32-bit xBGR format, [31:0] x:B:G:R 2:10:10:10 little endian,
    Xbgr2101010 = 808665688,
    /// 32-bit RGBx format, [31:0] R:G:B:x 10:10:10:2 little endian,
    Rgbx1010102 = 808671314,
    /// 32-bit BGRx format, [31:0] B:G:R:x 10:10:10:2 little endian,
    Bgrx1010102 = 808671298,
    /// 32-bit ARGB format, [31:0] A:R:G:B 2:10:10:10 little endian,
    Argb2101010 = 808669761,
    /// 32-bit ABGR format, [31:0] A:B:G:R 2:10:10:10 little endian,
    Abgr2101010 = 808665665,
    /// 32-bit RGBA format, [31:0] R:G:B:A 10:10:10:2 little endian,
    Rgba1010102 = 808665426,
    /// 32-bit BGRA format, [31:0] B:G:R:A 10:10:10:2 little endian,
    Bgra1010102 = 808665410,
    /// packed YCbCr format, [31:0] Cr0:Y1:Cb0:Y0 8:8:8:8 little endian,
    Yuyv = 1448695129,
    /// packed YCbCr format, [31:0] Cb0:Y1:Cr0:Y0 8:8:8:8 little endian,
    Yvyu = 1431918169,
    /// packed YCbCr format, [31:0] Y1:Cr0:Y0:Cb0 8:8:8:8 little endian,
    Uyvy = 1498831189,
    /// packed YCbCr format, [31:0] Y1:Cb0:Y0:Cr0 8:8:8:8 little endian,
    Vyuy = 1498765654,
    /// packed AYCbCr format, [31:0] A:Y:Cb:Cr 8:8:8:8 little endian,
    Ayuv = 1448433985,
    /// 2 plane YCbCr Cr:Cb format, 2x2 subsampled Cr:Cb plane,
    Nv12 = 842094158,
    /// 2 plane YCbCr Cb:Cr format, 2x2 subsampled Cb:Cr plane,
    Nv21 = 825382478,
    /// 2 plane YCbCr Cr:Cb format, 2x1 subsampled Cr:Cb plane,
    Nv16 = 909203022,
    /// 2 plane YCbCr Cb:Cr format, 2x1 subsampled Cb:Cr plane,
    Nv61 = 825644622,
    /// 3 plane YCbCr format, 4x4 subsampled Cb (1) and Cr (2) planes,
    Yuv410 = 961959257,
    /// 3 plane YCbCr format, 4x4 subsampled Cr (1) and Cb (2) planes,
    Yvu410 = 961893977,
    /// 3 plane YCbCr format, 4x1 subsampled Cb (1) and Cr (2) planes,
    Yuv411 = 825316697,
    /// 3 plane YCbCr format, 4x1 subsampled Cr (1) and Cb (2) planes,
    Yvu411 = 825316953,
    /// 3 plane YCbCr format, 2x2 subsampled Cb (1) and Cr (2) planes,
    Yuv420 = 842093913,
    /// 3 plane YCbCr format, 2x2 subsampled Cr (1) and Cb (2) planes,
    Yvu420 = 842094169,
    /// 3 plane YCbCr format, 2x1 subsampled Cb (1) and Cr (2) planes,
    Yuv422 = 909202777,
    /// 3 plane YCbCr format, 2x1 subsampled Cr (1) and Cb (2) planes,
    Yvu422 = 909203033,
    /// 3 plane YCbCr format, non-subsampled Cb (1) and Cr (2) planes,
    Yuv444 = 875713881,
    /// 3 plane YCbCr format, non-subsampled Cr (1) and Cb (2) planes,
    Yvu444 = 875714137,
    /// [7:0] R,
    R8 = 538982482,
    /// [15:0] R little endian,
    R16 = 540422482,
    /// [15:0] R:G 8:8 little endian,
    Rg88 = 943212370,
    /// [15:0] G:R 8:8 little endian,
    Gr88 = 943215175,
    /// [31:0] R:G 16:16 little endian,
    Rg1616 = 842221394,
    /// [31:0] G:R 16:16 little endian,
    Gr1616 = 842224199,
    /// [63:0] x:R:G:B 16:16:16:16 little endian,
    Xrgb16161616f = 1211388504,
    /// [63:0] x:B:G:R 16:16:16:16 little endian,
    Xbgr16161616f = 1211384408,
    /// [63:0] A:R:G:B 16:16:16:16 little endian,
    Argb16161616f = 1211388481,
    /// [63:0] A:B:G:R 16:16:16:16 little endian,
    Abgr16161616f = 1211384385,
    /// [31:0] X:Y:Cb:Cr 8:8:8:8 little endian,
    Xyuv8888 = 1448434008,
    /// [23:0] Cr:Cb:Y 8:8:8 little endian,
    Vuy888 = 875713878,
    /// Y followed by U then V, 10:10:10. Non-linear modifier only,
    Vuy101010 = 808670550,
    /// [63:0] Cr0:0:Y1:0:Cb0:0:Y0:0 10:6:10:6:10:6:10:6 little endian per 2 Y pixels,
    Y210 = 808530521,
    /// [63:0] Cr0:0:Y1:0:Cb0:0:Y0:0 12:4:12:4:12:4:12:4 little endian per 2 Y pixels,
    Y212 = 842084953,
    /// [63:0] Cr0:Y1:Cb0:Y0 16:16:16:16 little endian per 2 Y pixels,
    Y216 = 909193817,
    /// [31:0] A:Cr:Y:Cb 2:10:10:10 little endian,
    Y410 = 808531033,
    /// [63:0] A:0:Cr:0:Y:0:Cb:0 12:4:12:4:12:4:12:4 little endian,
    Y412 = 842085465,
    /// [63:0] A:Cr:Y:Cb 16:16:16:16 little endian,
    Y416 = 909194329,
    /// [31:0] X:Cr:Y:Cb 2:10:10:10 little endian,
    Xvyu2101010 = 808670808,
    /// [63:0] X:0:Cr:0:Y:0:Cb:0 12:4:12:4:12:4:12:4 little endian,
    Xvyu1216161616 = 909334104,
    /// [63:0] X:Cr:Y:Cb 16:16:16:16 little endian,
    Xvyu16161616 = 942954072,
    /// [63:0]   A3:A2:Y3:0:Cr0:0:Y2:0:A1:A0:Y1:0:Cb0:0:Y0:0  1:1:8:2:8:2:8:2:1:1:8:2:8:2:8:2 little endian,
    Y0l0 = 810299481,
    /// [63:0]   X3:X2:Y3:0:Cr0:0:Y2:0:X1:X0:Y1:0:Cb0:0:Y0:0  1:1:8:2:8:2:8:2:1:1:8:2:8:2:8:2 little endian,
    X0l0 = 810299480,
    /// [63:0]   A3:A2:Y3:Cr0:Y2:A1:A0:Y1:Cb0:Y0  1:1:10:10:10:1:1:10:10:10 little endian,
    Y0l2 = 843853913,
    /// [63:0]   X3:X2:Y3:Cr0:Y2:X1:X0:Y1:Cb0:Y0  1:1:10:10:10:1:1:10:10:10 little endian,
    X0l2 = 843853912,
    Yuv4208bit = 942691673,
    Yuv42010bit = 808539481,
    Xrgb8888A8 = 943805016,
    Xbgr8888A8 = 943800920,
    Rgbx8888A8 = 943806546,
    Bgrx8888A8 = 943806530,
    Rgb888A8 = 943798354,
    Bgr888A8 = 943798338,
    Rgb565A8 = 943797586,
    Bgr565A8 = 943797570,
    /// non-subsampled Cr:Cb plane,
    Nv24 = 875714126,
    /// non-subsampled Cb:Cr plane,
    Nv42 = 842290766,
    /// 2x1 subsampled Cr:Cb plane, 10 bit per channel,
    P210 = 808530512,
    /// 2x2 subsampled Cr:Cb plane 10 bits per channel,
    P010 = 808530000,
    /// 2x2 subsampled Cr:Cb plane 12 bits per channel,
    P012 = 842084432,
    /// 2x2 subsampled Cr:Cb plane 16 bits per channel,
    P016 = 909193296,
}

impl Format {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Format::Argb8888),
        1 => Some(Format::Xrgb8888),
        538982467 => Some(Format::C8),
        943867730 => Some(Format::Rgb332),
        944916290 => Some(Format::Bgr233),
        842093144 => Some(Format::Xrgb4444),
        842089048 => Some(Format::Xbgr4444),
        842094674 => Some(Format::Rgbx4444),
        842094658 => Some(Format::Bgrx4444),
        842093121 => Some(Format::Argb4444),
        842089025 => Some(Format::Abgr4444),
        842088786 => Some(Format::Rgba4444),
        842088770 => Some(Format::Bgra4444),
        892424792 => Some(Format::Xrgb1555),
        892420696 => Some(Format::Xbgr1555),
        892426322 => Some(Format::Rgbx5551),
        892426306 => Some(Format::Bgrx5551),
        892424769 => Some(Format::Argb1555),
        892420673 => Some(Format::Abgr1555),
        892420434 => Some(Format::Rgba5551),
        892420418 => Some(Format::Bgra5551),
        909199186 => Some(Format::Rgb565),
        909199170 => Some(Format::Bgr565),
        875710290 => Some(Format::Rgb888),
        875710274 => Some(Format::Bgr888),
        875709016 => Some(Format::Xbgr8888),
        875714642 => Some(Format::Rgbx8888),
        875714626 => Some(Format::Bgrx8888),
        875708993 => Some(Format::Abgr8888),
        875708754 => Some(Format::Rgba8888),
        875708738 => Some(Format::Bgra8888),
        808669784 => Some(Format::Xrgb2101010),
        808665688 => Some(Format::Xbgr2101010),
        808671314 => Some(Format::Rgbx1010102),
        808671298 => Some(Format::Bgrx1010102),
        808669761 => Some(Format::Argb2101010),
        808665665 => Some(Format::Abgr2101010),
        808665426 => Some(Format::Rgba1010102),
        808665410 => Some(Format::Bgra1010102),
        1448695129 => Some(Format::Yuyv),
        1431918169 => Some(Format::Yvyu),
        1498831189 => Some(Format::Uyvy),
        1498765654 => Some(Format::Vyuy),
        1448433985 => Some(Format::Ayuv),
        842094158 => Some(Format::Nv12),
        825382478 => Some(Format::Nv21),
        909203022 => Some(Format::Nv16),
        825644622 => Some(Format::Nv61),
        961959257 => Some(Format::Yuv410),
        961893977 => Some(Format::Yvu410),
        825316697 => Some(Format::Yuv411),
        825316953 => Some(Format::Yvu411),
        842093913 => Some(Format::Yuv420),
        842094169 => Some(Format::Yvu420),
        909202777 => Some(Format::Yuv422),
        909203033 => Some(Format::Yvu422),
        875713881 => Some(Format::Yuv444),
        875714137 => Some(Format::Yvu444),
        538982482 => Some(Format::R8),
        540422482 => Some(Format::R16),
        943212370 => Some(Format::Rg88),
        943215175 => Some(Format::Gr88),
        842221394 => Some(Format::Rg1616),
        842224199 => Some(Format::Gr1616),
        1211388504 => Some(Format::Xrgb16161616f),
        1211384408 => Some(Format::Xbgr16161616f),
        1211388481 => Some(Format::Argb16161616f),
        1211384385 => Some(Format::Abgr16161616f),
        1448434008 => Some(Format::Xyuv8888),
        875713878 => Some(Format::Vuy888),
        808670550 => Some(Format::Vuy101010),
        808530521 => Some(Format::Y210),
        842084953 => Some(Format::Y212),
        909193817 => Some(Format::Y216),
        808531033 => Some(Format::Y410),
        842085465 => Some(Format::Y412),
        909194329 => Some(Format::Y416),
        808670808 => Some(Format::Xvyu2101010),
        909334104 => Some(Format::Xvyu1216161616),
        942954072 => Some(Format::Xvyu16161616),
        810299481 => Some(Format::Y0l0),
        810299480 => Some(Format::X0l0),
        843853913 => Some(Format::Y0l2),
        843853912 => Some(Format::X0l2),
        942691673 => Some(Format::Yuv4208bit),
        808539481 => Some(Format::Yuv42010bit),
        943805016 => Some(Format::Xrgb8888A8),
        943800920 => Some(Format::Xbgr8888A8),
        943806546 => Some(Format::Rgbx8888A8),
        943806530 => Some(Format::Bgrx8888A8),
        943798354 => Some(Format::Rgb888A8),
        943798338 => Some(Format::Bgr888A8),
        943797586 => Some(Format::Rgb565A8),
        943797570 => Some(Format::Bgr565A8),
        875714126 => Some(Format::Nv24),
        842290766 => Some(Format::Nv42),
        808530512 => Some(Format::P210),
        808530000 => Some(Format::P010),
        842084432 => Some(Format::P012),
        909193296 => Some(Format::P016),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Format {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_shm

pub use crate::wl_shm::WlShm;
pub use crate::wl_shm::Request as WlShmRequest;
pub use crate::wl_shm::Event as WlShmEvent;
pub mod wl_buffer {
use super::*;

/// content for a wl_surface
///
/// A buffer provides the content for a wl_surface. Buffers are
/// created through factory interfaces such as wl_drm, wl_shm or
/// similar. It has a width and a height and can be attached to a
/// wl_surface, but the mechanism by which a client provides and
/// updates the contents is defined by the buffer factory interface.
#[derive(Debug)]
pub struct WlBuffer;

impl Interface for WlBuffer {
    const NAME: &'static str = "wl_buffer";
    const VERSION: u32 = 1;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // destroy
        MessageSpec(&[
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // release
        MessageSpec(&[
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// destroy a buffer
    ///
    /// Destroy a buffer. If and how you need to release the backing
    /// storage is defined by the buffer factory interface.
    /// 
    /// For possible side-effects to a surface, see wl_surface.attach.
    Destroy,
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::Destroy {
            } => {
                format!("wl_buffer@{:?}::destroy()", this)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::Destroy { .. } => c"wl_buffer::destroy",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// compositor releases buffer
    ///
    /// Sent when this wl_buffer is no longer used by the compositor.
    /// The client is now free to reuse or destroy this buffer and its
    /// backing storage.
    /// 
    /// If a client receives a release event before the frame callback
    /// requested in the same wl_surface.commit that attaches this
    /// wl_buffer to a surface, then the client is immediately free to
    /// reuse the buffer and its backing storage, and does not need a
    /// second buffer for the next surface content update. Typically
    /// this is possible, when the compositor maintains a copy of the
    /// wl_surface contents, e.g. as a GL texture. This is an important
    /// optimization for GL(ES) compositors with wl_shm clients.
    Release,
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Release {
            } => {
                format!("wl_buffer@{:?}::release()", this)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Release { .. } => c"wl_buffer::release",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::Destroy {
        } => {
            header.opcode = 0;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* release */ => {
            let mut iter = args.into_iter();
            Ok(Event::Release {

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
} // mod wl_buffer

pub use crate::wl_buffer::WlBuffer;
pub use crate::wl_buffer::Request as WlBufferRequest;
pub use crate::wl_buffer::Event as WlBufferEvent;
pub mod wl_data_offer {
use super::*;

/// offer to transfer data
///
/// A wl_data_offer represents a piece of data offered for transfer
/// by another client (the source client).  It is used by the
/// copy-and-paste and drag-and-drop mechanisms.  The offer
/// describes the different mime types that the data can be
/// converted to and provides the mechanism for transferring the
/// data directly from the source client.
#[derive(Debug)]
pub struct WlDataOffer;

impl Interface for WlDataOffer {
    const NAME: &'static str = "wl_data_offer";
    const VERSION: u32 = 3;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // accept
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::String,
        ]),
        // receive
        MessageSpec(&[
            ArgKind::String,
            ArgKind::Handle,
        ]),
        // destroy
        MessageSpec(&[
        ]),
        // finish
        MessageSpec(&[
        ]),
        // set_actions
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Uint,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // offer
        MessageSpec(&[
            ArgKind::String,
        ]),
        // source_actions
        MessageSpec(&[
            ArgKind::Uint,
        ]),
        // action
        MessageSpec(&[
            ArgKind::Uint,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// accept one of the offered mime types
    ///
    /// Indicate that the client can accept the given mime type, or
    /// NULL for not accepted.
    /// 
    /// For objects of version 2 or older, this request is used by the
    /// client to give feedback whether the client can receive the given
    /// mime type, or NULL if none is accepted; the feedback does not
    /// determine whether the drag-and-drop operation succeeds or not.
    /// 
    /// For objects of version 3 or newer, this request determines the
    /// final result of the drag-and-drop operation. If the end result
    /// is that no mime types were accepted, the drag-and-drop operation
    /// will be cancelled and the corresponding drag source will receive
    /// wl_data_source.cancelled. Clients may still use this event in
    /// conjunction with wl_data_source.action for feedback.
    Accept {
        /// serial number of the accept request
        serial: u32,
        /// mime type accepted by the client
        mime_type: String,
    },

    /// request that the data is transferred
    ///
    /// To transfer the offered data, the client issues this request
    /// and indicates the mime type it wants to receive.  The transfer
    /// happens through the passed file descriptor (typically created
    /// with the pipe system call).  The source client writes the data
    /// in the mime type representation requested and then closes the
    /// file descriptor.
    /// 
    /// The receiving client reads from the read end of the pipe until
    /// EOF and then closes its end, at which point the transfer is
    /// complete.
    /// 
    /// This request may happen multiple times for different mime types,
    /// both before and after wl_data_device.drop. Drag-and-drop destination
    /// clients may preemptively fetch data or examine it more closely to
    /// determine acceptance.
    Receive {
        /// mime type desired by receiver
        mime_type: String,
        /// file descriptor for data transfer
        fd: zx::Handle,
    },

    /// destroy data offer
    ///
    /// Destroy the data offer.
    Destroy,

    /// the offer will no longer be used
    ///
    /// Notifies the compositor that the drag destination successfully
    /// finished the drag-and-drop operation.
    /// 
    /// Upon receiving this request, the compositor will emit
    /// wl_data_source.dnd_finished on the drag source client.
    /// 
    /// It is a client error to perform other requests than
    /// wl_data_offer.destroy after this one. It is also an error to perform
    /// this request after a NULL mime type has been set in
    /// wl_data_offer.accept or no action was received through
    /// wl_data_offer.action.
    /// 
    /// If wl_data_offer.finish request is received for a non drag and drop
    /// operation, the invalid_finish protocol error is raised.
    Finish,

    /// set the available/preferred drag-and-drop actions
    ///
    /// Sets the actions that the destination side client supports for
    /// this operation. This request may trigger the emission of
    /// wl_data_source.action and wl_data_offer.action events if the compositor
    /// needs to change the selected action.
    /// 
    /// This request can be called multiple times throughout the
    /// drag-and-drop operation, typically in response to wl_data_device.enter
    /// or wl_data_device.motion events.
    /// 
    /// This request determines the final result of the drag-and-drop
    /// operation. If the end result is that no action is accepted,
    /// the drag source will receive wl_data_source.cancelled.
    /// 
    /// The dnd_actions argument must contain only values expressed in the
    /// wl_data_device_manager.dnd_actions enum, and the preferred_action
    /// argument must only contain one of those values set, otherwise it
    /// will result in a protocol error.
    /// 
    /// While managing an "ask" action, the destination drag-and-drop client
    /// may perform further wl_data_offer.receive requests, and is expected
    /// to perform one last wl_data_offer.set_actions request with a preferred
    /// action other than "ask" (and optionally wl_data_offer.accept) before
    /// requesting wl_data_offer.finish, in order to convey the action selected
    /// by the user. If the preferred action is not in the
    /// wl_data_offer.source_actions mask, an error will be raised.
    /// 
    /// If the "ask" action is dismissed (e.g. user cancellation), the client
    /// is expected to perform wl_data_offer.destroy right away.
    /// 
    /// This request can only be made on drag-and-drop offers, a protocol error
    /// will be raised otherwise.
    SetActions {
        /// actions supported by the destination client
        dnd_actions: crate::wl_data_device_manager::DndAction,
        /// action preferred by the destination client
        preferred_action: crate::wl_data_device_manager::DndAction,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::Accept {
                ref serial,
                ref mime_type,
            } => {
                format!("wl_data_offer@{:?}::accept(serial: {:?}, mime_type: {:?})", this, serial, mime_type)
            }
            Request::Receive {
                ref mime_type,
                ref fd,
            } => {
                format!("wl_data_offer@{:?}::receive(mime_type: {:?}, fd: <handle>)", this, mime_type)
            }
            Request::Destroy {
            } => {
                format!("wl_data_offer@{:?}::destroy()", this)
            }
            Request::Finish {
            } => {
                format!("wl_data_offer@{:?}::finish()", this)
            }
            Request::SetActions {
                ref dnd_actions,
                ref preferred_action,
            } => {
                format!("wl_data_offer@{:?}::set_actions(dnd_actions: {:?}, preferred_action: {:?})", this, dnd_actions, preferred_action)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::Accept { .. } => c"wl_data_offer::accept",
            Request::Receive { .. } => c"wl_data_offer::receive",
            Request::Destroy { .. } => c"wl_data_offer::destroy",
            Request::Finish { .. } => c"wl_data_offer::finish",
            Request::SetActions { .. } => c"wl_data_offer::set_actions",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// advertise offered mime type
    ///
    /// Sent immediately after creating the wl_data_offer object.  One
    /// event per offered mime type.
    Offer {
        /// offered mime type
        mime_type: String,
    },

    /// notify the source-side available actions
    ///
    /// This event indicates the actions offered by the data source. It
    /// will be sent right after wl_data_device.enter, or anytime the source
    /// side changes its offered actions through wl_data_source.set_actions.
    SourceActions {
        /// actions offered by the data source
        source_actions: Enum<crate::wl_data_device_manager::DndAction>,
    },

    /// notify the selected action
    ///
    /// This event indicates the action selected by the compositor after
    /// matching the source/destination side actions. Only one action (or
    /// none) will be offered here.
    /// 
    /// This event can be emitted multiple times during the drag-and-drop
    /// operation in response to destination side action changes through
    /// wl_data_offer.set_actions.
    /// 
    /// This event will no longer be emitted after wl_data_device.drop
    /// happened on the drag-and-drop destination, the client must
    /// honor the last action received, or the last preferred one set
    /// through wl_data_offer.set_actions when handling an "ask" action.
    /// 
    /// Compositors may also change the selected action on the fly, mainly
    /// in response to keyboard modifier changes during the drag-and-drop
    /// operation.
    /// 
    /// The most recent action received is always the valid one. Prior to
    /// receiving wl_data_device.drop, the chosen action may change (e.g.
    /// due to keyboard modifiers being pressed). At the time of receiving
    /// wl_data_device.drop the drag-and-drop destination must honor the
    /// last action received.
    /// 
    /// Action changes may still happen after wl_data_device.drop,
    /// especially on "ask" actions, where the drag-and-drop destination
    /// may choose another action afterwards. Action changes happening
    /// at this stage are always the result of inter-client negotiation, the
    /// compositor shall no longer be able to induce a different action.
    /// 
    /// Upon "ask" actions, it is expected that the drag-and-drop destination
    /// may potentially choose a different action and/or mime type,
    /// based on wl_data_offer.source_actions and finally chosen by the
    /// user (e.g. popping up a menu with the available options). The
    /// final wl_data_offer.set_actions and wl_data_offer.accept requests
    /// must happen before the call to wl_data_offer.finish.
    Action {
        /// action selected by the compositor
        dnd_action: Enum<crate::wl_data_device_manager::DndAction>,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Offer {
                ref mime_type,
            } => {
                format!("wl_data_offer@{:?}::offer(mime_type: {:?})", this, mime_type)
            }
            Event::SourceActions {
                ref source_actions,
            } => {
                format!("wl_data_offer@{:?}::source_actions(source_actions: {:?})", this, source_actions)
            }
            Event::Action {
                ref dnd_action,
            } => {
                format!("wl_data_offer@{:?}::action(dnd_action: {:?})", this, dnd_action)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Offer { .. } => c"wl_data_offer::offer",
            Event::SourceActions { .. } => c"wl_data_offer::source_actions",
            Event::Action { .. } => c"wl_data_offer::action",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::Accept {
            serial,
            mime_type,
        } => {
            msg.write_arg(Arg::Uint(serial))?;
            msg.write_arg(Arg::String(mime_type))?;
            header.opcode = 0;
        },
        Request::Receive {
            mime_type,
            fd,
        } => {
            msg.write_arg(Arg::String(mime_type))?;
            msg.write_arg(Arg::Handle(fd))?;
            header.opcode = 1;
        },
        Request::Destroy {
        } => {
            header.opcode = 2;
        },
        Request::Finish {
        } => {
            header.opcode = 3;
        },
        Request::SetActions {
            dnd_actions,
            preferred_action,
        } => {
            msg.write_arg(Arg::Uint(dnd_actions.bits()))?;
            msg.write_arg(Arg::Uint(preferred_action.bits()))?;
            header.opcode = 4;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* offer */ => {
            let mut iter = args.into_iter();
            Ok(Event::Offer {
                mime_type: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_string()?,

            })
        },
        1 /* source_actions */ => {
            let mut iter = args.into_iter();
            Ok(Event::SourceActions {
                source_actions: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match crate::wl_data_device_manager::DndAction::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,

            })
        },
        2 /* action */ => {
            let mut iter = args.into_iter();
            Ok(Event::Action {
                dnd_action: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match crate::wl_data_device_manager::DndAction::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Error {
    /// finish request was called untimely,
    InvalidFinish = 0,
    /// action mask contains invalid values,
    InvalidActionMask = 1,
    /// action argument has an invalid value,
    InvalidAction = 2,
    /// offer doesn't accept this request,
    InvalidOffer = 3,
}

impl Error {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Error::InvalidFinish),
        1 => Some(Error::InvalidActionMask),
        2 => Some(Error::InvalidAction),
        3 => Some(Error::InvalidOffer),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Error {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_data_offer

pub use crate::wl_data_offer::WlDataOffer;
pub use crate::wl_data_offer::Request as WlDataOfferRequest;
pub use crate::wl_data_offer::Event as WlDataOfferEvent;
pub mod wl_data_source {
use super::*;

/// offer to transfer data
///
/// The wl_data_source object is the source side of a wl_data_offer.
/// It is created by the source client in a data transfer and
/// provides a way to describe the offered data and a way to respond
/// to requests to transfer the data.
#[derive(Debug)]
pub struct WlDataSource;

impl Interface for WlDataSource {
    const NAME: &'static str = "wl_data_source";
    const VERSION: u32 = 3;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // offer
        MessageSpec(&[
            ArgKind::String,
        ]),
        // destroy
        MessageSpec(&[
        ]),
        // set_actions
        MessageSpec(&[
            ArgKind::Uint,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // target
        MessageSpec(&[
            ArgKind::String,
        ]),
        // send
        MessageSpec(&[
            ArgKind::String,
            ArgKind::Handle,
        ]),
        // cancelled
        MessageSpec(&[
        ]),
        // dnd_drop_performed
        MessageSpec(&[
        ]),
        // dnd_finished
        MessageSpec(&[
        ]),
        // action
        MessageSpec(&[
            ArgKind::Uint,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// add an offered mime type
    ///
    /// This request adds a mime type to the set of mime types
    /// advertised to targets.  Can be called several times to offer
    /// multiple types.
    Offer {
        /// mime type offered by the data source
        mime_type: String,
    },

    /// destroy the data source
    ///
    /// Destroy the data source.
    Destroy,

    /// set the available drag-and-drop actions
    ///
    /// Sets the actions that the source side client supports for this
    /// operation. This request may trigger wl_data_source.action and
    /// wl_data_offer.action events if the compositor needs to change the
    /// selected action.
    /// 
    /// The dnd_actions argument must contain only values expressed in the
    /// wl_data_device_manager.dnd_actions enum, otherwise it will result
    /// in a protocol error.
    /// 
    /// This request must be made once only, and can only be made on sources
    /// used in drag-and-drop, so it must be performed before
    /// wl_data_device.start_drag. Attempting to use the source other than
    /// for drag-and-drop will raise a protocol error.
    SetActions {
        /// actions supported by the data source
        dnd_actions: crate::wl_data_device_manager::DndAction,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::Offer {
                ref mime_type,
            } => {
                format!("wl_data_source@{:?}::offer(mime_type: {:?})", this, mime_type)
            }
            Request::Destroy {
            } => {
                format!("wl_data_source@{:?}::destroy()", this)
            }
            Request::SetActions {
                ref dnd_actions,
            } => {
                format!("wl_data_source@{:?}::set_actions(dnd_actions: {:?})", this, dnd_actions)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::Offer { .. } => c"wl_data_source::offer",
            Request::Destroy { .. } => c"wl_data_source::destroy",
            Request::SetActions { .. } => c"wl_data_source::set_actions",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// a target accepts an offered mime type
    ///
    /// Sent when a target accepts pointer_focus or motion events.  If
    /// a target does not accept any of the offered types, type is NULL.
    /// 
    /// Used for feedback during drag-and-drop.
    Target {
        /// mime type accepted by the target
        mime_type: String,
    },

    /// send the data
    ///
    /// Request for data from the client.  Send the data as the
    /// specified mime type over the passed file descriptor, then
    /// close it.
    Send {
        /// mime type for the data
        mime_type: String,
        /// file descriptor for the data
        fd: zx::Handle,
    },

    /// selection was cancelled
    ///
    /// This data source is no longer valid. There are several reasons why
    /// this could happen:
    /// 
    /// - The data source has been replaced by another data source.
    /// - The drag-and-drop operation was performed, but the drop destination
    /// did not accept any of the mime types offered through
    /// wl_data_source.target.
    /// - The drag-and-drop operation was performed, but the drop destination
    /// did not select any of the actions present in the mask offered through
    /// wl_data_source.action.
    /// - The drag-and-drop operation was performed but didn't happen over a
    /// surface.
    /// - The compositor cancelled the drag-and-drop operation (e.g. compositor
    /// dependent timeouts to avoid stale drag-and-drop transfers).
    /// 
    /// The client should clean up and destroy this data source.
    /// 
    /// For objects of version 2 or older, wl_data_source.cancelled will
    /// only be emitted if the data source was replaced by another data
    /// source.
    Cancelled,

    /// the drag-and-drop operation physically finished
    ///
    /// The user performed the drop action. This event does not indicate
    /// acceptance, wl_data_source.cancelled may still be emitted afterwards
    /// if the drop destination does not accept any mime type.
    /// 
    /// However, this event might however not be received if the compositor
    /// cancelled the drag-and-drop operation before this event could happen.
    /// 
    /// Note that the data_source may still be used in the future and should
    /// not be destroyed here.
    DndDropPerformed,

    /// the drag-and-drop operation concluded
    ///
    /// The drop destination finished interoperating with this data
    /// source, so the client is now free to destroy this data source and
    /// free all associated data.
    /// 
    /// If the action used to perform the operation was "move", the
    /// source can now delete the transferred data.
    DndFinished,

    /// notify the selected action
    ///
    /// This event indicates the action selected by the compositor after
    /// matching the source/destination side actions. Only one action (or
    /// none) will be offered here.
    /// 
    /// This event can be emitted multiple times during the drag-and-drop
    /// operation, mainly in response to destination side changes through
    /// wl_data_offer.set_actions, and as the data device enters/leaves
    /// surfaces.
    /// 
    /// It is only possible to receive this event after
    /// wl_data_source.dnd_drop_performed if the drag-and-drop operation
    /// ended in an "ask" action, in which case the final wl_data_source.action
    /// event will happen immediately before wl_data_source.dnd_finished.
    /// 
    /// Compositors may also change the selected action on the fly, mainly
    /// in response to keyboard modifier changes during the drag-and-drop
    /// operation.
    /// 
    /// The most recent action received is always the valid one. The chosen
    /// action may change alongside negotiation (e.g. an "ask" action can turn
    /// into a "move" operation), so the effects of the final action must
    /// always be applied in wl_data_offer.dnd_finished.
    /// 
    /// Clients can trigger cursor surface changes from this point, so
    /// they reflect the current action.
    Action {
        /// action selected by the compositor
        dnd_action: Enum<crate::wl_data_device_manager::DndAction>,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Target {
                ref mime_type,
            } => {
                format!("wl_data_source@{:?}::target(mime_type: {:?})", this, mime_type)
            }
            Event::Send {
                ref mime_type,
                ref fd,
            } => {
                format!("wl_data_source@{:?}::send(mime_type: {:?}, fd: <handle>)", this, mime_type)
            }
            Event::Cancelled {
            } => {
                format!("wl_data_source@{:?}::cancelled()", this)
            }
            Event::DndDropPerformed {
            } => {
                format!("wl_data_source@{:?}::dnd_drop_performed()", this)
            }
            Event::DndFinished {
            } => {
                format!("wl_data_source@{:?}::dnd_finished()", this)
            }
            Event::Action {
                ref dnd_action,
            } => {
                format!("wl_data_source@{:?}::action(dnd_action: {:?})", this, dnd_action)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Target { .. } => c"wl_data_source::target",
            Event::Send { .. } => c"wl_data_source::send",
            Event::Cancelled { .. } => c"wl_data_source::cancelled",
            Event::DndDropPerformed { .. } => c"wl_data_source::dnd_drop_performed",
            Event::DndFinished { .. } => c"wl_data_source::dnd_finished",
            Event::Action { .. } => c"wl_data_source::action",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::Offer {
            mime_type,
        } => {
            msg.write_arg(Arg::String(mime_type))?;
            header.opcode = 0;
        },
        Request::Destroy {
        } => {
            header.opcode = 1;
        },
        Request::SetActions {
            dnd_actions,
        } => {
            msg.write_arg(Arg::Uint(dnd_actions.bits()))?;
            header.opcode = 2;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* target */ => {
            let mut iter = args.into_iter();
            Ok(Event::Target {
                mime_type: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_string()?,

            })
        },
        1 /* send */ => {
            let mut iter = args.into_iter();
            Ok(Event::Send {
                mime_type: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_string()?,
                fd: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_handle()?,

            })
        },
        2 /* cancelled */ => {
            let mut iter = args.into_iter();
            Ok(Event::Cancelled {

            })
        },
        3 /* dnd_drop_performed */ => {
            let mut iter = args.into_iter();
            Ok(Event::DndDropPerformed {

            })
        },
        4 /* dnd_finished */ => {
            let mut iter = args.into_iter();
            Ok(Event::DndFinished {

            })
        },
        5 /* action */ => {
            let mut iter = args.into_iter();
            Ok(Event::Action {
                dnd_action: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match crate::wl_data_device_manager::DndAction::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Error {
    /// action mask contains invalid values,
    InvalidActionMask = 0,
    /// source doesn't accept this request,
    InvalidSource = 1,
}

impl Error {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Error::InvalidActionMask),
        1 => Some(Error::InvalidSource),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Error {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_data_source

pub use crate::wl_data_source::WlDataSource;
pub use crate::wl_data_source::Request as WlDataSourceRequest;
pub use crate::wl_data_source::Event as WlDataSourceEvent;
pub mod wl_data_device {
use super::*;

/// data transfer device
///
/// There is one wl_data_device per seat which can be obtained
/// from the global wl_data_device_manager singleton.
/// 
/// A wl_data_device provides access to inter-client data transfer
/// mechanisms such as copy-and-paste and drag-and-drop.
#[derive(Debug)]
pub struct WlDataDevice;

impl Interface for WlDataDevice {
    const NAME: &'static str = "wl_data_device";
    const VERSION: u32 = 3;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // start_drag
        MessageSpec(&[
            ArgKind::Object,
            ArgKind::Object,
            ArgKind::Object,
            ArgKind::Uint,
        ]),
        // set_selection
        MessageSpec(&[
            ArgKind::Object,
            ArgKind::Uint,
        ]),
        // release
        MessageSpec(&[
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // data_offer
        MessageSpec(&[
            ArgKind::NewId,
        ]),
        // enter
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Object,
            ArgKind::Fixed,
            ArgKind::Fixed,
            ArgKind::Object,
        ]),
        // leave
        MessageSpec(&[
        ]),
        // motion
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Fixed,
            ArgKind::Fixed,
        ]),
        // drop
        MessageSpec(&[
        ]),
        // selection
        MessageSpec(&[
            ArgKind::Object,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// start drag-and-drop operation
    ///
    /// This request asks the compositor to start a drag-and-drop
    /// operation on behalf of the client.
    /// 
    /// The source argument is the data source that provides the data
    /// for the eventual data transfer. If source is NULL, enter, leave
    /// and motion events are sent only to the client that initiated the
    /// drag and the client is expected to handle the data passing
    /// internally.
    /// 
    /// The origin surface is the surface where the drag originates and
    /// the client must have an active implicit grab that matches the
    /// serial.
    /// 
    /// The icon surface is an optional (can be NULL) surface that
    /// provides an icon to be moved around with the cursor.  Initially,
    /// the top-left corner of the icon surface is placed at the cursor
    /// hotspot, but subsequent wl_surface.attach request can move the
    /// relative position. Attach requests must be confirmed with
    /// wl_surface.commit as usual. The icon surface is given the role of
    /// a drag-and-drop icon. If the icon surface already has another role,
    /// it raises a protocol error.
    /// 
    /// The current and pending input regions of the icon wl_surface are
    /// cleared, and wl_surface.set_input_region is ignored until the
    /// wl_surface is no longer used as the icon surface. When the use
    /// as an icon ends, the current and pending input regions become
    /// undefined, and the wl_surface is unmapped.
    StartDrag {
        /// data source for the eventual transfer
        source: ObjectId,
        /// surface where the drag originates
        origin: ObjectId,
        /// drag-and-drop icon surface
        icon: ObjectId,
        /// serial number of the implicit grab on the origin
        serial: u32,
    },

    /// copy data to the selection
    ///
    /// This request asks the compositor to set the selection
    /// to the data from the source on behalf of the client.
    /// 
    /// To unset the selection, set the source to NULL.
    SetSelection {
        /// data source for the selection
        source: ObjectId,
        /// serial number of the event that triggered this request
        serial: u32,
    },

    /// destroy data device
    ///
    /// This request destroys the data device.
    Release,
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::StartDrag {
                ref source,
                ref origin,
                ref icon,
                ref serial,
            } => {
                format!("wl_data_device@{:?}::start_drag(source: {:?}, origin: {:?}, icon: {:?}, serial: {:?})", this, source, origin, icon, serial)
            }
            Request::SetSelection {
                ref source,
                ref serial,
            } => {
                format!("wl_data_device@{:?}::set_selection(source: {:?}, serial: {:?})", this, source, serial)
            }
            Request::Release {
            } => {
                format!("wl_data_device@{:?}::release()", this)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::StartDrag { .. } => c"wl_data_device::start_drag",
            Request::SetSelection { .. } => c"wl_data_device::set_selection",
            Request::Release { .. } => c"wl_data_device::release",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// introduce a new wl_data_offer
    ///
    /// The data_offer event introduces a new wl_data_offer object,
    /// which will subsequently be used in either the
    /// data_device.enter event (for drag-and-drop) or the
    /// data_device.selection event (for selections).  Immediately
    /// following the data_device_data_offer event, the new data_offer
    /// object will send out data_offer.offer events to describe the
    /// mime types it offers.
    DataOffer {
        /// the new data_offer object
        id: NewObject<WlDataOffer>,
    },

    /// initiate drag-and-drop session
    ///
    /// This event is sent when an active drag-and-drop pointer enters
    /// a surface owned by the client.  The position of the pointer at
    /// enter time is provided by the x and y arguments, in surface-local
    /// coordinates.
    Enter {
        /// serial number of the enter event
        serial: u32,
        /// client surface entered
        surface: ObjectId,
        /// surface-local x coordinate
        x: Fixed,
        /// surface-local y coordinate
        y: Fixed,
        /// source data_offer object
        id: ObjectId,
    },

    /// end drag-and-drop session
    ///
    /// This event is sent when the drag-and-drop pointer leaves the
    /// surface and the session ends.  The client must destroy the
    /// wl_data_offer introduced at enter time at this point.
    Leave,

    /// drag-and-drop session motion
    ///
    /// This event is sent when the drag-and-drop pointer moves within
    /// the currently focused surface. The new position of the pointer
    /// is provided by the x and y arguments, in surface-local
    /// coordinates.
    Motion {
        /// timestamp with millisecond granularity
        time: u32,
        /// surface-local x coordinate
        x: Fixed,
        /// surface-local y coordinate
        y: Fixed,
    },

    /// end drag-and-drop session successfully
    ///
    /// The event is sent when a drag-and-drop operation is ended
    /// because the implicit grab is removed.
    /// 
    /// The drag-and-drop destination is expected to honor the last action
    /// received through wl_data_offer.action, if the resulting action is
    /// "copy" or "move", the destination can still perform
    /// wl_data_offer.receive requests, and is expected to end all
    /// transfers with a wl_data_offer.finish request.
    /// 
    /// If the resulting action is "ask", the action will not be considered
    /// final. The drag-and-drop destination is expected to perform one last
    /// wl_data_offer.set_actions request, or wl_data_offer.destroy in order
    /// to cancel the operation.
    Drop,

    /// advertise new selection
    ///
    /// The selection event is sent out to notify the client of a new
    /// wl_data_offer for the selection for this device.  The
    /// data_device.data_offer and the data_offer.offer events are
    /// sent out immediately before this event to introduce the data
    /// offer object.  The selection event is sent to a client
    /// immediately before receiving keyboard focus and when a new
    /// selection is set while the client has keyboard focus.  The
    /// data_offer is valid until a new data_offer or NULL is received
    /// or until the client loses keyboard focus.  The client must
    /// destroy the previous selection data_offer, if any, upon receiving
    /// this event.
    Selection {
        /// selection data_offer object
        id: ObjectId,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::DataOffer {
                ref id,
            } => {
                format!("wl_data_device@{:?}::data_offer(id: {:?})", this, id)
            }
            Event::Enter {
                ref serial,
                ref surface,
                ref x,
                ref y,
                ref id,
            } => {
                format!("wl_data_device@{:?}::enter(serial: {:?}, surface: {:?}, x: {:?}, y: {:?}, id: {:?})", this, serial, surface, x, y, id)
            }
            Event::Leave {
            } => {
                format!("wl_data_device@{:?}::leave()", this)
            }
            Event::Motion {
                ref time,
                ref x,
                ref y,
            } => {
                format!("wl_data_device@{:?}::motion(time: {:?}, x: {:?}, y: {:?})", this, time, x, y)
            }
            Event::Drop {
            } => {
                format!("wl_data_device@{:?}::drop()", this)
            }
            Event::Selection {
                ref id,
            } => {
                format!("wl_data_device@{:?}::selection(id: {:?})", this, id)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::DataOffer { .. } => c"wl_data_device::data_offer",
            Event::Enter { .. } => c"wl_data_device::enter",
            Event::Leave { .. } => c"wl_data_device::leave",
            Event::Motion { .. } => c"wl_data_device::motion",
            Event::Drop { .. } => c"wl_data_device::drop",
            Event::Selection { .. } => c"wl_data_device::selection",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::StartDrag {
            source,
            origin,
            icon,
            serial,
        } => {
            msg.write_arg(Arg::Object(source))?;
            msg.write_arg(Arg::Object(origin))?;
            msg.write_arg(Arg::Object(icon))?;
            msg.write_arg(Arg::Uint(serial))?;
            header.opcode = 0;
        },
        Request::SetSelection {
            source,
            serial,
        } => {
            msg.write_arg(Arg::Object(source))?;
            msg.write_arg(Arg::Uint(serial))?;
            header.opcode = 1;
        },
        Request::Release {
        } => {
            header.opcode = 2;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* data_offer */ => {
            let mut iter = args.into_iter();
            Ok(Event::DataOffer {
                id: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_new_id()?.into(),

            })
        },
        1 /* enter */ => {
            let mut iter = args.into_iter();
            Ok(Event::Enter {
                serial: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                surface: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_object()?,
                x: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),
                y: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),
                id: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_object()?,

            })
        },
        2 /* leave */ => {
            let mut iter = args.into_iter();
            Ok(Event::Leave {

            })
        },
        3 /* motion */ => {
            let mut iter = args.into_iter();
            Ok(Event::Motion {
                time: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                x: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),
                y: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),

            })
        },
        4 /* drop */ => {
            let mut iter = args.into_iter();
            Ok(Event::Drop {

            })
        },
        5 /* selection */ => {
            let mut iter = args.into_iter();
            Ok(Event::Selection {
                id: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_object()?,

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Error {
    /// given wl_surface has another role,
    Role = 0,
}

impl Error {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Error::Role),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Error {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_data_device

pub use crate::wl_data_device::WlDataDevice;
pub use crate::wl_data_device::Request as WlDataDeviceRequest;
pub use crate::wl_data_device::Event as WlDataDeviceEvent;
pub mod wl_data_device_manager {
use super::*;

/// data transfer interface
///
/// The wl_data_device_manager is a singleton global object that
/// provides access to inter-client data transfer mechanisms such as
/// copy-and-paste and drag-and-drop.  These mechanisms are tied to
/// a wl_seat and this interface lets a client get a wl_data_device
/// corresponding to a wl_seat.
/// 
/// Depending on the version bound, the objects created from the bound
/// wl_data_device_manager object will have different requirements for
/// functioning properly. See wl_data_source.set_actions,
/// wl_data_offer.accept and wl_data_offer.finish for details.
#[derive(Debug)]
pub struct WlDataDeviceManager;

impl Interface for WlDataDeviceManager {
    const NAME: &'static str = "wl_data_device_manager";
    const VERSION: u32 = 3;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // create_data_source
        MessageSpec(&[
            ArgKind::NewId,
        ]),
        // get_data_device
        MessageSpec(&[
            ArgKind::NewId,
            ArgKind::Object,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// create a new data source
    ///
    /// Create a new data source.
    CreateDataSource {
        /// data source to create
        id: NewId,
    },

    /// create a new data device
    ///
    /// Create a new data device for a given seat.
    GetDataDevice {
        /// data device to create
        id: NewId,
        /// seat associated with the data device
        seat: ObjectId,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::CreateDataSource {
                ref id,
            } => {
                format!("wl_data_device_manager@{:?}::create_data_source(id: {:?})", this, id)
            }
            Request::GetDataDevice {
                ref id,
                ref seat,
            } => {
                format!("wl_data_device_manager@{:?}::get_data_device(id: {:?}, seat: {:?})", this, id, seat)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::CreateDataSource { .. } => c"wl_data_device_manager::create_data_source",
            Request::GetDataDevice { .. } => c"wl_data_device_manager::get_data_device",
        }
    }
}
#[derive(Debug)]
pub enum Event {
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::CreateDataSource {
            id,
        } => {
            msg.write_arg(Arg::NewId(id))?;
            header.opcode = 0;
        },
        Request::GetDataDevice {
            id,
            seat,
        } => {
            msg.write_arg(Arg::NewId(id))?;
            msg.write_arg(Arg::Object(seat))?;
            header.opcode = 1;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
::bitflags::bitflags! {

    /// drag and drop actions
    ///
    /// This is a bitmask of the available/preferred actions in a
    /// drag-and-drop operation.
    /// 
    /// In the compositor, the selected action is a result of matching the
    /// actions offered by the source and destination sides.  "action" events
    /// with a "none" action will be sent to both source and destination if
    /// there is no match. All further checks will effectively happen on
    /// (source actions ∩ destination actions).
    /// 
    /// In addition, compositors may also pick different actions in
    /// reaction to key modifiers being pressed. One common design that
    /// is used in major toolkits (and the behavior recommended for
    /// compositors) is:
    /// 
    /// - If no modifiers are pressed, the first match (in bit order)
    /// will be used.
    /// - Pressing Shift selects "move", if enabled in the mask.
    /// - Pressing Control selects "copy", if enabled in the mask.
    /// 
    /// Behavior beyond that is considered implementation-dependent.
    /// Compositors may for example bind other modifiers (like Alt/Meta)
    /// or drags initiated with other buttons than BTN_LEFT to specific
    /// actions (e.g. "ask").
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct DndAction: u32 {
        /// no action,
        const None = 0;
        /// copy action,
        const Copy = 1;
        /// move action,
        const Move = 2;
        /// ask action,
        const Ask = 4;
    }
}
impl Into<Arg> for DndAction {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_data_device_manager

pub use crate::wl_data_device_manager::WlDataDeviceManager;
pub use crate::wl_data_device_manager::Request as WlDataDeviceManagerRequest;
pub use crate::wl_data_device_manager::Event as WlDataDeviceManagerEvent;
pub mod wl_shell {
use super::*;

/// create desktop-style surfaces
///
/// This interface is implemented by servers that provide
/// desktop-style user interfaces.
/// 
/// It allows clients to associate a wl_shell_surface with
/// a basic surface.
/// 
/// Note! This protocol is deprecated and not intended for production use.
/// For desktop-style user interfaces, use xdg_shell.
#[derive(Debug)]
pub struct WlShell;

impl Interface for WlShell {
    const NAME: &'static str = "wl_shell";
    const VERSION: u32 = 1;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // get_shell_surface
        MessageSpec(&[
            ArgKind::NewId,
            ArgKind::Object,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// create a shell surface from a surface
    ///
    /// Create a shell surface for an existing surface. This gives
    /// the wl_surface the role of a shell surface. If the wl_surface
    /// already has another role, it raises a protocol error.
    /// 
    /// Only one shell surface can be associated with a given surface.
    GetShellSurface {
        /// shell surface to create
        id: NewId,
        /// surface to be given the shell surface role
        surface: ObjectId,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::GetShellSurface {
                ref id,
                ref surface,
            } => {
                format!("wl_shell@{:?}::get_shell_surface(id: {:?}, surface: {:?})", this, id, surface)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::GetShellSurface { .. } => c"wl_shell::get_shell_surface",
        }
    }
}
#[derive(Debug)]
pub enum Event {
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::GetShellSurface {
            id,
            surface,
        } => {
            msg.write_arg(Arg::NewId(id))?;
            msg.write_arg(Arg::Object(surface))?;
            header.opcode = 0;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Error {
    /// given wl_surface has another role,
    Role = 0,
}

impl Error {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Error::Role),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Error {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_shell

pub use crate::wl_shell::WlShell;
pub use crate::wl_shell::Request as WlShellRequest;
pub use crate::wl_shell::Event as WlShellEvent;
pub mod wl_shell_surface {
use super::*;

/// desktop-style metadata interface
///
/// An interface that may be implemented by a wl_surface, for
/// implementations that provide a desktop-style user interface.
/// 
/// It provides requests to treat surfaces like toplevel, fullscreen
/// or popup windows, move, resize or maximize them, associate
/// metadata like title and class, etc.
/// 
/// On the server side the object is automatically destroyed when
/// the related wl_surface is destroyed. On the client side,
/// wl_shell_surface_destroy() must be called before destroying
/// the wl_surface object.
#[derive(Debug)]
pub struct WlShellSurface;

impl Interface for WlShellSurface {
    const NAME: &'static str = "wl_shell_surface";
    const VERSION: u32 = 1;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // pong
        MessageSpec(&[
            ArgKind::Uint,
        ]),
        // move
        MessageSpec(&[
            ArgKind::Object,
            ArgKind::Uint,
        ]),
        // resize
        MessageSpec(&[
            ArgKind::Object,
            ArgKind::Uint,
            ArgKind::Uint,
        ]),
        // set_toplevel
        MessageSpec(&[
        ]),
        // set_transient
        MessageSpec(&[
            ArgKind::Object,
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Uint,
        ]),
        // set_fullscreen
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Uint,
            ArgKind::Object,
        ]),
        // set_popup
        MessageSpec(&[
            ArgKind::Object,
            ArgKind::Uint,
            ArgKind::Object,
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Uint,
        ]),
        // set_maximized
        MessageSpec(&[
            ArgKind::Object,
        ]),
        // set_title
        MessageSpec(&[
            ArgKind::String,
        ]),
        // set_class
        MessageSpec(&[
            ArgKind::String,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // ping
        MessageSpec(&[
            ArgKind::Uint,
        ]),
        // configure
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Int,
            ArgKind::Int,
        ]),
        // popup_done
        MessageSpec(&[
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// respond to a ping event
    ///
    /// A client must respond to a ping event with a pong request or
    /// the client may be deemed unresponsive.
    Pong {
        /// serial number of the ping event
        serial: u32,
    },

    /// start an interactive move
    ///
    /// Start a pointer-driven move of the surface.
    /// 
    /// This request must be used in response to a button press event.
    /// The server may ignore move requests depending on the state of
    /// the surface (e.g. fullscreen or maximized).
    Move {
        /// seat whose pointer is used
        seat: ObjectId,
        /// serial number of the implicit grab on the pointer
        serial: u32,
    },

    /// start an interactive resize
    ///
    /// Start a pointer-driven resizing of the surface.
    /// 
    /// This request must be used in response to a button press event.
    /// The server may ignore resize requests depending on the state of
    /// the surface (e.g. fullscreen or maximized).
    Resize {
        /// seat whose pointer is used
        seat: ObjectId,
        /// serial number of the implicit grab on the pointer
        serial: u32,
        /// which edge or corner is being dragged
        edges: Resize,
    },

    /// make the surface a toplevel surface
    ///
    /// Map the surface as a toplevel surface.
    /// 
    /// A toplevel surface is not fullscreen, maximized or transient.
    SetToplevel,

    /// make the surface a transient surface
    ///
    /// Map the surface relative to an existing surface.
    /// 
    /// The x and y arguments specify the location of the upper left
    /// corner of the surface relative to the upper left corner of the
    /// parent surface, in surface-local coordinates.
    /// 
    /// The flags argument controls details of the transient behaviour.
    SetTransient {
        /// parent surface
        parent: ObjectId,
        /// surface-local x coordinate
        x: i32,
        /// surface-local y coordinate
        y: i32,
        /// transient surface behavior
        flags: Transient,
    },

    /// make the surface a fullscreen surface
    ///
    /// Map the surface as a fullscreen surface.
    /// 
    /// If an output parameter is given then the surface will be made
    /// fullscreen on that output. If the client does not specify the
    /// output then the compositor will apply its policy - usually
    /// choosing the output on which the surface has the biggest surface
    /// area.
    /// 
    /// The client may specify a method to resolve a size conflict
    /// between the output size and the surface size - this is provided
    /// through the method parameter.
    /// 
    /// The framerate parameter is used only when the method is set
    /// to "driver", to indicate the preferred framerate. A value of 0
    /// indicates that the client does not care about framerate.  The
    /// framerate is specified in mHz, that is framerate of 60000 is 60Hz.
    /// 
    /// A method of "scale" or "driver" implies a scaling operation of
    /// the surface, either via a direct scaling operation or a change of
    /// the output mode. This will override any kind of output scaling, so
    /// that mapping a surface with a buffer size equal to the mode can
    /// fill the screen independent of buffer_scale.
    /// 
    /// A method of "fill" means we don't scale up the buffer, however
    /// any output scale is applied. This means that you may run into
    /// an edge case where the application maps a buffer with the same
    /// size of the output mode but buffer_scale 1 (thus making a
    /// surface larger than the output). In this case it is allowed to
    /// downscale the results to fit the screen.
    /// 
    /// The compositor must reply to this request with a configure event
    /// with the dimensions for the output on which the surface will
    /// be made fullscreen.
    SetFullscreen {
        /// method for resolving size conflict
        method: FullscreenMethod,
        /// framerate in mHz
        framerate: u32,
        /// output on which the surface is to be fullscreen
        output: ObjectId,
    },

    /// make the surface a popup surface
    ///
    /// Map the surface as a popup.
    /// 
    /// A popup surface is a transient surface with an added pointer
    /// grab.
    /// 
    /// An existing implicit grab will be changed to owner-events mode,
    /// and the popup grab will continue after the implicit grab ends
    /// (i.e. releasing the mouse button does not cause the popup to
    /// be unmapped).
    /// 
    /// The popup grab continues until the window is destroyed or a
    /// mouse button is pressed in any other client's window. A click
    /// in any of the client's surfaces is reported as normal, however,
    /// clicks in other clients' surfaces will be discarded and trigger
    /// the callback.
    /// 
    /// The x and y arguments specify the location of the upper left
    /// corner of the surface relative to the upper left corner of the
    /// parent surface, in surface-local coordinates.
    SetPopup {
        /// seat whose pointer is used
        seat: ObjectId,
        /// serial number of the implicit grab on the pointer
        serial: u32,
        /// parent surface
        parent: ObjectId,
        /// surface-local x coordinate
        x: i32,
        /// surface-local y coordinate
        y: i32,
        /// transient surface behavior
        flags: Transient,
    },

    /// make the surface a maximized surface
    ///
    /// Map the surface as a maximized surface.
    /// 
    /// If an output parameter is given then the surface will be
    /// maximized on that output. If the client does not specify the
    /// output then the compositor will apply its policy - usually
    /// choosing the output on which the surface has the biggest surface
    /// area.
    /// 
    /// The compositor will reply with a configure event telling
    /// the expected new surface size. The operation is completed
    /// on the next buffer attach to this surface.
    /// 
    /// A maximized surface typically fills the entire output it is
    /// bound to, except for desktop elements such as panels. This is
    /// the main difference between a maximized shell surface and a
    /// fullscreen shell surface.
    /// 
    /// The details depend on the compositor implementation.
    SetMaximized {
        /// output on which the surface is to be maximized
        output: ObjectId,
    },

    /// set surface title
    ///
    /// Set a short title for the surface.
    /// 
    /// This string may be used to identify the surface in a task bar,
    /// window list, or other user interface elements provided by the
    /// compositor.
    /// 
    /// The string must be encoded in UTF-8.
    SetTitle {
        /// surface title
        title: String,
    },

    /// set surface class
    ///
    /// Set a class for the surface.
    /// 
    /// The surface class identifies the general class of applications
    /// to which the surface belongs. A common convention is to use the
    /// file name (or the full path if it is a non-standard location) of
    /// the application's .desktop file as the class.
    SetClass {
        /// surface class
        class_: String,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::Pong {
                ref serial,
            } => {
                format!("wl_shell_surface@{:?}::pong(serial: {:?})", this, serial)
            }
            Request::Move {
                ref seat,
                ref serial,
            } => {
                format!("wl_shell_surface@{:?}::move(seat: {:?}, serial: {:?})", this, seat, serial)
            }
            Request::Resize {
                ref seat,
                ref serial,
                ref edges,
            } => {
                format!("wl_shell_surface@{:?}::resize(seat: {:?}, serial: {:?}, edges: {:?})", this, seat, serial, edges)
            }
            Request::SetToplevel {
            } => {
                format!("wl_shell_surface@{:?}::set_toplevel()", this)
            }
            Request::SetTransient {
                ref parent,
                ref x,
                ref y,
                ref flags,
            } => {
                format!("wl_shell_surface@{:?}::set_transient(parent: {:?}, x: {:?}, y: {:?}, flags: {:?})", this, parent, x, y, flags)
            }
            Request::SetFullscreen {
                ref method,
                ref framerate,
                ref output,
            } => {
                format!("wl_shell_surface@{:?}::set_fullscreen(method: {:?}, framerate: {:?}, output: {:?})", this, method, framerate, output)
            }
            Request::SetPopup {
                ref seat,
                ref serial,
                ref parent,
                ref x,
                ref y,
                ref flags,
            } => {
                format!("wl_shell_surface@{:?}::set_popup(seat: {:?}, serial: {:?}, parent: {:?}, x: {:?}, y: {:?}, flags: {:?})", this, seat, serial, parent, x, y, flags)
            }
            Request::SetMaximized {
                ref output,
            } => {
                format!("wl_shell_surface@{:?}::set_maximized(output: {:?})", this, output)
            }
            Request::SetTitle {
                ref title,
            } => {
                format!("wl_shell_surface@{:?}::set_title(title: {:?})", this, title)
            }
            Request::SetClass {
                ref class_,
            } => {
                format!("wl_shell_surface@{:?}::set_class(class_: {:?})", this, class_)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::Pong { .. } => c"wl_shell_surface::pong",
            Request::Move { .. } => c"wl_shell_surface::move",
            Request::Resize { .. } => c"wl_shell_surface::resize",
            Request::SetToplevel { .. } => c"wl_shell_surface::set_toplevel",
            Request::SetTransient { .. } => c"wl_shell_surface::set_transient",
            Request::SetFullscreen { .. } => c"wl_shell_surface::set_fullscreen",
            Request::SetPopup { .. } => c"wl_shell_surface::set_popup",
            Request::SetMaximized { .. } => c"wl_shell_surface::set_maximized",
            Request::SetTitle { .. } => c"wl_shell_surface::set_title",
            Request::SetClass { .. } => c"wl_shell_surface::set_class",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// ping client
    ///
    /// Ping a client to check if it is receiving events and sending
    /// requests. A client is expected to reply with a pong request.
    Ping {
        /// serial number of the ping
        serial: u32,
    },

    /// suggest resize
    ///
    /// The configure event asks the client to resize its surface.
    /// 
    /// The size is a hint, in the sense that the client is free to
    /// ignore it if it doesn't resize, pick a smaller size (to
    /// satisfy aspect ratio or resize in steps of NxM pixels).
    /// 
    /// The edges parameter provides a hint about how the surface
    /// was resized. The client may use this information to decide
    /// how to adjust its content to the new size (e.g. a scrolling
    /// area might adjust its content position to leave the viewable
    /// content unmoved).
    /// 
    /// The client is free to dismiss all but the last configure
    /// event it received.
    /// 
    /// The width and height arguments specify the size of the window
    /// in surface-local coordinates.
    Configure {
        /// how the surface was resized
        edges: Enum<Resize>,
        /// new width of the surface
        width: i32,
        /// new height of the surface
        height: i32,
    },

    /// popup interaction is done
    ///
    /// The popup_done event is sent out when a popup grab is broken,
    /// that is, when the user clicks a surface that doesn't belong
    /// to the client owning the popup surface.
    PopupDone,
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Ping {
                ref serial,
            } => {
                format!("wl_shell_surface@{:?}::ping(serial: {:?})", this, serial)
            }
            Event::Configure {
                ref edges,
                ref width,
                ref height,
            } => {
                format!("wl_shell_surface@{:?}::configure(edges: {:?}, width: {:?}, height: {:?})", this, edges, width, height)
            }
            Event::PopupDone {
            } => {
                format!("wl_shell_surface@{:?}::popup_done()", this)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Ping { .. } => c"wl_shell_surface::ping",
            Event::Configure { .. } => c"wl_shell_surface::configure",
            Event::PopupDone { .. } => c"wl_shell_surface::popup_done",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::Pong {
            serial,
        } => {
            msg.write_arg(Arg::Uint(serial))?;
            header.opcode = 0;
        },
        Request::Move {
            seat,
            serial,
        } => {
            msg.write_arg(Arg::Object(seat))?;
            msg.write_arg(Arg::Uint(serial))?;
            header.opcode = 1;
        },
        Request::Resize {
            seat,
            serial,
            edges,
        } => {
            msg.write_arg(Arg::Object(seat))?;
            msg.write_arg(Arg::Uint(serial))?;
            msg.write_arg(Arg::Uint(edges.bits()))?;
            header.opcode = 2;
        },
        Request::SetToplevel {
        } => {
            header.opcode = 3;
        },
        Request::SetTransient {
            parent,
            x,
            y,
            flags,
        } => {
            msg.write_arg(Arg::Object(parent))?;
            msg.write_arg(Arg::Int(x))?;
            msg.write_arg(Arg::Int(y))?;
            msg.write_arg(Arg::Uint(flags.bits()))?;
            header.opcode = 4;
        },
        Request::SetFullscreen {
            method,
            framerate,
            output,
        } => {
            msg.write_arg(Arg::Uint(method.bits()))?;
            msg.write_arg(Arg::Uint(framerate))?;
            msg.write_arg(Arg::Object(output))?;
            header.opcode = 5;
        },
        Request::SetPopup {
            seat,
            serial,
            parent,
            x,
            y,
            flags,
        } => {
            msg.write_arg(Arg::Object(seat))?;
            msg.write_arg(Arg::Uint(serial))?;
            msg.write_arg(Arg::Object(parent))?;
            msg.write_arg(Arg::Int(x))?;
            msg.write_arg(Arg::Int(y))?;
            msg.write_arg(Arg::Uint(flags.bits()))?;
            header.opcode = 6;
        },
        Request::SetMaximized {
            output,
        } => {
            msg.write_arg(Arg::Object(output))?;
            header.opcode = 7;
        },
        Request::SetTitle {
            title,
        } => {
            msg.write_arg(Arg::String(title))?;
            header.opcode = 8;
        },
        Request::SetClass {
            class_,
        } => {
            msg.write_arg(Arg::String(class_))?;
            header.opcode = 9;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* ping */ => {
            let mut iter = args.into_iter();
            Ok(Event::Ping {
                serial: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,

            })
        },
        1 /* configure */ => {
            let mut iter = args.into_iter();
            Ok(Event::Configure {
                edges: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match Resize::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,
                width: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,
                height: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,

            })
        },
        2 /* popup_done */ => {
            let mut iter = args.into_iter();
            Ok(Event::PopupDone {

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
::bitflags::bitflags! {

    /// edge values for resizing
    ///
    /// These values are used to indicate which edge of a surface
    /// is being dragged in a resize operation. The server may
    /// use this information to adapt its behavior, e.g. choose
    /// an appropriate cursor image.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Resize: u32 {
        /// no edge,
        const None = 0;
        /// top edge,
        const Top = 1;
        /// bottom edge,
        const Bottom = 2;
        /// left edge,
        const Left = 4;
        /// top and left edges,
        const TopLeft = 5;
        /// bottom and left edges,
        const BottomLeft = 6;
        /// right edge,
        const Right = 8;
        /// top and right edges,
        const TopRight = 9;
        /// bottom and right edges,
        const BottomRight = 10;
    }
}
impl Into<Arg> for Resize {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
::bitflags::bitflags! {

    /// details of transient behaviour
    ///
    /// These flags specify details of the expected behaviour
    /// of transient surfaces. Used in the set_transient request.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Transient: u32 {
        /// do not set keyboard focus,
        const Inactive = 1;
    }
}
impl Into<Arg> for Transient {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}

/// different method to set the surface fullscreen
///
/// Hints to indicate to the compositor how to deal with a conflict
/// between the dimensions of the surface and the dimensions of the
/// output. The compositor is free to ignore this parameter.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum FullscreenMethod {
    /// no preference, apply default policy,
    Default = 0,
    /// scale, preserve the surface's aspect ratio and center on output,
    Scale = 1,
    /// switch output mode to the smallest mode that can fit the surface, add black borders to compensate size mismatch,
    Driver = 2,
    /// no upscaling, center on output and add black borders to compensate size mismatch,
    Fill = 3,
}

impl FullscreenMethod {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(FullscreenMethod::Default),
        1 => Some(FullscreenMethod::Scale),
        2 => Some(FullscreenMethod::Driver),
        3 => Some(FullscreenMethod::Fill),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for FullscreenMethod {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_shell_surface

pub use crate::wl_shell_surface::WlShellSurface;
pub use crate::wl_shell_surface::Request as WlShellSurfaceRequest;
pub use crate::wl_shell_surface::Event as WlShellSurfaceEvent;
pub mod wl_surface {
use super::*;

/// an onscreen surface
///
/// A surface is a rectangular area that may be displayed on zero
/// or more outputs, and shown any number of times at the compositor's
/// discretion. They can present wl_buffers, receive user input, and
/// define a local coordinate system.
/// 
/// The size of a surface (and relative positions on it) is described
/// in surface-local coordinates, which may differ from the buffer
/// coordinates of the pixel content, in case a buffer_transform
/// or a buffer_scale is used.
/// 
/// A surface without a "role" is fairly useless: a compositor does
/// not know where, when or how to present it. The role is the
/// purpose of a wl_surface. Examples of roles are a cursor for a
/// pointer (as set by wl_pointer.set_cursor), a drag icon
/// (wl_data_device.start_drag), a sub-surface
/// (wl_subcompositor.get_subsurface), and a window as defined by a
/// shell protocol (e.g. wl_shell.get_shell_surface).
/// 
/// A surface can have only one role at a time. Initially a
/// wl_surface does not have a role. Once a wl_surface is given a
/// role, it is set permanently for the whole lifetime of the
/// wl_surface object. Giving the current role again is allowed,
/// unless explicitly forbidden by the relevant interface
/// specification.
/// 
/// Surface roles are given by requests in other interfaces such as
/// wl_pointer.set_cursor. The request should explicitly mention
/// that this request gives a role to a wl_surface. Often, this
/// request also creates a new protocol object that represents the
/// role and adds additional functionality to wl_surface. When a
/// client wants to destroy a wl_surface, they must destroy this 'role
/// object' before the wl_surface.
/// 
/// Destroying the role object does not remove the role from the
/// wl_surface, but it may stop the wl_surface from "playing the role".
/// For instance, if a wl_subsurface object is destroyed, the wl_surface
/// it was created for will be unmapped and forget its position and
/// z-order. It is allowed to create a wl_subsurface for the same
/// wl_surface again, but it is not allowed to use the wl_surface as
/// a cursor (cursor is a different role than sub-surface, and role
/// switching is not allowed).
#[derive(Debug)]
pub struct WlSurface;

impl Interface for WlSurface {
    const NAME: &'static str = "wl_surface";
    const VERSION: u32 = 4;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // destroy
        MessageSpec(&[
        ]),
        // attach
        MessageSpec(&[
            ArgKind::Object,
            ArgKind::Int,
            ArgKind::Int,
        ]),
        // damage
        MessageSpec(&[
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Int,
        ]),
        // frame
        MessageSpec(&[
            ArgKind::NewId,
        ]),
        // set_opaque_region
        MessageSpec(&[
            ArgKind::Object,
        ]),
        // set_input_region
        MessageSpec(&[
            ArgKind::Object,
        ]),
        // commit
        MessageSpec(&[
        ]),
        // set_buffer_transform
        MessageSpec(&[
            ArgKind::Uint,
        ]),
        // set_buffer_scale
        MessageSpec(&[
            ArgKind::Int,
        ]),
        // damage_buffer
        MessageSpec(&[
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Int,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // enter
        MessageSpec(&[
            ArgKind::Object,
        ]),
        // leave
        MessageSpec(&[
            ArgKind::Object,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// delete surface
    ///
    /// Deletes the surface and invalidates its object ID.
    Destroy,

    /// set the surface contents
    ///
    /// Set a buffer as the content of this surface.
    /// 
    /// The new size of the surface is calculated based on the buffer
    /// size transformed by the inverse buffer_transform and the
    /// inverse buffer_scale. This means that at commit time the supplied
    /// buffer size must be an integer multiple of the buffer_scale. If
    /// that's not the case, an invalid_size error is sent.
    /// 
    /// The x and y arguments specify the location of the new pending
    /// buffer's upper left corner, relative to the current buffer's upper
    /// left corner, in surface-local coordinates. In other words, the
    /// x and y, combined with the new surface size define in which
    /// directions the surface's size changes.
    /// 
    /// Surface contents are double-buffered state, see wl_surface.commit.
    /// 
    /// The initial surface contents are void; there is no content.
    /// wl_surface.attach assigns the given wl_buffer as the pending
    /// wl_buffer. wl_surface.commit makes the pending wl_buffer the new
    /// surface contents, and the size of the surface becomes the size
    /// calculated from the wl_buffer, as described above. After commit,
    /// there is no pending buffer until the next attach.
    /// 
    /// Committing a pending wl_buffer allows the compositor to read the
    /// pixels in the wl_buffer. The compositor may access the pixels at
    /// any time after the wl_surface.commit request. When the compositor
    /// will not access the pixels anymore, it will send the
    /// wl_buffer.release event. Only after receiving wl_buffer.release,
    /// the client may reuse the wl_buffer. A wl_buffer that has been
    /// attached and then replaced by another attach instead of committed
    /// will not receive a release event, and is not used by the
    /// compositor.
    /// 
    /// If a pending wl_buffer has been committed to more than one wl_surface,
    /// the delivery of wl_buffer.release events becomes undefined. A well
    /// behaved client should not rely on wl_buffer.release events in this
    /// case. Alternatively, a client could create multiple wl_buffer objects
    /// from the same backing storage or use wp_linux_buffer_release.
    /// 
    /// Destroying the wl_buffer after wl_buffer.release does not change
    /// the surface contents. However, if the client destroys the
    /// wl_buffer before receiving the wl_buffer.release event, the surface
    /// contents become undefined immediately.
    /// 
    /// If wl_surface.attach is sent with a NULL wl_buffer, the
    /// following wl_surface.commit will remove the surface content.
    Attach {
        /// buffer of surface contents
        buffer: ObjectId,
        /// surface-local x coordinate
        x: i32,
        /// surface-local y coordinate
        y: i32,
    },

    /// mark part of the surface damaged
    ///
    /// This request is used to describe the regions where the pending
    /// buffer is different from the current surface contents, and where
    /// the surface therefore needs to be repainted. The compositor
    /// ignores the parts of the damage that fall outside of the surface.
    /// 
    /// Damage is double-buffered state, see wl_surface.commit.
    /// 
    /// The damage rectangle is specified in surface-local coordinates,
    /// where x and y specify the upper left corner of the damage rectangle.
    /// 
    /// The initial value for pending damage is empty: no damage.
    /// wl_surface.damage adds pending damage: the new pending damage
    /// is the union of old pending damage and the given rectangle.
    /// 
    /// wl_surface.commit assigns pending damage as the current damage,
    /// and clears pending damage. The server will clear the current
    /// damage as it repaints the surface.
    /// 
    /// Note! New clients should not use this request. Instead damage can be
    /// posted with wl_surface.damage_buffer which uses buffer coordinates
    /// instead of surface coordinates.
    Damage {
        /// surface-local x coordinate
        x: i32,
        /// surface-local y coordinate
        y: i32,
        /// width of damage rectangle
        width: i32,
        /// height of damage rectangle
        height: i32,
    },

    /// request a frame throttling hint
    ///
    /// Request a notification when it is a good time to start drawing a new
    /// frame, by creating a frame callback. This is useful for throttling
    /// redrawing operations, and driving animations.
    /// 
    /// When a client is animating on a wl_surface, it can use the 'frame'
    /// request to get notified when it is a good time to draw and commit the
    /// next frame of animation. If the client commits an update earlier than
    /// that, it is likely that some updates will not make it to the display,
    /// and the client is wasting resources by drawing too often.
    /// 
    /// The frame request will take effect on the next wl_surface.commit.
    /// The notification will only be posted for one frame unless
    /// requested again. For a wl_surface, the notifications are posted in
    /// the order the frame requests were committed.
    /// 
    /// The server must send the notifications so that a client
    /// will not send excessive updates, while still allowing
    /// the highest possible update rate for clients that wait for the reply
    /// before drawing again. The server should give some time for the client
    /// to draw and commit after sending the frame callback events to let it
    /// hit the next output refresh.
    /// 
    /// A server should avoid signaling the frame callbacks if the
    /// surface is not visible in any way, e.g. the surface is off-screen,
    /// or completely obscured by other opaque surfaces.
    /// 
    /// 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 the current time, in
    /// milliseconds, with an undefined base.
    Frame {
        /// callback object for the frame request
        callback: NewId,
    },

    /// set opaque region
    ///
    /// This request sets the region of the surface that contains
    /// opaque content.
    /// 
    /// The opaque region is an optimization hint for the compositor
    /// that lets it optimize the redrawing of content behind opaque
    /// regions.  Setting an opaque region is not required for correct
    /// behaviour, but marking transparent content as opaque will result
    /// in repaint artifacts.
    /// 
    /// The opaque region is specified in surface-local coordinates.
    /// 
    /// The compositor ignores the parts of the opaque region that fall
    /// outside of the surface.
    /// 
    /// Opaque region is double-buffered state, see wl_surface.commit.
    /// 
    /// wl_surface.set_opaque_region changes the pending opaque region.
    /// wl_surface.commit copies the pending region to the current region.
    /// Otherwise, the pending and current regions are never changed.
    /// 
    /// The initial value for an opaque region is empty. Setting the pending
    /// opaque region has copy semantics, and the wl_region object can be
    /// destroyed immediately. A NULL wl_region causes the pending opaque
    /// region to be set to empty.
    SetOpaqueRegion {
        /// opaque region of the surface
        region: ObjectId,
    },

    /// set input region
    ///
    /// This request sets the region of the surface that can receive
    /// pointer and touch events.
    /// 
    /// Input events happening outside of this region will try the next
    /// surface in the server surface stack. The compositor ignores the
    /// parts of the input region that fall outside of the surface.
    /// 
    /// The input region is specified in surface-local coordinates.
    /// 
    /// Input region is double-buffered state, see wl_surface.commit.
    /// 
    /// wl_surface.set_input_region changes the pending input region.
    /// wl_surface.commit copies the pending region to the current region.
    /// Otherwise the pending and current regions are never changed,
    /// except cursor and icon surfaces are special cases, see
    /// wl_pointer.set_cursor and wl_data_device.start_drag.
    /// 
    /// The initial value for an input region is infinite. That means the
    /// whole surface will accept input. Setting the pending input region
    /// has copy semantics, and the wl_region object can be destroyed
    /// immediately. A NULL wl_region causes the input region to be set
    /// to infinite.
    SetInputRegion {
        /// input region of the surface
        region: ObjectId,
    },

    /// commit pending surface state
    ///
    /// Surface state (input, opaque, and damage regions, attached buffers,
    /// etc.) is double-buffered. Protocol requests modify the pending state,
    /// as opposed to the current state in use by the compositor. A commit
    /// request atomically applies all pending state, replacing the current
    /// state. After commit, the new pending state is as documented for each
    /// related request.
    /// 
    /// On commit, a pending wl_buffer is applied first, and all other state
    /// second. This means that all coordinates in double-buffered state are
    /// relative to the new wl_buffer coming into use, except for
    /// wl_surface.attach itself. If there is no pending wl_buffer, the
    /// coordinates are relative to the current surface contents.
    /// 
    /// All requests that need a commit to become effective are documented
    /// to affect double-buffered state.
    /// 
    /// Other interfaces may add further double-buffered surface state.
    Commit,

    /// sets the buffer transformation
    ///
    /// This request sets an optional transformation on how the compositor
    /// interprets the contents of the buffer attached to the surface. The
    /// accepted values for the transform parameter are the values for
    /// wl_output.transform.
    /// 
    /// Buffer transform is double-buffered state, see wl_surface.commit.
    /// 
    /// A newly created surface has its buffer transformation set to normal.
    /// 
    /// wl_surface.set_buffer_transform changes the pending buffer
    /// transformation. wl_surface.commit copies the pending buffer
    /// transformation to the current one. Otherwise, the pending and current
    /// values are never changed.
    /// 
    /// The purpose of this request is to allow clients to render content
    /// according to the output transform, thus permitting the compositor to
    /// use certain optimizations even if the display is rotated. Using
    /// hardware overlays and scanning out a client buffer for fullscreen
    /// surfaces are examples of such optimizations. Those optimizations are
    /// highly dependent on the compositor implementation, so the use of this
    /// request should be considered on a case-by-case basis.
    /// 
    /// Note that if the transform value includes 90 or 270 degree rotation,
    /// the width of the buffer will become the surface height and the height
    /// of the buffer will become the surface width.
    /// 
    /// If transform is not one of the values from the
    /// wl_output.transform enum the invalid_transform protocol error
    /// is raised.
    SetBufferTransform {
        /// transform for interpreting buffer contents
        transform: crate::wl_output::Transform,
    },

    /// sets the buffer scaling factor
    ///
    /// This request sets an optional scaling factor on how the compositor
    /// interprets the contents of the buffer attached to the window.
    /// 
    /// Buffer scale is double-buffered state, see wl_surface.commit.
    /// 
    /// A newly created surface has its buffer scale set to 1.
    /// 
    /// wl_surface.set_buffer_scale changes the pending buffer scale.
    /// wl_surface.commit copies the pending buffer scale to the current one.
    /// Otherwise, the pending and current values are never changed.
    /// 
    /// The purpose of this request is to allow clients to supply higher
    /// resolution buffer data for use on high resolution outputs. It is
    /// intended that you pick the same buffer scale as the scale of the
    /// output that the surface is displayed on. This means the compositor
    /// can avoid scaling when rendering the surface on that output.
    /// 
    /// Note that if the scale is larger than 1, then you have to attach
    /// a buffer that is larger (by a factor of scale in each dimension)
    /// than the desired surface size.
    /// 
    /// If scale is not positive the invalid_scale protocol error is
    /// raised.
    SetBufferScale {
        /// positive scale for interpreting buffer contents
        scale: i32,
    },

    /// mark part of the surface damaged using buffer coordinates
    ///
    /// This request is used to describe the regions where the pending
    /// buffer is different from the current surface contents, and where
    /// the surface therefore needs to be repainted. The compositor
    /// ignores the parts of the damage that fall outside of the surface.
    /// 
    /// Damage is double-buffered state, see wl_surface.commit.
    /// 
    /// The damage rectangle is specified in buffer coordinates,
    /// where x and y specify the upper left corner of the damage rectangle.
    /// 
    /// The initial value for pending damage is empty: no damage.
    /// wl_surface.damage_buffer adds pending damage: the new pending
    /// damage is the union of old pending damage and the given rectangle.
    /// 
    /// wl_surface.commit assigns pending damage as the current damage,
    /// and clears pending damage. The server will clear the current
    /// damage as it repaints the surface.
    /// 
    /// This request differs from wl_surface.damage in only one way - it
    /// takes damage in buffer coordinates instead of surface-local
    /// coordinates. While this generally is more intuitive than surface
    /// coordinates, it is especially desirable when using wp_viewport
    /// or when a drawing library (like EGL) is unaware of buffer scale
    /// and buffer transform.
    /// 
    /// Note: Because buffer transformation changes and damage requests may
    /// be interleaved in the protocol stream, it is impossible to determine
    /// the actual mapping between surface and buffer damage until
    /// wl_surface.commit time. Therefore, compositors wishing to take both
    /// kinds of damage into account will have to accumulate damage from the
    /// two requests separately and only transform from one to the other
    /// after receiving the wl_surface.commit.
    DamageBuffer {
        /// buffer-local x coordinate
        x: i32,
        /// buffer-local y coordinate
        y: i32,
        /// width of damage rectangle
        width: i32,
        /// height of damage rectangle
        height: i32,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::Destroy {
            } => {
                format!("wl_surface@{:?}::destroy()", this)
            }
            Request::Attach {
                ref buffer,
                ref x,
                ref y,
            } => {
                format!("wl_surface@{:?}::attach(buffer: {:?}, x: {:?}, y: {:?})", this, buffer, x, y)
            }
            Request::Damage {
                ref x,
                ref y,
                ref width,
                ref height,
            } => {
                format!("wl_surface@{:?}::damage(x: {:?}, y: {:?}, width: {:?}, height: {:?})", this, x, y, width, height)
            }
            Request::Frame {
                ref callback,
            } => {
                format!("wl_surface@{:?}::frame(callback: {:?})", this, callback)
            }
            Request::SetOpaqueRegion {
                ref region,
            } => {
                format!("wl_surface@{:?}::set_opaque_region(region: {:?})", this, region)
            }
            Request::SetInputRegion {
                ref region,
            } => {
                format!("wl_surface@{:?}::set_input_region(region: {:?})", this, region)
            }
            Request::Commit {
            } => {
                format!("wl_surface@{:?}::commit()", this)
            }
            Request::SetBufferTransform {
                ref transform,
            } => {
                format!("wl_surface@{:?}::set_buffer_transform(transform: {:?})", this, transform)
            }
            Request::SetBufferScale {
                ref scale,
            } => {
                format!("wl_surface@{:?}::set_buffer_scale(scale: {:?})", this, scale)
            }
            Request::DamageBuffer {
                ref x,
                ref y,
                ref width,
                ref height,
            } => {
                format!("wl_surface@{:?}::damage_buffer(x: {:?}, y: {:?}, width: {:?}, height: {:?})", this, x, y, width, height)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::Destroy { .. } => c"wl_surface::destroy",
            Request::Attach { .. } => c"wl_surface::attach",
            Request::Damage { .. } => c"wl_surface::damage",
            Request::Frame { .. } => c"wl_surface::frame",
            Request::SetOpaqueRegion { .. } => c"wl_surface::set_opaque_region",
            Request::SetInputRegion { .. } => c"wl_surface::set_input_region",
            Request::Commit { .. } => c"wl_surface::commit",
            Request::SetBufferTransform { .. } => c"wl_surface::set_buffer_transform",
            Request::SetBufferScale { .. } => c"wl_surface::set_buffer_scale",
            Request::DamageBuffer { .. } => c"wl_surface::damage_buffer",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// surface enters an output
    ///
    /// This is emitted whenever a surface's creation, movement, or resizing
    /// results in some part of it being within the scanout region of an
    /// output.
    /// 
    /// Note that a surface may be overlapping with zero or more outputs.
    Enter {
        /// output entered by the surface
        output: ObjectId,
    },

    /// surface leaves an output
    ///
    /// This is emitted whenever a surface's creation, movement, or resizing
    /// results in it no longer having any part of it within the scanout region
    /// of an output.
    Leave {
        /// output left by the surface
        output: ObjectId,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Enter {
                ref output,
            } => {
                format!("wl_surface@{:?}::enter(output: {:?})", this, output)
            }
            Event::Leave {
                ref output,
            } => {
                format!("wl_surface@{:?}::leave(output: {:?})", this, output)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Enter { .. } => c"wl_surface::enter",
            Event::Leave { .. } => c"wl_surface::leave",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::Destroy {
        } => {
            header.opcode = 0;
        },
        Request::Attach {
            buffer,
            x,
            y,
        } => {
            msg.write_arg(Arg::Object(buffer))?;
            msg.write_arg(Arg::Int(x))?;
            msg.write_arg(Arg::Int(y))?;
            header.opcode = 1;
        },
        Request::Damage {
            x,
            y,
            width,
            height,
        } => {
            msg.write_arg(Arg::Int(x))?;
            msg.write_arg(Arg::Int(y))?;
            msg.write_arg(Arg::Int(width))?;
            msg.write_arg(Arg::Int(height))?;
            header.opcode = 2;
        },
        Request::Frame {
            callback,
        } => {
            msg.write_arg(Arg::NewId(callback))?;
            header.opcode = 3;
        },
        Request::SetOpaqueRegion {
            region,
        } => {
            msg.write_arg(Arg::Object(region))?;
            header.opcode = 4;
        },
        Request::SetInputRegion {
            region,
        } => {
            msg.write_arg(Arg::Object(region))?;
            header.opcode = 5;
        },
        Request::Commit {
        } => {
            header.opcode = 6;
        },
        Request::SetBufferTransform {
            transform,
        } => {
            msg.write_arg(Arg::Uint(transform.bits()))?;
            header.opcode = 7;
        },
        Request::SetBufferScale {
            scale,
        } => {
            msg.write_arg(Arg::Int(scale))?;
            header.opcode = 8;
        },
        Request::DamageBuffer {
            x,
            y,
            width,
            height,
        } => {
            msg.write_arg(Arg::Int(x))?;
            msg.write_arg(Arg::Int(y))?;
            msg.write_arg(Arg::Int(width))?;
            msg.write_arg(Arg::Int(height))?;
            header.opcode = 9;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* enter */ => {
            let mut iter = args.into_iter();
            Ok(Event::Enter {
                output: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_object()?,

            })
        },
        1 /* leave */ => {
            let mut iter = args.into_iter();
            Ok(Event::Leave {
                output: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_object()?,

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}

/// wl_surface error values
///
/// These errors can be emitted in response to wl_surface requests.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Error {
    /// buffer scale value is invalid,
    InvalidScale = 0,
    /// buffer transform value is invalid,
    InvalidTransform = 1,
    /// buffer size is invalid,
    InvalidSize = 2,
}

impl Error {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Error::InvalidScale),
        1 => Some(Error::InvalidTransform),
        2 => Some(Error::InvalidSize),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Error {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_surface

pub use crate::wl_surface::WlSurface;
pub use crate::wl_surface::Request as WlSurfaceRequest;
pub use crate::wl_surface::Event as WlSurfaceEvent;
pub mod wl_seat {
use super::*;

/// group of input devices
///
/// A seat is a group of keyboards, pointer and touch devices. This
/// object is published as a global during start up, or when such a
/// device is hot plugged.  A seat typically has a pointer and
/// maintains a keyboard focus and a pointer focus.
#[derive(Debug)]
pub struct WlSeat;

impl Interface for WlSeat {
    const NAME: &'static str = "wl_seat";
    const VERSION: u32 = 7;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // get_pointer
        MessageSpec(&[
            ArgKind::NewId,
        ]),
        // get_keyboard
        MessageSpec(&[
            ArgKind::NewId,
        ]),
        // get_touch
        MessageSpec(&[
            ArgKind::NewId,
        ]),
        // release
        MessageSpec(&[
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // capabilities
        MessageSpec(&[
            ArgKind::Uint,
        ]),
        // name
        MessageSpec(&[
            ArgKind::String,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// return pointer object
    ///
    /// The ID provided will be initialized to the wl_pointer interface
    /// for this seat.
    /// 
    /// This request only takes effect if the seat has the pointer
    /// capability, or has had the pointer capability in the past.
    /// It is a protocol violation to issue this request on a seat that has
    /// never had the pointer capability. The missing_capability error will
    /// be sent in this case.
    GetPointer {
        /// seat pointer
        id: NewId,
    },

    /// return keyboard object
    ///
    /// The ID provided will be initialized to the wl_keyboard interface
    /// for this seat.
    /// 
    /// This request only takes effect if the seat has the keyboard
    /// capability, or has had the keyboard capability in the past.
    /// It is a protocol violation to issue this request on a seat that has
    /// never had the keyboard capability. The missing_capability error will
    /// be sent in this case.
    GetKeyboard {
        /// seat keyboard
        id: NewId,
    },

    /// return touch object
    ///
    /// The ID provided will be initialized to the wl_touch interface
    /// for this seat.
    /// 
    /// This request only takes effect if the seat has the touch
    /// capability, or has had the touch capability in the past.
    /// It is a protocol violation to issue this request on a seat that has
    /// never had the touch capability. The missing_capability error will
    /// be sent in this case.
    GetTouch {
        /// seat touch interface
        id: NewId,
    },

    /// release the seat object
    ///
    /// Using this request a client can tell the server that it is not going to
    /// use the seat object anymore.
    Release,
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::GetPointer {
                ref id,
            } => {
                format!("wl_seat@{:?}::get_pointer(id: {:?})", this, id)
            }
            Request::GetKeyboard {
                ref id,
            } => {
                format!("wl_seat@{:?}::get_keyboard(id: {:?})", this, id)
            }
            Request::GetTouch {
                ref id,
            } => {
                format!("wl_seat@{:?}::get_touch(id: {:?})", this, id)
            }
            Request::Release {
            } => {
                format!("wl_seat@{:?}::release()", this)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::GetPointer { .. } => c"wl_seat::get_pointer",
            Request::GetKeyboard { .. } => c"wl_seat::get_keyboard",
            Request::GetTouch { .. } => c"wl_seat::get_touch",
            Request::Release { .. } => c"wl_seat::release",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// seat capabilities changed
    ///
    /// This is emitted whenever a seat gains or loses the pointer,
    /// keyboard or touch capabilities.  The argument is a capability
    /// enum containing the complete set of capabilities this seat has.
    /// 
    /// When the pointer capability is added, a client may create a
    /// wl_pointer object using the wl_seat.get_pointer request. This object
    /// will receive pointer events until the capability is removed in the
    /// future.
    /// 
    /// When the pointer capability is removed, a client should destroy the
    /// wl_pointer objects associated with the seat where the capability was
    /// removed, using the wl_pointer.release request. No further pointer
    /// events will be received on these objects.
    /// 
    /// In some compositors, if a seat regains the pointer capability and a
    /// client has a previously obtained wl_pointer object of version 4 or
    /// less, that object may start sending pointer events again. This
    /// behavior is considered a misinterpretation of the intended behavior
    /// and must not be relied upon by the client. wl_pointer objects of
    /// version 5 or later must not send events if created before the most
    /// recent event notifying the client of an added pointer capability.
    /// 
    /// The above behavior also applies to wl_keyboard and wl_touch with the
    /// keyboard and touch capabilities, respectively.
    Capabilities {
        /// capabilities of the seat
        capabilities: Enum<Capability>,
    },

    /// unique identifier for this seat
    ///
    /// In a multiseat configuration this can be used by the client to help
    /// identify which physical devices the seat represents. Based on
    /// the seat configuration used by the compositor.
    Name {
        /// seat identifier
        name: String,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Capabilities {
                ref capabilities,
            } => {
                format!("wl_seat@{:?}::capabilities(capabilities: {:?})", this, capabilities)
            }
            Event::Name {
                ref name,
            } => {
                format!("wl_seat@{:?}::name(name: {:?})", this, name)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Capabilities { .. } => c"wl_seat::capabilities",
            Event::Name { .. } => c"wl_seat::name",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::GetPointer {
            id,
        } => {
            msg.write_arg(Arg::NewId(id))?;
            header.opcode = 0;
        },
        Request::GetKeyboard {
            id,
        } => {
            msg.write_arg(Arg::NewId(id))?;
            header.opcode = 1;
        },
        Request::GetTouch {
            id,
        } => {
            msg.write_arg(Arg::NewId(id))?;
            header.opcode = 2;
        },
        Request::Release {
        } => {
            header.opcode = 3;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* capabilities */ => {
            let mut iter = args.into_iter();
            Ok(Event::Capabilities {
                capabilities: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match Capability::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,

            })
        },
        1 /* name */ => {
            let mut iter = args.into_iter();
            Ok(Event::Name {
                name: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_string()?,

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
::bitflags::bitflags! {

    /// seat capability bitmask
    ///
    /// This is a bitmask of capabilities this seat has; if a member is
    /// set, then it is present on the seat.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Capability: u32 {
        /// the seat has pointer devices,
        const Pointer = 1;
        /// the seat has one or more keyboards,
        const Keyboard = 2;
        /// the seat has touch devices,
        const Touch = 4;
    }
}
impl Into<Arg> for Capability {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}

/// wl_seat error values
///
/// These errors can be emitted in response to wl_seat requests.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Error {
    /// get_pointer, get_keyboard or get_touch called on seat without the matching capability,
    MissingCapability = 0,
}

impl Error {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Error::MissingCapability),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Error {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_seat

pub use crate::wl_seat::WlSeat;
pub use crate::wl_seat::Request as WlSeatRequest;
pub use crate::wl_seat::Event as WlSeatEvent;
pub mod wl_pointer {
use super::*;

/// pointer input device
///
/// The wl_pointer interface represents one or more input devices,
/// such as mice, which control the pointer location and pointer_focus
/// of a seat.
/// 
/// The wl_pointer interface generates motion, enter and leave
/// events for the surfaces that the pointer is located over,
/// and button and axis events for button presses, button releases
/// and scrolling.
#[derive(Debug)]
pub struct WlPointer;

impl Interface for WlPointer {
    const NAME: &'static str = "wl_pointer";
    const VERSION: u32 = 7;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // set_cursor
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Object,
            ArgKind::Int,
            ArgKind::Int,
        ]),
        // release
        MessageSpec(&[
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // enter
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Object,
            ArgKind::Fixed,
            ArgKind::Fixed,
        ]),
        // leave
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Object,
        ]),
        // motion
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Fixed,
            ArgKind::Fixed,
        ]),
        // button
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Uint,
            ArgKind::Uint,
            ArgKind::Uint,
        ]),
        // axis
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Uint,
            ArgKind::Fixed,
        ]),
        // frame
        MessageSpec(&[
        ]),
        // axis_source
        MessageSpec(&[
            ArgKind::Uint,
        ]),
        // axis_stop
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Uint,
        ]),
        // axis_discrete
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Int,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// set the pointer surface
    ///
    /// Set the pointer surface, i.e., the surface that contains the
    /// pointer image (cursor). This request gives the surface the role
    /// of a cursor. If the surface already has another role, it raises
    /// a protocol error.
    /// 
    /// The cursor actually changes only if the pointer
    /// focus for this device is one of the requesting client's surfaces
    /// or the surface parameter is the current pointer surface. If
    /// there was a previous surface set with this request it is
    /// replaced. If surface is NULL, the pointer image is hidden.
    /// 
    /// The parameters hotspot_x and hotspot_y define the position of
    /// the pointer surface relative to the pointer location. Its
    /// top-left corner is always at (x, y) - (hotspot_x, hotspot_y),
    /// where (x, y) are the coordinates of the pointer location, in
    /// surface-local coordinates.
    /// 
    /// On surface.attach requests to the pointer surface, hotspot_x
    /// and hotspot_y are decremented by the x and y parameters
    /// passed to the request. Attach must be confirmed by
    /// wl_surface.commit as usual.
    /// 
    /// The hotspot can also be updated by passing the currently set
    /// pointer surface to this request with new values for hotspot_x
    /// and hotspot_y.
    /// 
    /// The current and pending input regions of the wl_surface are
    /// cleared, and wl_surface.set_input_region is ignored until the
    /// wl_surface is no longer used as the cursor. When the use as a
    /// cursor ends, the current and pending input regions become
    /// undefined, and the wl_surface is unmapped.
    SetCursor {
        /// serial number of the enter event
        serial: u32,
        /// pointer surface
        surface: ObjectId,
        /// surface-local x coordinate
        hotspot_x: i32,
        /// surface-local y coordinate
        hotspot_y: i32,
    },

    /// release the pointer object
    ///
    /// Using this request a client can tell the server that it is not going to
    /// use the pointer object anymore.
    /// 
    /// This request destroys the pointer proxy object, so clients must not call
    /// wl_pointer_destroy() after using this request.
    Release,
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::SetCursor {
                ref serial,
                ref surface,
                ref hotspot_x,
                ref hotspot_y,
            } => {
                format!("wl_pointer@{:?}::set_cursor(serial: {:?}, surface: {:?}, hotspot_x: {:?}, hotspot_y: {:?})", this, serial, surface, hotspot_x, hotspot_y)
            }
            Request::Release {
            } => {
                format!("wl_pointer@{:?}::release()", this)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::SetCursor { .. } => c"wl_pointer::set_cursor",
            Request::Release { .. } => c"wl_pointer::release",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// enter event
    ///
    /// Notification that this seat's pointer is focused on a certain
    /// surface.
    /// 
    /// When a seat's focus enters a surface, the pointer image
    /// is undefined and a client should respond to this event by setting
    /// an appropriate pointer image with the set_cursor request.
    Enter {
        /// serial number of the enter event
        serial: u32,
        /// surface entered by the pointer
        surface: ObjectId,
        /// surface-local x coordinate
        surface_x: Fixed,
        /// surface-local y coordinate
        surface_y: Fixed,
    },

    /// leave event
    ///
    /// Notification that this seat's pointer is no longer focused on
    /// a certain surface.
    /// 
    /// The leave notification is sent before the enter notification
    /// for the new focus.
    Leave {
        /// serial number of the leave event
        serial: u32,
        /// surface left by the pointer
        surface: ObjectId,
    },

    /// pointer motion event
    ///
    /// Notification of pointer location change. The arguments
    /// surface_x and surface_y are the location relative to the
    /// focused surface.
    Motion {
        /// timestamp with millisecond granularity
        time: u32,
        /// surface-local x coordinate
        surface_x: Fixed,
        /// surface-local y coordinate
        surface_y: Fixed,
    },

    /// pointer button event
    ///
    /// Mouse button click and release notifications.
    /// 
    /// The location of the click is given by the last motion or
    /// enter event.
    /// The time argument is a timestamp with millisecond
    /// granularity, with an undefined base.
    /// 
    /// The button is a button code as defined in the Linux kernel's
    /// linux/input-event-codes.h header file, e.g. BTN_LEFT.
    /// 
    /// Any 16-bit button code value is reserved for future additions to the
    /// kernel's event code list. All other button codes above 0xFFFF are
    /// currently undefined but may be used in future versions of this
    /// protocol.
    Button {
        /// serial number of the button event
        serial: u32,
        /// timestamp with millisecond granularity
        time: u32,
        /// button that produced the event
        button: u32,
        /// physical state of the button
        state: Enum<ButtonState>,
    },

    /// axis event
    ///
    /// Scroll and other axis notifications.
    /// 
    /// For scroll events (vertical and horizontal scroll axes), the
    /// value parameter is the length of a vector along the specified
    /// axis in a coordinate space identical to those of motion events,
    /// representing a relative movement along the specified axis.
    /// 
    /// For devices that support movements non-parallel to axes multiple
    /// axis events will be emitted.
    /// 
    /// When applicable, for example for touch pads, the server can
    /// choose to emit scroll events where the motion vector is
    /// equivalent to a motion event vector.
    /// 
    /// When applicable, a client can transform its content relative to the
    /// scroll distance.
    Axis {
        /// timestamp with millisecond granularity
        time: u32,
        /// axis type
        axis: Enum<Axis>,
        /// length of vector in surface-local coordinate space
        value: Fixed,
    },

    /// end of a pointer event sequence
    ///
    /// Indicates the end of a set of events that logically belong together.
    /// A client is expected to accumulate the data in all events within the
    /// frame before proceeding.
    /// 
    /// All wl_pointer events before a wl_pointer.frame event belong
    /// logically together. For example, in a diagonal scroll motion the
    /// compositor will send an optional wl_pointer.axis_source event, two
    /// wl_pointer.axis events (horizontal and vertical) and finally a
    /// wl_pointer.frame event. The client may use this information to
    /// calculate a diagonal vector for scrolling.
    /// 
    /// When multiple wl_pointer.axis events occur within the same frame,
    /// the motion vector is the combined motion of all events.
    /// When a wl_pointer.axis and a wl_pointer.axis_stop event occur within
    /// the same frame, this indicates that axis movement in one axis has
    /// stopped but continues in the other axis.
    /// When multiple wl_pointer.axis_stop events occur within the same
    /// frame, this indicates that these axes stopped in the same instance.
    /// 
    /// A wl_pointer.frame event is sent for every logical event group,
    /// even if the group only contains a single wl_pointer event.
    /// Specifically, a client may get a sequence: motion, frame, button,
    /// frame, axis, frame, axis_stop, frame.
    /// 
    /// The wl_pointer.enter and wl_pointer.leave events are logical events
    /// generated by the compositor and not the hardware. These events are
    /// also grouped by a wl_pointer.frame. When a pointer moves from one
    /// surface to another, a compositor should group the
    /// wl_pointer.leave event within the same wl_pointer.frame.
    /// However, a client must not rely on wl_pointer.leave and
    /// wl_pointer.enter being in the same wl_pointer.frame.
    /// Compositor-specific policies may require the wl_pointer.leave and
    /// wl_pointer.enter event being split across multiple wl_pointer.frame
    /// groups.
    Frame,

    /// axis source event
    ///
    /// Source information for scroll and other axes.
    /// 
    /// This event does not occur on its own. It is sent before a
    /// wl_pointer.frame event and carries the source information for
    /// all events within that frame.
    /// 
    /// The source specifies how this event was generated. If the source is
    /// wl_pointer.axis_source.finger, a wl_pointer.axis_stop event will be
    /// sent when the user lifts the finger off the device.
    /// 
    /// If the source is wl_pointer.axis_source.wheel,
    /// wl_pointer.axis_source.wheel_tilt or
    /// wl_pointer.axis_source.continuous, a wl_pointer.axis_stop event may
    /// or may not be sent. Whether a compositor sends an axis_stop event
    /// for these sources is hardware-specific and implementation-dependent;
    /// clients must not rely on receiving an axis_stop event for these
    /// scroll sources and should treat scroll sequences from these scroll
    /// sources as unterminated by default.
    /// 
    /// This event is optional. If the source is unknown for a particular
    /// axis event sequence, no event is sent.
    /// Only one wl_pointer.axis_source event is permitted per frame.
    /// 
    /// The order of wl_pointer.axis_discrete and wl_pointer.axis_source is
    /// not guaranteed.
    AxisSource {
        /// source of the axis event
        axis_source: Enum<AxisSource>,
    },

    /// axis stop event
    ///
    /// Stop notification for scroll and other axes.
    /// 
    /// For some wl_pointer.axis_source types, a wl_pointer.axis_stop event
    /// is sent to notify a client that the axis sequence has terminated.
    /// This enables the client to implement kinetic scrolling.
    /// See the wl_pointer.axis_source documentation for information on when
    /// this event may be generated.
    /// 
    /// Any wl_pointer.axis events with the same axis_source after this
    /// event should be considered as the start of a new axis motion.
    /// 
    /// The timestamp is to be interpreted identical to the timestamp in the
    /// wl_pointer.axis event. The timestamp value may be the same as a
    /// preceding wl_pointer.axis event.
    AxisStop {
        /// timestamp with millisecond granularity
        time: u32,
        /// the axis stopped with this event
        axis: Enum<Axis>,
    },

    /// axis click event
    ///
    /// Discrete step information for scroll and other axes.
    /// 
    /// This event carries the axis value of the wl_pointer.axis event in
    /// discrete steps (e.g. mouse wheel clicks).
    /// 
    /// This event does not occur on its own, it is coupled with a
    /// wl_pointer.axis event that represents this axis value on a
    /// continuous scale. The protocol guarantees that each axis_discrete
    /// event is always followed by exactly one axis event with the same
    /// axis number within the same wl_pointer.frame. Note that the protocol
    /// allows for other events to occur between the axis_discrete and
    /// its coupled axis event, including other axis_discrete or axis
    /// events.
    /// 
    /// This event is optional; continuous scrolling devices
    /// like two-finger scrolling on touchpads do not have discrete
    /// steps and do not generate this event.
    /// 
    /// The discrete value carries the directional information. e.g. a value
    /// of -2 is two steps towards the negative direction of this axis.
    /// 
    /// The axis number is identical to the axis number in the associated
    /// axis event.
    /// 
    /// The order of wl_pointer.axis_discrete and wl_pointer.axis_source is
    /// not guaranteed.
    AxisDiscrete {
        /// axis type
        axis: Enum<Axis>,
        /// number of steps
        discrete: i32,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Enter {
                ref serial,
                ref surface,
                ref surface_x,
                ref surface_y,
            } => {
                format!("wl_pointer@{:?}::enter(serial: {:?}, surface: {:?}, surface_x: {:?}, surface_y: {:?})", this, serial, surface, surface_x, surface_y)
            }
            Event::Leave {
                ref serial,
                ref surface,
            } => {
                format!("wl_pointer@{:?}::leave(serial: {:?}, surface: {:?})", this, serial, surface)
            }
            Event::Motion {
                ref time,
                ref surface_x,
                ref surface_y,
            } => {
                format!("wl_pointer@{:?}::motion(time: {:?}, surface_x: {:?}, surface_y: {:?})", this, time, surface_x, surface_y)
            }
            Event::Button {
                ref serial,
                ref time,
                ref button,
                ref state,
            } => {
                format!("wl_pointer@{:?}::button(serial: {:?}, time: {:?}, button: {:?}, state: {:?})", this, serial, time, button, state)
            }
            Event::Axis {
                ref time,
                ref axis,
                ref value,
            } => {
                format!("wl_pointer@{:?}::axis(time: {:?}, axis: {:?}, value: {:?})", this, time, axis, value)
            }
            Event::Frame {
            } => {
                format!("wl_pointer@{:?}::frame()", this)
            }
            Event::AxisSource {
                ref axis_source,
            } => {
                format!("wl_pointer@{:?}::axis_source(axis_source: {:?})", this, axis_source)
            }
            Event::AxisStop {
                ref time,
                ref axis,
            } => {
                format!("wl_pointer@{:?}::axis_stop(time: {:?}, axis: {:?})", this, time, axis)
            }
            Event::AxisDiscrete {
                ref axis,
                ref discrete,
            } => {
                format!("wl_pointer@{:?}::axis_discrete(axis: {:?}, discrete: {:?})", this, axis, discrete)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Enter { .. } => c"wl_pointer::enter",
            Event::Leave { .. } => c"wl_pointer::leave",
            Event::Motion { .. } => c"wl_pointer::motion",
            Event::Button { .. } => c"wl_pointer::button",
            Event::Axis { .. } => c"wl_pointer::axis",
            Event::Frame { .. } => c"wl_pointer::frame",
            Event::AxisSource { .. } => c"wl_pointer::axis_source",
            Event::AxisStop { .. } => c"wl_pointer::axis_stop",
            Event::AxisDiscrete { .. } => c"wl_pointer::axis_discrete",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::SetCursor {
            serial,
            surface,
            hotspot_x,
            hotspot_y,
        } => {
            msg.write_arg(Arg::Uint(serial))?;
            msg.write_arg(Arg::Object(surface))?;
            msg.write_arg(Arg::Int(hotspot_x))?;
            msg.write_arg(Arg::Int(hotspot_y))?;
            header.opcode = 0;
        },
        Request::Release {
        } => {
            header.opcode = 1;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* enter */ => {
            let mut iter = args.into_iter();
            Ok(Event::Enter {
                serial: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                surface: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_object()?,
                surface_x: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),
                surface_y: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),

            })
        },
        1 /* leave */ => {
            let mut iter = args.into_iter();
            Ok(Event::Leave {
                serial: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                surface: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_object()?,

            })
        },
        2 /* motion */ => {
            let mut iter = args.into_iter();
            Ok(Event::Motion {
                time: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                surface_x: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),
                surface_y: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),

            })
        },
        3 /* button */ => {
            let mut iter = args.into_iter();
            Ok(Event::Button {
                serial: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                time: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                button: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                state: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match ButtonState::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,

            })
        },
        4 /* axis */ => {
            let mut iter = args.into_iter();
            Ok(Event::Axis {
                time: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                axis: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match Axis::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,
                value: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),

            })
        },
        5 /* frame */ => {
            let mut iter = args.into_iter();
            Ok(Event::Frame {

            })
        },
        6 /* axis_source */ => {
            let mut iter = args.into_iter();
            Ok(Event::AxisSource {
                axis_source: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match AxisSource::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,

            })
        },
        7 /* axis_stop */ => {
            let mut iter = args.into_iter();
            Ok(Event::AxisStop {
                time: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                axis: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match Axis::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,

            })
        },
        8 /* axis_discrete */ => {
            let mut iter = args.into_iter();
            Ok(Event::AxisDiscrete {
                axis: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match Axis::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,
                discrete: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Error {
    /// given wl_surface has another role,
    Role = 0,
}

impl Error {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Error::Role),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Error {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}

/// physical button state
///
/// Describes the physical state of a button that produced the button
/// event.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum ButtonState {
    /// the button is not pressed,
    Released = 0,
    /// the button is pressed,
    Pressed = 1,
}

impl ButtonState {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(ButtonState::Released),
        1 => Some(ButtonState::Pressed),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for ButtonState {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}

/// axis types
///
/// Describes the axis types of scroll events.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Axis {
    /// vertical axis,
    VerticalScroll = 0,
    /// horizontal axis,
    HorizontalScroll = 1,
}

impl Axis {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Axis::VerticalScroll),
        1 => Some(Axis::HorizontalScroll),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Axis {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}

/// axis source types
///
/// Describes the source types for axis events. This indicates to the
/// client how an axis event was physically generated; a client may
/// adjust the user interface accordingly. For example, scroll events
/// from a "finger" source may be in a smooth coordinate space with
/// kinetic scrolling whereas a "wheel" source may be in discrete steps
/// of a number of lines.
/// 
/// The "continuous" axis source is a device generating events in a
/// continuous coordinate space, but using something other than a
/// finger. One example for this source is button-based scrolling where
/// the vertical motion of a device is converted to scroll events while
/// a button is held down.
/// 
/// The "wheel tilt" axis source indicates that the actual device is a
/// wheel but the scroll event is not caused by a rotation but a
/// (usually sideways) tilt of the wheel.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum AxisSource {
    /// a physical wheel rotation,
    Wheel = 0,
    /// finger on a touch surface,
    Finger = 1,
    /// continuous coordinate space,
    Continuous = 2,
    /// a physical wheel tilt,
    WheelTilt = 3,
}

impl AxisSource {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(AxisSource::Wheel),
        1 => Some(AxisSource::Finger),
        2 => Some(AxisSource::Continuous),
        3 => Some(AxisSource::WheelTilt),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for AxisSource {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_pointer

pub use crate::wl_pointer::WlPointer;
pub use crate::wl_pointer::Request as WlPointerRequest;
pub use crate::wl_pointer::Event as WlPointerEvent;
pub mod wl_keyboard {
use super::*;

/// keyboard input device
///
/// The wl_keyboard interface represents one or more keyboards
/// associated with a seat.
#[derive(Debug)]
pub struct WlKeyboard;

impl Interface for WlKeyboard {
    const NAME: &'static str = "wl_keyboard";
    const VERSION: u32 = 7;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // release
        MessageSpec(&[
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // keymap
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Handle,
            ArgKind::Uint,
        ]),
        // enter
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Object,
            ArgKind::Array,
        ]),
        // leave
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Object,
        ]),
        // key
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Uint,
            ArgKind::Uint,
            ArgKind::Uint,
        ]),
        // modifiers
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Uint,
            ArgKind::Uint,
            ArgKind::Uint,
            ArgKind::Uint,
        ]),
        // repeat_info
        MessageSpec(&[
            ArgKind::Int,
            ArgKind::Int,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// release the keyboard object
    ///
    Release,
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::Release {
            } => {
                format!("wl_keyboard@{:?}::release()", this)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::Release { .. } => c"wl_keyboard::release",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// keyboard mapping
    ///
    /// This event provides a file descriptor to the client which can be
    /// memory-mapped to provide a keyboard mapping description.
    /// 
    /// From version 7 onwards, the fd must be mapped with MAP_PRIVATE by
    /// the recipient, as MAP_SHARED may fail.
    Keymap {
        /// keymap format
        format: Enum<KeymapFormat>,
        /// keymap file descriptor
        fd: zx::Handle,
        /// keymap size, in bytes
        size: u32,
    },

    /// enter event
    ///
    /// Notification that this seat's keyboard focus is on a certain
    /// surface.
    /// 
    /// The compositor must send the wl_keyboard.modifiers event after this
    /// event.
    Enter {
        /// serial number of the enter event
        serial: u32,
        /// surface gaining keyboard focus
        surface: ObjectId,
        /// the currently pressed keys
        keys: Array,
    },

    /// leave event
    ///
    /// Notification that this seat's keyboard focus is no longer on
    /// a certain surface.
    /// 
    /// The leave notification is sent before the enter notification
    /// for the new focus.
    /// 
    /// After this event client must assume that all keys, including modifiers,
    /// are lifted and also it must stop key repeating if there's some going on.
    Leave {
        /// serial number of the leave event
        serial: u32,
        /// surface that lost keyboard focus
        surface: ObjectId,
    },

    /// key event
    ///
    /// A key was pressed or released.
    /// The time argument is a timestamp with millisecond
    /// granularity, with an undefined base.
    /// 
    /// The key is a platform-specific key code that can be interpreted
    /// by feeding it to the keyboard mapping (see the keymap event).
    /// 
    /// If this event produces a change in modifiers, then the resulting
    /// wl_keyboard.modifiers event must be sent after this event.
    Key {
        /// serial number of the key event
        serial: u32,
        /// timestamp with millisecond granularity
        time: u32,
        /// key that produced the event
        key: u32,
        /// physical state of the key
        state: Enum<KeyState>,
    },

    /// modifier and group state
    ///
    /// Notifies clients that the modifier and/or group state has
    /// changed, and it should update its local state.
    Modifiers {
        /// serial number of the modifiers event
        serial: u32,
        /// depressed modifiers
        mods_depressed: u32,
        /// latched modifiers
        mods_latched: u32,
        /// locked modifiers
        mods_locked: u32,
        /// keyboard layout
        group: u32,
    },

    /// repeat rate and delay
    ///
    /// Informs the client about the keyboard's repeat rate and delay.
    /// 
    /// This event is sent as soon as the wl_keyboard object has been created,
    /// and is guaranteed to be received by the client before any key press
    /// event.
    /// 
    /// Negative values for either rate or delay are illegal. A rate of zero
    /// will disable any repeating (regardless of the value of delay).
    /// 
    /// This event can be sent later on as well with a new value if necessary,
    /// so clients should continue listening for the event past the creation
    /// of wl_keyboard.
    RepeatInfo {
        /// the rate of repeating keys in characters per second
        rate: i32,
        /// delay in milliseconds since key down until repeating starts
        delay: i32,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Keymap {
                ref format,
                ref fd,
                ref size,
            } => {
                format!("wl_keyboard@{:?}::keymap(format: {:?}, fd: <handle>, size: {:?})", this, format, size)
            }
            Event::Enter {
                ref serial,
                ref surface,
                ref keys,
            } => {
                format!("wl_keyboard@{:?}::enter(serial: {:?}, surface: {:?}, keys: Array[{}])", this, serial, surface, keys.len())
            }
            Event::Leave {
                ref serial,
                ref surface,
            } => {
                format!("wl_keyboard@{:?}::leave(serial: {:?}, surface: {:?})", this, serial, surface)
            }
            Event::Key {
                ref serial,
                ref time,
                ref key,
                ref state,
            } => {
                format!("wl_keyboard@{:?}::key(serial: {:?}, time: {:?}, key: {:?}, state: {:?})", this, serial, time, key, state)
            }
            Event::Modifiers {
                ref serial,
                ref mods_depressed,
                ref mods_latched,
                ref mods_locked,
                ref group,
            } => {
                format!("wl_keyboard@{:?}::modifiers(serial: {:?}, mods_depressed: {:?}, mods_latched: {:?}, mods_locked: {:?}, group: {:?})", this, serial, mods_depressed, mods_latched, mods_locked, group)
            }
            Event::RepeatInfo {
                ref rate,
                ref delay,
            } => {
                format!("wl_keyboard@{:?}::repeat_info(rate: {:?}, delay: {:?})", this, rate, delay)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Keymap { .. } => c"wl_keyboard::keymap",
            Event::Enter { .. } => c"wl_keyboard::enter",
            Event::Leave { .. } => c"wl_keyboard::leave",
            Event::Key { .. } => c"wl_keyboard::key",
            Event::Modifiers { .. } => c"wl_keyboard::modifiers",
            Event::RepeatInfo { .. } => c"wl_keyboard::repeat_info",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::Release {
        } => {
            header.opcode = 0;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* keymap */ => {
            let mut iter = args.into_iter();
            Ok(Event::Keymap {
                format: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match KeymapFormat::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,
                fd: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_handle()?,
                size: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,

            })
        },
        1 /* enter */ => {
            let mut iter = args.into_iter();
            Ok(Event::Enter {
                serial: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                surface: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_object()?,
                keys: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_array()?,

            })
        },
        2 /* leave */ => {
            let mut iter = args.into_iter();
            Ok(Event::Leave {
                serial: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                surface: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_object()?,

            })
        },
        3 /* key */ => {
            let mut iter = args.into_iter();
            Ok(Event::Key {
                serial: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                time: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                key: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                state: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match KeyState::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,

            })
        },
        4 /* modifiers */ => {
            let mut iter = args.into_iter();
            Ok(Event::Modifiers {
                serial: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                mods_depressed: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                mods_latched: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                mods_locked: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                group: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,

            })
        },
        5 /* repeat_info */ => {
            let mut iter = args.into_iter();
            Ok(Event::RepeatInfo {
                rate: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,
                delay: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}

/// keyboard mapping format
///
/// This specifies the format of the keymap provided to the
/// client with the wl_keyboard.keymap event.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum KeymapFormat {
    /// no keymap; client must understand how to interpret the raw keycode,
    NoKeymap = 0,
    /// libxkbcommon compatible; to determine the xkb keycode, clients must add 8 to the key event keycode,
    XkbV1 = 1,
}

impl KeymapFormat {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(KeymapFormat::NoKeymap),
        1 => Some(KeymapFormat::XkbV1),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for KeymapFormat {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}

/// physical key state
///
/// Describes the physical state of a key that produced the key event.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum KeyState {
    /// key is not pressed,
    Released = 0,
    /// key is pressed,
    Pressed = 1,
}

impl KeyState {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(KeyState::Released),
        1 => Some(KeyState::Pressed),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for KeyState {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_keyboard

pub use crate::wl_keyboard::WlKeyboard;
pub use crate::wl_keyboard::Request as WlKeyboardRequest;
pub use crate::wl_keyboard::Event as WlKeyboardEvent;
pub mod wl_touch {
use super::*;

/// touchscreen input device
///
/// The wl_touch interface represents a touchscreen
/// associated with a seat.
/// 
/// Touch interactions can consist of one or more contacts.
/// For each contact, a series of events is generated, starting
/// with a down event, followed by zero or more motion events,
/// and ending with an up event. Events relating to the same
/// contact point can be identified by the ID of the sequence.
#[derive(Debug)]
pub struct WlTouch;

impl Interface for WlTouch {
    const NAME: &'static str = "wl_touch";
    const VERSION: u32 = 7;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // release
        MessageSpec(&[
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // down
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Uint,
            ArgKind::Object,
            ArgKind::Int,
            ArgKind::Fixed,
            ArgKind::Fixed,
        ]),
        // up
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Uint,
            ArgKind::Int,
        ]),
        // motion
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Int,
            ArgKind::Fixed,
            ArgKind::Fixed,
        ]),
        // frame
        MessageSpec(&[
        ]),
        // cancel
        MessageSpec(&[
        ]),
        // shape
        MessageSpec(&[
            ArgKind::Int,
            ArgKind::Fixed,
            ArgKind::Fixed,
        ]),
        // orientation
        MessageSpec(&[
            ArgKind::Int,
            ArgKind::Fixed,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// release the touch object
    ///
    Release,
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::Release {
            } => {
                format!("wl_touch@{:?}::release()", this)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::Release { .. } => c"wl_touch::release",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// touch down event and beginning of a touch sequence
    ///
    /// A new touch point has appeared on the surface. This touch point is
    /// assigned a unique ID. Future events from this touch point reference
    /// this ID. The ID ceases to be valid after a touch up event and may be
    /// reused in the future.
    Down {
        /// serial number of the touch down event
        serial: u32,
        /// timestamp with millisecond granularity
        time: u32,
        /// surface touched
        surface: ObjectId,
        /// the unique ID of this touch point
        id: i32,
        /// surface-local x coordinate
        x: Fixed,
        /// surface-local y coordinate
        y: Fixed,
    },

    /// end of a touch event sequence
    ///
    /// The touch point has disappeared. No further events will be sent for
    /// this touch point and the touch point's ID is released and may be
    /// reused in a future touch down event.
    Up {
        /// serial number of the touch up event
        serial: u32,
        /// timestamp with millisecond granularity
        time: u32,
        /// the unique ID of this touch point
        id: i32,
    },

    /// update of touch point coordinates
    ///
    /// A touch point has changed coordinates.
    Motion {
        /// timestamp with millisecond granularity
        time: u32,
        /// the unique ID of this touch point
        id: i32,
        /// surface-local x coordinate
        x: Fixed,
        /// surface-local y coordinate
        y: Fixed,
    },

    /// end of touch frame event
    ///
    /// Indicates the end of a set of events that logically belong together.
    /// A client is expected to accumulate the data in all events within the
    /// frame before proceeding.
    /// 
    /// A wl_touch.frame terminates at least one event but otherwise no
    /// guarantee is provided about the set of events within a frame. A client
    /// must assume that any state not updated in a frame is unchanged from the
    /// previously known state.
    Frame,

    /// touch session cancelled
    ///
    /// Sent if the compositor decides the touch stream is a global
    /// gesture. No further events are sent to the clients from that
    /// particular gesture. Touch cancellation applies to all touch points
    /// currently active on this client's surface. The client is
    /// responsible for finalizing the touch points, future touch points on
    /// this surface may reuse the touch point ID.
    Cancel,

    /// update shape of touch point
    ///
    /// Sent when a touchpoint has changed its shape.
    /// 
    /// This event does not occur on its own. It is sent before a
    /// wl_touch.frame event and carries the new shape information for
    /// any previously reported, or new touch points of that frame.
    /// 
    /// Other events describing the touch point such as wl_touch.down,
    /// wl_touch.motion or wl_touch.orientation may be sent within the
    /// same wl_touch.frame. A client should treat these events as a single
    /// logical touch point update. The order of wl_touch.shape,
    /// wl_touch.orientation and wl_touch.motion is not guaranteed.
    /// A wl_touch.down event is guaranteed to occur before the first
    /// wl_touch.shape event for this touch ID but both events may occur within
    /// the same wl_touch.frame.
    /// 
    /// A touchpoint shape is approximated by an ellipse through the major and
    /// minor axis length. The major axis length describes the longer diameter
    /// of the ellipse, while the minor axis length describes the shorter
    /// diameter. Major and minor are orthogonal and both are specified in
    /// surface-local coordinates. The center of the ellipse is always at the
    /// touchpoint location as reported by wl_touch.down or wl_touch.move.
    /// 
    /// This event is only sent by the compositor if the touch device supports
    /// shape reports. The client has to make reasonable assumptions about the
    /// shape if it did not receive this event.
    Shape {
        /// the unique ID of this touch point
        id: i32,
        /// length of the major axis in surface-local coordinates
        major: Fixed,
        /// length of the minor axis in surface-local coordinates
        minor: Fixed,
    },

    /// update orientation of touch point
    ///
    /// Sent when a touchpoint has changed its orientation.
    /// 
    /// This event does not occur on its own. It is sent before a
    /// wl_touch.frame event and carries the new shape information for
    /// any previously reported, or new touch points of that frame.
    /// 
    /// Other events describing the touch point such as wl_touch.down,
    /// wl_touch.motion or wl_touch.shape may be sent within the
    /// same wl_touch.frame. A client should treat these events as a single
    /// logical touch point update. The order of wl_touch.shape,
    /// wl_touch.orientation and wl_touch.motion is not guaranteed.
    /// A wl_touch.down event is guaranteed to occur before the first
    /// wl_touch.orientation event for this touch ID but both events may occur
    /// within the same wl_touch.frame.
    /// 
    /// The orientation describes the clockwise angle of a touchpoint's major
    /// axis to the positive surface y-axis and is normalized to the -180 to
    /// +180 degree range. The granularity of orientation depends on the touch
    /// device, some devices only support binary rotation values between 0 and
    /// 90 degrees.
    /// 
    /// This event is only sent by the compositor if the touch device supports
    /// orientation reports.
    Orientation {
        /// the unique ID of this touch point
        id: i32,
        /// angle between major axis and positive surface y-axis in degrees
        orientation: Fixed,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Down {
                ref serial,
                ref time,
                ref surface,
                ref id,
                ref x,
                ref y,
            } => {
                format!("wl_touch@{:?}::down(serial: {:?}, time: {:?}, surface: {:?}, id: {:?}, x: {:?}, y: {:?})", this, serial, time, surface, id, x, y)
            }
            Event::Up {
                ref serial,
                ref time,
                ref id,
            } => {
                format!("wl_touch@{:?}::up(serial: {:?}, time: {:?}, id: {:?})", this, serial, time, id)
            }
            Event::Motion {
                ref time,
                ref id,
                ref x,
                ref y,
            } => {
                format!("wl_touch@{:?}::motion(time: {:?}, id: {:?}, x: {:?}, y: {:?})", this, time, id, x, y)
            }
            Event::Frame {
            } => {
                format!("wl_touch@{:?}::frame()", this)
            }
            Event::Cancel {
            } => {
                format!("wl_touch@{:?}::cancel()", this)
            }
            Event::Shape {
                ref id,
                ref major,
                ref minor,
            } => {
                format!("wl_touch@{:?}::shape(id: {:?}, major: {:?}, minor: {:?})", this, id, major, minor)
            }
            Event::Orientation {
                ref id,
                ref orientation,
            } => {
                format!("wl_touch@{:?}::orientation(id: {:?}, orientation: {:?})", this, id, orientation)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Down { .. } => c"wl_touch::down",
            Event::Up { .. } => c"wl_touch::up",
            Event::Motion { .. } => c"wl_touch::motion",
            Event::Frame { .. } => c"wl_touch::frame",
            Event::Cancel { .. } => c"wl_touch::cancel",
            Event::Shape { .. } => c"wl_touch::shape",
            Event::Orientation { .. } => c"wl_touch::orientation",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::Release {
        } => {
            header.opcode = 0;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* down */ => {
            let mut iter = args.into_iter();
            Ok(Event::Down {
                serial: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                time: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                surface: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_object()?,
                id: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,
                x: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),
                y: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),

            })
        },
        1 /* up */ => {
            let mut iter = args.into_iter();
            Ok(Event::Up {
                serial: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                time: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                id: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,

            })
        },
        2 /* motion */ => {
            let mut iter = args.into_iter();
            Ok(Event::Motion {
                time: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,
                id: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,
                x: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),
                y: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),

            })
        },
        3 /* frame */ => {
            let mut iter = args.into_iter();
            Ok(Event::Frame {

            })
        },
        4 /* cancel */ => {
            let mut iter = args.into_iter();
            Ok(Event::Cancel {

            })
        },
        5 /* shape */ => {
            let mut iter = args.into_iter();
            Ok(Event::Shape {
                id: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,
                major: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),
                minor: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),

            })
        },
        6 /* orientation */ => {
            let mut iter = args.into_iter();
            Ok(Event::Orientation {
                id: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,
                orientation: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
} // mod wl_touch

pub use crate::wl_touch::WlTouch;
pub use crate::wl_touch::Request as WlTouchRequest;
pub use crate::wl_touch::Event as WlTouchEvent;
pub mod wl_output {
use super::*;

/// compositor output region
///
/// An output describes part of the compositor geometry.  The
/// compositor works in the 'compositor coordinate system' and an
/// output corresponds to a rectangular area in that space that is
/// actually visible.  This typically corresponds to a monitor that
/// displays part of the compositor space.  This object is published
/// as global during start up, or when a monitor is hotplugged.
#[derive(Debug)]
pub struct WlOutput;

impl Interface for WlOutput {
    const NAME: &'static str = "wl_output";
    const VERSION: u32 = 3;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // release
        MessageSpec(&[
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // geometry
        MessageSpec(&[
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Uint,
            ArgKind::String,
            ArgKind::String,
            ArgKind::Uint,
        ]),
        // mode
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Int,
        ]),
        // done
        MessageSpec(&[
        ]),
        // scale
        MessageSpec(&[
            ArgKind::Int,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// release the output object
    ///
    /// Using this request a client can tell the server that it is not going to
    /// use the output object anymore.
    Release,
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::Release {
            } => {
                format!("wl_output@{:?}::release()", this)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::Release { .. } => c"wl_output::release",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// properties of the output
    ///
    /// The geometry event describes geometric properties of the output.
    /// The event is sent when binding to the output object and whenever
    /// any of the properties change.
    /// 
    /// The physical size can be set to zero if it doesn't make sense for this
    /// output (e.g. for projectors or virtual outputs).
    /// 
    /// Note: wl_output only advertises partial information about the output
    /// position and identification. Some compositors, for instance those not
    /// implementing a desktop-style output layout or those exposing virtual
    /// outputs, might fake this information. Instead of using x and y, clients
    /// should use xdg_output.logical_position. Instead of using make and model,
    /// clients should use xdg_output.name and xdg_output.description.
    Geometry {
        /// x position within the global compositor space
        x: i32,
        /// y position within the global compositor space
        y: i32,
        /// width in millimeters of the output
        physical_width: i32,
        /// height in millimeters of the output
        physical_height: i32,
        /// subpixel orientation of the output
        subpixel: Enum<Subpixel>,
        /// textual description of the manufacturer
        make: String,
        /// textual description of the model
        model: String,
        /// transform that maps framebuffer to output
        transform: Enum<Transform>,
    },

    /// advertise available modes for the output
    ///
    /// The mode event describes an available mode for the output.
    /// 
    /// The event is sent when binding to the output object and there
    /// will always be one mode, the current mode.  The event is sent
    /// again if an output changes mode, for the mode that is now
    /// current.  In other words, the current mode is always the last
    /// mode that was received with the current flag set.
    /// 
    /// The size of a mode is given in physical hardware units of
    /// the output device. This is not necessarily the same as
    /// the output size in the global compositor space. For instance,
    /// the output may be scaled, as described in wl_output.scale,
    /// or transformed, as described in wl_output.transform. Clients
    /// willing to retrieve the output size in the global compositor
    /// space should use xdg_output.logical_size instead.
    /// 
    /// The vertical refresh rate can be set to zero if it doesn't make
    /// sense for this output (e.g. for virtual outputs).
    /// 
    /// Clients should not use the refresh rate to schedule frames. Instead,
    /// they should use the wl_surface.frame event or the presentation-time
    /// protocol.
    /// 
    /// Note: this information is not always meaningful for all outputs. Some
    /// compositors, such as those exposing virtual outputs, might fake the
    /// refresh rate or the size.
    Mode {
        /// bitfield of mode flags
        flags: Enum<Mode>,
        /// width of the mode in hardware units
        width: i32,
        /// height of the mode in hardware units
        height: i32,
        /// vertical refresh rate in mHz
        refresh: i32,
    },

    /// sent all information about output
    ///
    /// This event is sent after all other properties have been
    /// sent after binding to the output object and after any
    /// other property changes done after that. This allows
    /// changes to the output properties to be seen as
    /// atomic, even if they happen via multiple events.
    Done,

    /// output scaling properties
    ///
    /// This event contains scaling geometry information
    /// that is not in the geometry event. It may be sent after
    /// binding the output object or if the output scale changes
    /// later. If it is not sent, the client should assume a
    /// scale of 1.
    /// 
    /// A scale larger than 1 means that the compositor will
    /// automatically scale surface buffers by this amount
    /// when rendering. This is used for very high resolution
    /// displays where applications rendering at the native
    /// resolution would be too small to be legible.
    /// 
    /// It is intended that scaling aware clients track the
    /// current output of a surface, and if it is on a scaled
    /// output it should use wl_surface.set_buffer_scale with
    /// the scale of the output. That way the compositor can
    /// avoid scaling the surface, and the client can supply
    /// a higher detail image.
    Scale {
        /// scaling factor of output
        factor: i32,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Geometry {
                ref x,
                ref y,
                ref physical_width,
                ref physical_height,
                ref subpixel,
                ref make,
                ref model,
                ref transform,
            } => {
                format!("wl_output@{:?}::geometry(x: {:?}, y: {:?}, physical_width: {:?}, physical_height: {:?}, subpixel: {:?}, make: {:?}, model: {:?}, transform: {:?})", this, x, y, physical_width, physical_height, subpixel, make, model, transform)
            }
            Event::Mode {
                ref flags,
                ref width,
                ref height,
                ref refresh,
            } => {
                format!("wl_output@{:?}::mode(flags: {:?}, width: {:?}, height: {:?}, refresh: {:?})", this, flags, width, height, refresh)
            }
            Event::Done {
            } => {
                format!("wl_output@{:?}::done()", this)
            }
            Event::Scale {
                ref factor,
            } => {
                format!("wl_output@{:?}::scale(factor: {:?})", this, factor)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Geometry { .. } => c"wl_output::geometry",
            Event::Mode { .. } => c"wl_output::mode",
            Event::Done { .. } => c"wl_output::done",
            Event::Scale { .. } => c"wl_output::scale",
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::Release {
        } => {
            header.opcode = 0;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        0 /* geometry */ => {
            let mut iter = args.into_iter();
            Ok(Event::Geometry {
                x: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,
                y: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,
                physical_width: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,
                physical_height: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,
                subpixel: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match Subpixel::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,
                make: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_string()?,
                model: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_string()?,
                transform: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match Transform::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,

            })
        },
        1 /* mode */ => {
            let mut iter = args.into_iter();
            Ok(Event::Mode {
                flags: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match Mode::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,
                width: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,
                height: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,
                refresh: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,

            })
        },
        2 /* done */ => {
            let mut iter = args.into_iter();
            Ok(Event::Done {

            })
        },
        3 /* scale */ => {
            let mut iter = args.into_iter();
            Ok(Event::Scale {
                factor: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_int()?,

            })
        },
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}

/// subpixel geometry information
///
/// This enumeration describes how the physical
/// pixels on an output are laid out.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Subpixel {
    /// unknown geometry,
    Unknown = 0,
    /// no geometry,
    None = 1,
    /// horizontal RGB,
    HorizontalRgb = 2,
    /// horizontal BGR,
    HorizontalBgr = 3,
    /// vertical RGB,
    VerticalRgb = 4,
    /// vertical BGR,
    VerticalBgr = 5,
}

impl Subpixel {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Subpixel::Unknown),
        1 => Some(Subpixel::None),
        2 => Some(Subpixel::HorizontalRgb),
        3 => Some(Subpixel::HorizontalBgr),
        4 => Some(Subpixel::VerticalRgb),
        5 => Some(Subpixel::VerticalBgr),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Subpixel {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}

/// transform from framebuffer to output
///
/// This describes the transform that a compositor will apply to a
/// surface to compensate for the rotation or mirroring of an
/// output device.
/// 
/// The flipped values correspond to an initial flip around a
/// vertical axis followed by rotation.
/// 
/// The purpose is mainly to allow clients to render accordingly and
/// tell the compositor, so that for fullscreen surfaces, the
/// compositor will still be able to scan out directly from client
/// surfaces.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Transform {
    /// no transform,
    Normal = 0,
    /// 90 degrees counter-clockwise,
    _90 = 1,
    /// 180 degrees counter-clockwise,
    _180 = 2,
    /// 270 degrees counter-clockwise,
    _270 = 3,
    /// 180 degree flip around a vertical axis,
    Flipped = 4,
    /// flip and rotate 90 degrees counter-clockwise,
    Flipped90 = 5,
    /// flip and rotate 180 degrees counter-clockwise,
    Flipped180 = 6,
    /// flip and rotate 270 degrees counter-clockwise,
    Flipped270 = 7,
}

impl Transform {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Transform::Normal),
        1 => Some(Transform::_90),
        2 => Some(Transform::_180),
        3 => Some(Transform::_270),
        4 => Some(Transform::Flipped),
        5 => Some(Transform::Flipped90),
        6 => Some(Transform::Flipped180),
        7 => Some(Transform::Flipped270),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Transform {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
::bitflags::bitflags! {

    /// mode information
    ///
    /// These flags describe properties of an output mode.
    /// They are used in the flags bitfield of the mode event.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Mode: u32 {
        /// indicates this is the current mode,
        const Current = 1;
        /// indicates this is the preferred mode,
        const Preferred = 2;
    }
}
impl Into<Arg> for Mode {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_output

pub use crate::wl_output::WlOutput;
pub use crate::wl_output::Request as WlOutputRequest;
pub use crate::wl_output::Event as WlOutputEvent;
pub mod wl_region {
use super::*;

/// region interface
///
/// A region object describes an area.
/// 
/// Region objects are used to describe the opaque and input
/// regions of a surface.
#[derive(Debug)]
pub struct WlRegion;

impl Interface for WlRegion {
    const NAME: &'static str = "wl_region";
    const VERSION: u32 = 1;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // destroy
        MessageSpec(&[
        ]),
        // add
        MessageSpec(&[
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Int,
        ]),
        // subtract
        MessageSpec(&[
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Int,
            ArgKind::Int,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// destroy region
    ///
    /// Destroy the region.  This will invalidate the object ID.
    Destroy,

    /// add rectangle to region
    ///
    /// Add the specified rectangle to the region.
    Add {
        /// region-local x coordinate
        x: i32,
        /// region-local y coordinate
        y: i32,
        /// rectangle width
        width: i32,
        /// rectangle height
        height: i32,
    },

    /// subtract rectangle from region
    ///
    /// Subtract the specified rectangle from the region.
    Subtract {
        /// region-local x coordinate
        x: i32,
        /// region-local y coordinate
        y: i32,
        /// rectangle width
        width: i32,
        /// rectangle height
        height: i32,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::Destroy {
            } => {
                format!("wl_region@{:?}::destroy()", this)
            }
            Request::Add {
                ref x,
                ref y,
                ref width,
                ref height,
            } => {
                format!("wl_region@{:?}::add(x: {:?}, y: {:?}, width: {:?}, height: {:?})", this, x, y, width, height)
            }
            Request::Subtract {
                ref x,
                ref y,
                ref width,
                ref height,
            } => {
                format!("wl_region@{:?}::subtract(x: {:?}, y: {:?}, width: {:?}, height: {:?})", this, x, y, width, height)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::Destroy { .. } => c"wl_region::destroy",
            Request::Add { .. } => c"wl_region::add",
            Request::Subtract { .. } => c"wl_region::subtract",
        }
    }
}
#[derive(Debug)]
pub enum Event {
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::Destroy {
        } => {
            header.opcode = 0;
        },
        Request::Add {
            x,
            y,
            width,
            height,
        } => {
            msg.write_arg(Arg::Int(x))?;
            msg.write_arg(Arg::Int(y))?;
            msg.write_arg(Arg::Int(width))?;
            msg.write_arg(Arg::Int(height))?;
            header.opcode = 1;
        },
        Request::Subtract {
            x,
            y,
            width,
            height,
        } => {
            msg.write_arg(Arg::Int(x))?;
            msg.write_arg(Arg::Int(y))?;
            msg.write_arg(Arg::Int(width))?;
            msg.write_arg(Arg::Int(height))?;
            header.opcode = 2;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
} // mod wl_region

pub use crate::wl_region::WlRegion;
pub use crate::wl_region::Request as WlRegionRequest;
pub use crate::wl_region::Event as WlRegionEvent;
pub mod wl_subcompositor {
use super::*;

/// sub-surface compositing
///
/// The global interface exposing sub-surface compositing capabilities.
/// A wl_surface, that has sub-surfaces associated, is called the
/// parent surface. Sub-surfaces can be arbitrarily nested and create
/// a tree of sub-surfaces.
/// 
/// The root surface in a tree of sub-surfaces is the main
/// surface. The main surface cannot be a sub-surface, because
/// sub-surfaces must always have a parent.
/// 
/// A main surface with its sub-surfaces forms a (compound) window.
/// For window management purposes, this set of wl_surface objects is
/// to be considered as a single window, and it should also behave as
/// such.
/// 
/// The aim of sub-surfaces is to offload some of the compositing work
/// within a window from clients to the compositor. A prime example is
/// a video player with decorations and video in separate wl_surface
/// objects. This should allow the compositor to pass YUV video buffer
/// processing to dedicated overlay hardware when possible.
#[derive(Debug)]
pub struct WlSubcompositor;

impl Interface for WlSubcompositor {
    const NAME: &'static str = "wl_subcompositor";
    const VERSION: u32 = 1;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // destroy
        MessageSpec(&[
        ]),
        // get_subsurface
        MessageSpec(&[
            ArgKind::NewId,
            ArgKind::Object,
            ArgKind::Object,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// unbind from the subcompositor interface
    ///
    /// Informs the server that the client will not be using this
    /// protocol object anymore. This does not affect any other
    /// objects, wl_subsurface objects included.
    Destroy,

    /// give a surface the role sub-surface
    ///
    /// Create a sub-surface interface for the given surface, and
    /// associate it with the given parent surface. This turns a
    /// plain wl_surface into a sub-surface.
    /// 
    /// The to-be sub-surface must not already have another role, and it
    /// must not have an existing wl_subsurface object. Otherwise a protocol
    /// error is raised.
    /// 
    /// Adding sub-surfaces to a parent is a double-buffered operation on the
    /// parent (see wl_surface.commit). The effect of adding a sub-surface
    /// becomes visible on the next time the state of the parent surface is
    /// applied.
    /// 
    /// This request modifies the behaviour of wl_surface.commit request on
    /// the sub-surface, see the documentation on wl_subsurface interface.
    GetSubsurface {
        /// the new sub-surface object ID
        id: NewId,
        /// the surface to be turned into a sub-surface
        surface: ObjectId,
        /// the parent surface
        parent: ObjectId,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::Destroy {
            } => {
                format!("wl_subcompositor@{:?}::destroy()", this)
            }
            Request::GetSubsurface {
                ref id,
                ref surface,
                ref parent,
            } => {
                format!("wl_subcompositor@{:?}::get_subsurface(id: {:?}, surface: {:?}, parent: {:?})", this, id, surface, parent)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::Destroy { .. } => c"wl_subcompositor::destroy",
            Request::GetSubsurface { .. } => c"wl_subcompositor::get_subsurface",
        }
    }
}
#[derive(Debug)]
pub enum Event {
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::Destroy {
        } => {
            header.opcode = 0;
        },
        Request::GetSubsurface {
            id,
            surface,
            parent,
        } => {
            msg.write_arg(Arg::NewId(id))?;
            msg.write_arg(Arg::Object(surface))?;
            msg.write_arg(Arg::Object(parent))?;
            header.opcode = 1;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Error {
    /// the to-be sub-surface is invalid,
    BadSurface = 0,
}

impl Error {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Error::BadSurface),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Error {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_subcompositor

pub use crate::wl_subcompositor::WlSubcompositor;
pub use crate::wl_subcompositor::Request as WlSubcompositorRequest;
pub use crate::wl_subcompositor::Event as WlSubcompositorEvent;
pub mod wl_subsurface {
use super::*;

/// sub-surface interface to a wl_surface
///
/// An additional interface to a wl_surface object, which has been
/// made a sub-surface. A sub-surface has one parent surface. A
/// sub-surface's size and position are not limited to that of the parent.
/// Particularly, a sub-surface is not automatically clipped to its
/// parent's area.
/// 
/// A sub-surface becomes mapped, when a non-NULL wl_buffer is applied
/// and the parent surface is mapped. The order of which one happens
/// first is irrelevant. A sub-surface is hidden if the parent becomes
/// hidden, or if a NULL wl_buffer is applied. These rules apply
/// recursively through the tree of surfaces.
/// 
/// The behaviour of a wl_surface.commit request on a sub-surface
/// depends on the sub-surface's mode. The possible modes are
/// synchronized and desynchronized, see methods
/// wl_subsurface.set_sync and wl_subsurface.set_desync. Synchronized
/// mode caches the wl_surface state to be applied when the parent's
/// state gets applied, and desynchronized mode applies the pending
/// wl_surface state directly. A sub-surface is initially in the
/// synchronized mode.
/// 
/// Sub-surfaces also have another kind of state, which is managed by
/// wl_subsurface requests, as opposed to wl_surface requests. This
/// state includes the sub-surface position relative to the parent
/// surface (wl_subsurface.set_position), and the stacking order of
/// the parent and its sub-surfaces (wl_subsurface.place_above and
/// .place_below). This state is applied when the parent surface's
/// wl_surface state is applied, regardless of the sub-surface's mode.
/// As the exception, set_sync and set_desync are effective immediately.
/// 
/// The main surface can be thought to be always in desynchronized mode,
/// since it does not have a parent in the sub-surfaces sense.
/// 
/// Even if a sub-surface is in desynchronized mode, it will behave as
/// in synchronized mode, if its parent surface behaves as in
/// synchronized mode. This rule is applied recursively throughout the
/// tree of surfaces. This means, that one can set a sub-surface into
/// synchronized mode, and then assume that all its child and grand-child
/// sub-surfaces are synchronized, too, without explicitly setting them.
/// 
/// If the wl_surface associated with the wl_subsurface is destroyed, the
/// wl_subsurface object becomes inert. Note, that destroying either object
/// takes effect immediately. If you need to synchronize the removal
/// of a sub-surface to the parent surface update, unmap the sub-surface
/// first by attaching a NULL wl_buffer, update parent, and then destroy
/// the sub-surface.
/// 
/// If the parent wl_surface object is destroyed, the sub-surface is
/// unmapped.
#[derive(Debug)]
pub struct WlSubsurface;

impl Interface for WlSubsurface {
    const NAME: &'static str = "wl_subsurface";
    const VERSION: u32 = 1;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // destroy
        MessageSpec(&[
        ]),
        // set_position
        MessageSpec(&[
            ArgKind::Int,
            ArgKind::Int,
        ]),
        // place_above
        MessageSpec(&[
            ArgKind::Object,
        ]),
        // place_below
        MessageSpec(&[
            ArgKind::Object,
        ]),
        // set_sync
        MessageSpec(&[
        ]),
        // set_desync
        MessageSpec(&[
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// remove sub-surface interface
    ///
    /// The sub-surface interface is removed from the wl_surface object
    /// that was turned into a sub-surface with a
    /// wl_subcompositor.get_subsurface request. The wl_surface's association
    /// to the parent is deleted, and the wl_surface loses its role as
    /// a sub-surface. The wl_surface is unmapped immediately.
    Destroy,

    /// reposition the sub-surface
    ///
    /// This schedules a sub-surface position change.
    /// The sub-surface will be moved so that its origin (top left
    /// corner pixel) will be at the location x, y of the parent surface
    /// coordinate system. The coordinates are not restricted to the parent
    /// surface area. Negative values are allowed.
    /// 
    /// The scheduled coordinates will take effect whenever the state of the
    /// parent surface is applied. When this happens depends on whether the
    /// parent surface is in synchronized mode or not. See
    /// wl_subsurface.set_sync and wl_subsurface.set_desync for details.
    /// 
    /// If more than one set_position request is invoked by the client before
    /// the commit of the parent surface, the position of a new request always
    /// replaces the scheduled position from any previous request.
    /// 
    /// The initial position is 0, 0.
    SetPosition {
        /// x coordinate in the parent surface
        x: i32,
        /// y coordinate in the parent surface
        y: i32,
    },

    /// restack the sub-surface
    ///
    /// This sub-surface is taken from the stack, and put back just
    /// above the reference surface, changing the z-order of the sub-surfaces.
    /// The reference surface must be one of the sibling surfaces, or the
    /// parent surface. Using any other surface, including this sub-surface,
    /// will cause a protocol error.
    /// 
    /// The z-order is double-buffered. Requests are handled in order and
    /// applied immediately to a pending state. The final pending state is
    /// copied to the active state the next time the state of the parent
    /// surface is applied. When this happens depends on whether the parent
    /// surface is in synchronized mode or not. See wl_subsurface.set_sync and
    /// wl_subsurface.set_desync for details.
    /// 
    /// A new sub-surface is initially added as the top-most in the stack
    /// of its siblings and parent.
    PlaceAbove {
        /// the reference surface
        sibling: ObjectId,
    },

    /// restack the sub-surface
    ///
    /// The sub-surface is placed just below the reference surface.
    /// See wl_subsurface.place_above.
    PlaceBelow {
        /// the reference surface
        sibling: ObjectId,
    },

    /// set sub-surface to synchronized mode
    ///
    /// Change the commit behaviour of the sub-surface to synchronized
    /// mode, also described as the parent dependent mode.
    /// 
    /// In synchronized mode, wl_surface.commit on a sub-surface will
    /// accumulate the committed state in a cache, but the state will
    /// not be applied and hence will not change the compositor output.
    /// The cached state is applied to the sub-surface immediately after
    /// the parent surface's state is applied. This ensures atomic
    /// updates of the parent and all its synchronized sub-surfaces.
    /// Applying the cached state will invalidate the cache, so further
    /// parent surface commits do not (re-)apply old state.
    /// 
    /// See wl_subsurface for the recursive effect of this mode.
    SetSync,

    /// set sub-surface to desynchronized mode
    ///
    /// Change the commit behaviour of the sub-surface to desynchronized
    /// mode, also described as independent or freely running mode.
    /// 
    /// In desynchronized mode, wl_surface.commit on a sub-surface will
    /// apply the pending state directly, without caching, as happens
    /// normally with a wl_surface. Calling wl_surface.commit on the
    /// parent surface has no effect on the sub-surface's wl_surface
    /// state. This mode allows a sub-surface to be updated on its own.
    /// 
    /// If cached state exists when wl_surface.commit is called in
    /// desynchronized mode, the pending state is added to the cached
    /// state, and applied as a whole. This invalidates the cache.
    /// 
    /// Note: even if a sub-surface is set to desynchronized, a parent
    /// sub-surface may override it to behave as synchronized. For details,
    /// see wl_subsurface.
    /// 
    /// If a surface's parent surface behaves as desynchronized, then
    /// the cached state is applied on set_desync.
    SetDesync,
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::Destroy {
            } => {
                format!("wl_subsurface@{:?}::destroy()", this)
            }
            Request::SetPosition {
                ref x,
                ref y,
            } => {
                format!("wl_subsurface@{:?}::set_position(x: {:?}, y: {:?})", this, x, y)
            }
            Request::PlaceAbove {
                ref sibling,
            } => {
                format!("wl_subsurface@{:?}::place_above(sibling: {:?})", this, sibling)
            }
            Request::PlaceBelow {
                ref sibling,
            } => {
                format!("wl_subsurface@{:?}::place_below(sibling: {:?})", this, sibling)
            }
            Request::SetSync {
            } => {
                format!("wl_subsurface@{:?}::set_sync()", this)
            }
            Request::SetDesync {
            } => {
                format!("wl_subsurface@{:?}::set_desync()", this)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::Destroy { .. } => c"wl_subsurface::destroy",
            Request::SetPosition { .. } => c"wl_subsurface::set_position",
            Request::PlaceAbove { .. } => c"wl_subsurface::place_above",
            Request::PlaceBelow { .. } => c"wl_subsurface::place_below",
            Request::SetSync { .. } => c"wl_subsurface::set_sync",
            Request::SetDesync { .. } => c"wl_subsurface::set_desync",
        }
    }
}
#[derive(Debug)]
pub enum Event {
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
        }
    }
}
impl IntoMessage for Request {
    type Error = EncodeError;
    fn into_message(self, id: u32) -> Result<Message, <Self as IntoMessage>::Error> {
        let mut header = MessageHeader {
            sender: id,
            opcode: 0,
            length: 0,
        };
        let mut msg = Message::new();
        msg.write_header(&header)?;
        match self {
        Request::Destroy {
        } => {
            header.opcode = 0;
        },
        Request::SetPosition {
            x,
            y,
        } => {
            msg.write_arg(Arg::Int(x))?;
            msg.write_arg(Arg::Int(y))?;
            header.opcode = 1;
        },
        Request::PlaceAbove {
            sibling,
        } => {
            msg.write_arg(Arg::Object(sibling))?;
            header.opcode = 2;
        },
        Request::PlaceBelow {
            sibling,
        } => {
            msg.write_arg(Arg::Object(sibling))?;
            header.opcode = 3;
        },
        Request::SetSync {
        } => {
            header.opcode = 4;
        },
        Request::SetDesync {
        } => {
            header.opcode = 5;
        },
        }
        header.length = msg.bytes().len() as u16;
        msg.rewind();
        msg.write_header(&header)?;
        Ok(msg)
    }
}
impl FromArgs for Event {
    fn from_args(op: u16, mut args: Vec<Arg>) -> Result<Self, anyhow::Error> {
        match op {
        _ => {
            Err(DecodeError::InvalidOpcode(op).into())
        },
        }
    }
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Error {
    /// wl_surface is not a sibling or the parent,
    BadSurface = 0,
}

impl Error {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(Error::BadSurface),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for Error {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
} // mod wl_subsurface

pub use crate::wl_subsurface::WlSubsurface;
pub use crate::wl_subsurface::Request as WlSubsurfaceRequest;
pub use crate::wl_subsurface::Event as WlSubsurfaceEvent;