zaura_shell_client_protocol/

zaura_shell_client_protocol.rs

// GENERATED FILE -- DO NOT EDIT
//
// Copyright 2017 The Chromium Authors.
// 
// 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 zaura_shell {
use super::*;

/// aura_shell
///
/// The global interface exposing aura shell capabilities is used to
/// instantiate an interface extension for a wl_surface object.
/// This extended interface will then allow the client to use aura shell
/// specific functionality.
#[derive(Debug)]
pub struct ZauraShell;

impl Interface for ZauraShell {
    const NAME: &'static str = "zaura_shell";
    const VERSION: u32 = 8;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // get_aura_surface
        MessageSpec(&[
            ArgKind::NewId,
            ArgKind::Object,
        ]),
        // get_aura_output
        MessageSpec(&[
            ArgKind::NewId,
            ArgKind::Object,
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// extend surface interface for aura shell
    ///
    /// Instantiate an interface extension for the given wl_surface to
    /// provide aura shell functionality. If the given wl_surface is not
    /// associated with a shell surface, the shell_surface_missing protocol
    /// error is raised.
    GetAuraSurface {
        /// the new aura surface interface id
        id: NewId,
        /// the surface
        surface: ObjectId,
    },

    /// extend output interface for aura shell
    ///
    /// Instantiate an interface extension for the given wl_output to
    /// provide aura shell functionality.
    GetAuraOutput {
        /// the new aura output interface id
        id: NewId,
        /// the output
        output: ObjectId,
    },
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::GetAuraSurface {
                ref id,
                ref surface,
            } => {
                format!("zaura_shell@{:?}::get_aura_surface(id: {:?}, surface: {:?})", this, id, surface)
            }
            Request::GetAuraOutput {
                ref id,
                ref output,
            } => {
                format!("zaura_shell@{:?}::get_aura_output(id: {:?}, output: {:?})", this, id, output)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::GetAuraSurface { .. } => c"zaura_shell::get_aura_surface",
            Request::GetAuraOutput { .. } => c"zaura_shell::get_aura_output",
        }
    }
}
#[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::GetAuraSurface {
            id,
            surface,
        } => {
            msg.write_arg(Arg::NewId(id))?;
            msg.write_arg(Arg::Object(surface))?;
            header.opcode = 0;
        },
        Request::GetAuraOutput {
            id,
            output,
        } => {
            msg.write_arg(Arg::NewId(id))?;
            msg.write_arg(Arg::Object(output))?;
            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 surface already has an aura surface object associated,
    AuraSurfaceExists = 0,
    /// the output already has an aura output object associated,
    AuraOutputExists = 1,
}

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

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

pub use crate::zaura_shell::ZauraShell;
pub use crate::zaura_shell::Request as ZauraShellRequest;
pub use crate::zaura_shell::Event as ZauraShellEvent;
pub mod zaura_surface {
use super::*;

/// aura shell interface to a wl_surface
///
/// An additional interface to a wl_surface object, which allows the
/// client to access aura shell specific functionality for surface.
#[derive(Debug)]
pub struct ZauraSurface;

impl Interface for ZauraSurface {
    const NAME: &'static str = "zaura_surface";
    const VERSION: u32 = 8;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
        // set_frame
        MessageSpec(&[
            ArgKind::Uint,
        ]),
        // set_parent
        MessageSpec(&[
            ArgKind::Object,
            ArgKind::Int,
            ArgKind::Int,
        ]),
        // set_frame_colors
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Uint,
        ]),
        // set_startup_id
        MessageSpec(&[
            ArgKind::String,
        ]),
        // set_application_id
        MessageSpec(&[
            ArgKind::String,
        ]),
        // set_client_surface_id
        MessageSpec(&[
            ArgKind::Int,
        ]),
        // set_occlusion_tracking
        MessageSpec(&[
        ]),
        // unset_occlusion_tracking
        MessageSpec(&[
        ]),
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // occlusion_changed
        MessageSpec(&[
            ArgKind::Fixed,
            ArgKind::Uint,
        ]),
    ]);
    type Incoming = Event;
    type Outgoing = Request;
}

#[derive(Debug)]
pub enum Request {

    /// request a frame for surface
    ///
    /// Suggests a surface should use a specific frame.
    SetFrame {
        /// the new frame type
        type_: u32,
    },

    /// set the parent of this surface
    ///
    /// Set the "parent" of this surface. "x" and "y" arguments specify the
    /// initial position for surface relative to parent.
    SetParent {
        parent: ObjectId,
        x: i32,
        y: i32,
    },

    /// set the frame colors of this surface
    ///
    /// Set the frame colors.
    SetFrameColors {
        /// 32 bit ARGB color value, not premultiplied
        active_color: u32,
        /// 32 bit ARGB color value, not premultiplied
        inactive_color: u32,
    },

    /// set the startup ID of this surface
    ///
    /// Set the startup ID.
    SetStartupId {
        startup_id: String,
    },

    /// set the application ID of this surface
    ///
    /// Set the application ID.
    SetApplicationId {
        application_id: String,
    },

    /// set the client surface ID of this surface
    ///
    /// Set the identifier of the surface assigned by the client.
    SetClientSurfaceId {
        client_surface_id: i32,
    },

    /// set tracked occlusion region
    ///
    /// Sets occlusion tracking on this surface. The client will be updated with a
    /// new occlusion fraction when the amount of occlusion of this surface changes.
    SetOcclusionTracking,

    /// unset tracked occlusion region
    ///
    /// Unsets occlusion tracking for this surface.
    UnsetOcclusionTracking,
}

impl MessageType for Request {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Request::SetFrame {
                ref type_,
            } => {
                format!("zaura_surface@{:?}::set_frame(type: {:?})", this, type_)
            }
            Request::SetParent {
                ref parent,
                ref x,
                ref y,
            } => {
                format!("zaura_surface@{:?}::set_parent(parent: {:?}, x: {:?}, y: {:?})", this, parent, x, y)
            }
            Request::SetFrameColors {
                ref active_color,
                ref inactive_color,
            } => {
                format!("zaura_surface@{:?}::set_frame_colors(active_color: {:?}, inactive_color: {:?})", this, active_color, inactive_color)
            }
            Request::SetStartupId {
                ref startup_id,
            } => {
                format!("zaura_surface@{:?}::set_startup_id(startup_id: {:?})", this, startup_id)
            }
            Request::SetApplicationId {
                ref application_id,
            } => {
                format!("zaura_surface@{:?}::set_application_id(application_id: {:?})", this, application_id)
            }
            Request::SetClientSurfaceId {
                ref client_surface_id,
            } => {
                format!("zaura_surface@{:?}::set_client_surface_id(client_surface_id: {:?})", this, client_surface_id)
            }
            Request::SetOcclusionTracking {
            } => {
                format!("zaura_surface@{:?}::set_occlusion_tracking()", this)
            }
            Request::UnsetOcclusionTracking {
            } => {
                format!("zaura_surface@{:?}::unset_occlusion_tracking()", this)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Request::SetFrame { .. } => c"zaura_surface::set_frame",
            Request::SetParent { .. } => c"zaura_surface::set_parent",
            Request::SetFrameColors { .. } => c"zaura_surface::set_frame_colors",
            Request::SetStartupId { .. } => c"zaura_surface::set_startup_id",
            Request::SetApplicationId { .. } => c"zaura_surface::set_application_id",
            Request::SetClientSurfaceId { .. } => c"zaura_surface::set_client_surface_id",
            Request::SetOcclusionTracking { .. } => c"zaura_surface::set_occlusion_tracking",
            Request::UnsetOcclusionTracking { .. } => c"zaura_surface::unset_occlusion_tracking",
        }
    }
}
#[derive(Debug)]
pub enum Event {

    /// Notifies on an occlusion change
    ///
    /// Notifies when there is a change in the amount this surface is occluded.
    /// The occlusion update is sent as a fixed point number from 0 to 1, representing
    /// the proportion of occlusion.
    OcclusionChanged {
        occlusion_fraction: Fixed,
        occlusion_reason: u32,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::OcclusionChanged {
                ref occlusion_fraction,
                ref occlusion_reason,
            } => {
                format!("zaura_surface@{:?}::occlusion_changed(occlusion_fraction: {:?}, occlusion_reason: {:?})", this, occlusion_fraction, occlusion_reason)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::OcclusionChanged { .. } => c"zaura_surface::occlusion_changed",
        }
    }
}
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::SetFrame {
            type_,
        } => {
            msg.write_arg(Arg::Uint(type_))?;
            header.opcode = 0;
        },
        Request::SetParent {
            parent,
            x,
            y,
        } => {
            msg.write_arg(Arg::Object(parent))?;
            msg.write_arg(Arg::Int(x))?;
            msg.write_arg(Arg::Int(y))?;
            header.opcode = 1;
        },
        Request::SetFrameColors {
            active_color,
            inactive_color,
        } => {
            msg.write_arg(Arg::Uint(active_color))?;
            msg.write_arg(Arg::Uint(inactive_color))?;
            header.opcode = 2;
        },
        Request::SetStartupId {
            startup_id,
        } => {
            msg.write_arg(Arg::String(startup_id))?;
            header.opcode = 3;
        },
        Request::SetApplicationId {
            application_id,
        } => {
            msg.write_arg(Arg::String(application_id))?;
            header.opcode = 4;
        },
        Request::SetClientSurfaceId {
            client_surface_id,
        } => {
            msg.write_arg(Arg::Int(client_surface_id))?;
            header.opcode = 5;
        },
        Request::SetOcclusionTracking {
        } => {
            header.opcode = 6;
        },
        Request::UnsetOcclusionTracking {
        } => {
            header.opcode = 7;
        },
        }
        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 /* occlusion_changed */ => {
            let mut iter = args.into_iter();
            Ok(Event::OcclusionChanged {
                occlusion_fraction: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_fixed()?.into(),
                occlusion_reason: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint()?,

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

/// different frame types
///
/// Frame types that can be used to decorate a surface.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum FrameType {
    /// no frame,
    None = 0,
    /// caption with shadow,
    Normal = 1,
    /// shadow only,
    Shadow = 2,
}

impl FrameType {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        0 => Some(FrameType::None),
        1 => Some(FrameType::Normal),
        2 => Some(FrameType::Shadow),
        _ => None,
        }
    }

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

/// occlusion change reason
///
/// Enum describing why an occlusion change happened. An occlusion change as a
/// result of a user action could include things like the user moving a window,
/// changing occlusion, or opening/closing a window, changing the occlusion.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum OcclusionChangeReason {
    /// occlusion changed as a result of a user action,
    UserAction = 1,
}

impl OcclusionChangeReason {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        1 => Some(OcclusionChangeReason::UserAction),
        _ => None,
        }
    }

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

pub use crate::zaura_surface::ZauraSurface;
pub use crate::zaura_surface::Request as ZauraSurfaceRequest;
pub use crate::zaura_surface::Event as ZauraSurfaceEvent;
pub mod zaura_output {
use super::*;

/// aura shell interface to a wl_output
///
/// An additional interface to a wl_output object, which allows the
/// client to access aura shell specific functionality for output.
#[derive(Debug)]
pub struct ZauraOutput;

impl Interface for ZauraOutput {
    const NAME: &'static str = "zaura_output";
    const VERSION: u32 = 6;
    const REQUESTS: MessageGroupSpec = MessageGroupSpec(&[
    ]);
    const EVENTS: MessageGroupSpec = MessageGroupSpec(&[
        // scale
        MessageSpec(&[
            ArgKind::Uint,
            ArgKind::Uint,
        ]),
        // connection
        MessageSpec(&[
            ArgKind::Uint,
        ]),
        // device_scale_factor
        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 {

    /// advertise available scales for the output
    ///
    /// The scale event describes an available scale for the output.
    /// 
    /// The event is sent when binding to the output object and there
    /// will always be one scale, the current scale. The event is sent
    /// again if an output changes scale, for the scale that is now
    /// current. In other words, the current scale is always the last
    /// scale that was received with the current flag set.
    Scale {
        /// bitfield of scale flags
        flags: Enum<ScaleProperty>,
        /// output scale
        scale: Enum<ScaleFactor>,
    },

    /// advertise connection for the output
    ///
    /// The connection event describes how the output is connected.
    /// 
    /// The event is sent when binding to the output object.
    Connection {
        /// output connection
        connection: Enum<ConnectionType>,
    },

    /// advertise device scale factor for the output
    ///
    /// This event describes the device specific scale factor for the output.
    /// 
    /// The device specific scale factor is not expected the change during
    /// the lifetime of the output. And it is not limited to an integer value
    /// like the scale factor provided by wl_output interface. The exact
    /// contents scale used by the compositor can be determined by combining
    /// this device scale factor with the current output scale.
    /// 
    /// The event is sent when binding to the output object.
    DeviceScaleFactor {
        /// output device scale factor
        scale: Enum<ScaleFactor>,
    },
}

impl MessageType for Event {
    fn log(&self, this: ObjectId) -> String {
        match *self {
            Event::Scale {
                ref flags,
                ref scale,
            } => {
                format!("zaura_output@{:?}::scale(flags: {:?}, scale: {:?})", this, flags, scale)
            }
            Event::Connection {
                ref connection,
            } => {
                format!("zaura_output@{:?}::connection(connection: {:?})", this, connection)
            }
            Event::DeviceScaleFactor {
                ref scale,
            } => {
                format!("zaura_output@{:?}::device_scale_factor(scale: {:?})", this, scale)
            }
        }
    }
    fn message_name(&self) -> &'static std::ffi::CStr{
        match *self {
            Event::Scale { .. } => c"zaura_output::scale",
            Event::Connection { .. } => c"zaura_output::connection",
            Event::DeviceScaleFactor { .. } => c"zaura_output::device_scale_factor",
        }
    }
}
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 /* scale */ => {
            let mut iter = args.into_iter();
            Ok(Event::Scale {
                flags: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match ScaleProperty::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,
                scale: iter.next()
                                             .ok_or(DecodeError::InsufficientArgs)?
                                             .as_uint().map(|i| match ScaleFactor::from_bits(i) {
                                      Some(e) => Enum::Recognized(e),
                                      None => Enum::Unrecognized(i),
                                 })?,

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

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

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

    /// scale information
    ///
    /// These flags describe properties of an output scale.
    /// They are used in the flags bitfield of the scale event.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ScaleProperty: u32 {
        /// indicates this is the current scale,
        const Current = 1;
        /// indicates this is the preferred scale,
        const Preferred = 2;
    }
}
impl Into<Arg> for ScaleProperty {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum ScaleFactor {
    _0400 = 400,
    _0500 = 500,
    _0550 = 550,
    _0600 = 600,
    _0625 = 625,
    _0650 = 650,
    _0700 = 700,
    _0750 = 750,
    _0800 = 800,
    _0850 = 850,
    _0900 = 900,
    _0950 = 950,
    _1000 = 1000,
    _1050 = 1050,
    _1100 = 1100,
    _1150 = 1150,
    _1125 = 1125,
    _1200 = 1200,
    _1250 = 1250,
    _1300 = 1300,
    _1400 = 1400,
    _1450 = 1450,
    _1500 = 1500,
    _1600 = 1600,
    _1750 = 1750,
    _1800 = 1800,
    _2000 = 2000,
    _2200 = 2200,
    _2250 = 2250,
    _2500 = 2500,
    _2750 = 2750,
    _3000 = 3000,
    _3500 = 3500,
    _4000 = 4000,
    _4500 = 4500,
    _5000 = 5000,
}

impl ScaleFactor {
    pub fn from_bits(v: u32) -> Option<Self> {
        match v {
        400 => Some(ScaleFactor::_0400),
        500 => Some(ScaleFactor::_0500),
        550 => Some(ScaleFactor::_0550),
        600 => Some(ScaleFactor::_0600),
        625 => Some(ScaleFactor::_0625),
        650 => Some(ScaleFactor::_0650),
        700 => Some(ScaleFactor::_0700),
        750 => Some(ScaleFactor::_0750),
        800 => Some(ScaleFactor::_0800),
        850 => Some(ScaleFactor::_0850),
        900 => Some(ScaleFactor::_0900),
        950 => Some(ScaleFactor::_0950),
        1000 => Some(ScaleFactor::_1000),
        1050 => Some(ScaleFactor::_1050),
        1100 => Some(ScaleFactor::_1100),
        1150 => Some(ScaleFactor::_1150),
        1125 => Some(ScaleFactor::_1125),
        1200 => Some(ScaleFactor::_1200),
        1250 => Some(ScaleFactor::_1250),
        1300 => Some(ScaleFactor::_1300),
        1400 => Some(ScaleFactor::_1400),
        1450 => Some(ScaleFactor::_1450),
        1500 => Some(ScaleFactor::_1500),
        1600 => Some(ScaleFactor::_1600),
        1750 => Some(ScaleFactor::_1750),
        1800 => Some(ScaleFactor::_1800),
        2000 => Some(ScaleFactor::_2000),
        2200 => Some(ScaleFactor::_2200),
        2250 => Some(ScaleFactor::_2250),
        2500 => Some(ScaleFactor::_2500),
        2750 => Some(ScaleFactor::_2750),
        3000 => Some(ScaleFactor::_3000),
        3500 => Some(ScaleFactor::_3500),
        4000 => Some(ScaleFactor::_4000),
        4500 => Some(ScaleFactor::_4500),
        5000 => Some(ScaleFactor::_5000),
        _ => None,
        }
    }

    pub fn bits(&self) -> u32 {
        *self as u32
    }
}
impl Into<Arg> for ScaleFactor {
    fn into(self) -> Arg {
        Arg::Uint(self.bits())
    }
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum ConnectionType {
    Unknown = 0,
    Internal = 1,
}

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

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

pub use crate::zaura_output::ZauraOutput;
pub use crate::zaura_output::Request as ZauraOutputRequest;
pub use crate::zaura_output::Event as ZauraOutputEvent;