use glib::translate::*;
use glib::value::FromValue;
use glib::value::ToValue;
use glib::StaticType;
use glib::Type;
use std::fmt;
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "VncAudioFormatType")]
pub enum AudioFormatType {
#[doc(alias = "VNC_AUDIO_FORMAT_RAW_U8")]
U8,
#[doc(alias = "VNC_AUDIO_FORMAT_RAW_S8")]
S8,
#[doc(alias = "VNC_AUDIO_FORMAT_RAW_U16")]
U16,
#[doc(alias = "VNC_AUDIO_FORMAT_RAW_S16")]
S16,
#[doc(alias = "VNC_AUDIO_FORMAT_RAW_U32")]
U32,
#[doc(alias = "VNC_AUDIO_FORMAT_RAW_S32")]
S32,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for AudioFormatType {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"AudioFormatType::{}",
match *self {
Self::U8 => "U8",
Self::S8 => "S8",
Self::U16 => "U16",
Self::S16 => "S16",
Self::U32 => "U32",
Self::S32 => "S32",
_ => "Unknown",
}
)
}
}
#[doc(hidden)]
impl IntoGlib for AudioFormatType {
type GlibType = ffi::VncAudioFormatType;
fn into_glib(self) -> ffi::VncAudioFormatType {
match self {
Self::U8 => ffi::VNC_AUDIO_FORMAT_RAW_U8,
Self::S8 => ffi::VNC_AUDIO_FORMAT_RAW_S8,
Self::U16 => ffi::VNC_AUDIO_FORMAT_RAW_U16,
Self::S16 => ffi::VNC_AUDIO_FORMAT_RAW_S16,
Self::U32 => ffi::VNC_AUDIO_FORMAT_RAW_U32,
Self::S32 => ffi::VNC_AUDIO_FORMAT_RAW_S32,
Self::__Unknown(value) => value,
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::VncAudioFormatType> for AudioFormatType {
unsafe fn from_glib(value: ffi::VncAudioFormatType) -> Self {
skip_assert_initialized!();
match value {
ffi::VNC_AUDIO_FORMAT_RAW_U8 => Self::U8,
ffi::VNC_AUDIO_FORMAT_RAW_S8 => Self::S8,
ffi::VNC_AUDIO_FORMAT_RAW_U16 => Self::U16,
ffi::VNC_AUDIO_FORMAT_RAW_S16 => Self::S16,
ffi::VNC_AUDIO_FORMAT_RAW_U32 => Self::U32,
ffi::VNC_AUDIO_FORMAT_RAW_S32 => Self::S32,
value => Self::__Unknown(value),
}
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "VncConnectionAuth")]
pub enum ConnectionAuth {
#[doc(alias = "VNC_CONNECTION_AUTH_INVALID")]
Invalid,
#[doc(alias = "VNC_CONNECTION_AUTH_NONE")]
None,
#[doc(alias = "VNC_CONNECTION_AUTH_VNC")]
Vnc,
#[doc(alias = "VNC_CONNECTION_AUTH_RA2")]
Ra2,
#[doc(alias = "VNC_CONNECTION_AUTH_RA2NE")]
Ra2ne,
#[doc(alias = "VNC_CONNECTION_AUTH_TIGHT")]
Tight,
#[doc(alias = "VNC_CONNECTION_AUTH_ULTRA")]
Ultra,
#[doc(alias = "VNC_CONNECTION_AUTH_TLS")]
Tls,
#[doc(alias = "VNC_CONNECTION_AUTH_VENCRYPT")]
Vencrypt,
#[doc(alias = "VNC_CONNECTION_AUTH_SASL")]
Sasl,
#[doc(alias = "VNC_CONNECTION_AUTH_ARD")]
Ard,
#[doc(alias = "VNC_CONNECTION_AUTH_MSLOGONII")]
Mslogonii,
#[doc(alias = "VNC_CONNECTION_AUTH_MSLOGON")]
Mslogon,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ConnectionAuth {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"ConnectionAuth::{}",
match *self {
Self::Invalid => "Invalid",
Self::None => "None",
Self::Vnc => "Vnc",
Self::Ra2 => "Ra2",
Self::Ra2ne => "Ra2ne",
Self::Tight => "Tight",
Self::Ultra => "Ultra",
Self::Tls => "Tls",
Self::Vencrypt => "Vencrypt",
Self::Sasl => "Sasl",
Self::Ard => "Ard",
Self::Mslogonii => "Mslogonii",
Self::Mslogon => "Mslogon",
_ => "Unknown",
}
)
}
}
#[doc(hidden)]
impl IntoGlib for ConnectionAuth {
type GlibType = ffi::VncConnectionAuth;
fn into_glib(self) -> ffi::VncConnectionAuth {
match self {
Self::Invalid => ffi::VNC_CONNECTION_AUTH_INVALID,
Self::None => ffi::VNC_CONNECTION_AUTH_NONE,
Self::Vnc => ffi::VNC_CONNECTION_AUTH_VNC,
Self::Ra2 => ffi::VNC_CONNECTION_AUTH_RA2,
Self::Ra2ne => ffi::VNC_CONNECTION_AUTH_RA2NE,
Self::Tight => ffi::VNC_CONNECTION_AUTH_TIGHT,
Self::Ultra => ffi::VNC_CONNECTION_AUTH_ULTRA,
Self::Tls => ffi::VNC_CONNECTION_AUTH_TLS,
Self::Vencrypt => ffi::VNC_CONNECTION_AUTH_VENCRYPT,
Self::Sasl => ffi::VNC_CONNECTION_AUTH_SASL,
Self::Ard => ffi::VNC_CONNECTION_AUTH_ARD,
Self::Mslogonii => ffi::VNC_CONNECTION_AUTH_MSLOGONII,
Self::Mslogon => ffi::VNC_CONNECTION_AUTH_MSLOGON,
Self::__Unknown(value) => value,
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::VncConnectionAuth> for ConnectionAuth {
unsafe fn from_glib(value: ffi::VncConnectionAuth) -> Self {
skip_assert_initialized!();
match value {
ffi::VNC_CONNECTION_AUTH_INVALID => Self::Invalid,
ffi::VNC_CONNECTION_AUTH_NONE => Self::None,
ffi::VNC_CONNECTION_AUTH_VNC => Self::Vnc,
ffi::VNC_CONNECTION_AUTH_RA2 => Self::Ra2,
ffi::VNC_CONNECTION_AUTH_RA2NE => Self::Ra2ne,
ffi::VNC_CONNECTION_AUTH_TIGHT => Self::Tight,
ffi::VNC_CONNECTION_AUTH_ULTRA => Self::Ultra,
ffi::VNC_CONNECTION_AUTH_TLS => Self::Tls,
ffi::VNC_CONNECTION_AUTH_VENCRYPT => Self::Vencrypt,
ffi::VNC_CONNECTION_AUTH_SASL => Self::Sasl,
ffi::VNC_CONNECTION_AUTH_ARD => Self::Ard,
ffi::VNC_CONNECTION_AUTH_MSLOGONII => Self::Mslogonii,
ffi::VNC_CONNECTION_AUTH_MSLOGON => Self::Mslogon,
value => Self::__Unknown(value),
}
}
}
impl StaticType for ConnectionAuth {
fn static_type() -> Type {
unsafe { from_glib(ffi::vnc_connection_auth_get_type()) }
}
}
impl glib::value::ValueType for ConnectionAuth {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for ConnectionAuth {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
}
}
impl ToValue for ConnectionAuth {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "VncConnectionAuthVencrypt")]
pub enum ConnectionAuthVencrypt {
#[doc(alias = "VNC_CONNECTION_AUTH_VENCRYPT_PLAIN")]
Plain,
#[doc(alias = "VNC_CONNECTION_AUTH_VENCRYPT_TLSNONE")]
Tlsnone,
#[doc(alias = "VNC_CONNECTION_AUTH_VENCRYPT_TLSVNC")]
Tlsvnc,
#[doc(alias = "VNC_CONNECTION_AUTH_VENCRYPT_TLSPLAIN")]
Tlsplain,
#[doc(alias = "VNC_CONNECTION_AUTH_VENCRYPT_X509NONE")]
X509none,
#[doc(alias = "VNC_CONNECTION_AUTH_VENCRYPT_X509VNC")]
X509vnc,
#[doc(alias = "VNC_CONNECTION_AUTH_VENCRYPT_X509PLAIN")]
X509plain,
#[doc(alias = "VNC_CONNECTION_AUTH_VENCRYPT_X509SASL")]
X509sasl,
#[doc(alias = "VNC_CONNECTION_AUTH_VENCRYPT_TLSSASL")]
Tlssasl,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ConnectionAuthVencrypt {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"ConnectionAuthVencrypt::{}",
match *self {
Self::Plain => "Plain",
Self::Tlsnone => "Tlsnone",
Self::Tlsvnc => "Tlsvnc",
Self::Tlsplain => "Tlsplain",
Self::X509none => "X509none",
Self::X509vnc => "X509vnc",
Self::X509plain => "X509plain",
Self::X509sasl => "X509sasl",
Self::Tlssasl => "Tlssasl",
_ => "Unknown",
}
)
}
}
#[doc(hidden)]
impl IntoGlib for ConnectionAuthVencrypt {
type GlibType = ffi::VncConnectionAuthVencrypt;
fn into_glib(self) -> ffi::VncConnectionAuthVencrypt {
match self {
Self::Plain => ffi::VNC_CONNECTION_AUTH_VENCRYPT_PLAIN,
Self::Tlsnone => ffi::VNC_CONNECTION_AUTH_VENCRYPT_TLSNONE,
Self::Tlsvnc => ffi::VNC_CONNECTION_AUTH_VENCRYPT_TLSVNC,
Self::Tlsplain => ffi::VNC_CONNECTION_AUTH_VENCRYPT_TLSPLAIN,
Self::X509none => ffi::VNC_CONNECTION_AUTH_VENCRYPT_X509NONE,
Self::X509vnc => ffi::VNC_CONNECTION_AUTH_VENCRYPT_X509VNC,
Self::X509plain => ffi::VNC_CONNECTION_AUTH_VENCRYPT_X509PLAIN,
Self::X509sasl => ffi::VNC_CONNECTION_AUTH_VENCRYPT_X509SASL,
Self::Tlssasl => ffi::VNC_CONNECTION_AUTH_VENCRYPT_TLSSASL,
Self::__Unknown(value) => value,
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::VncConnectionAuthVencrypt> for ConnectionAuthVencrypt {
unsafe fn from_glib(value: ffi::VncConnectionAuthVencrypt) -> Self {
skip_assert_initialized!();
match value {
ffi::VNC_CONNECTION_AUTH_VENCRYPT_PLAIN => Self::Plain,
ffi::VNC_CONNECTION_AUTH_VENCRYPT_TLSNONE => Self::Tlsnone,
ffi::VNC_CONNECTION_AUTH_VENCRYPT_TLSVNC => Self::Tlsvnc,
ffi::VNC_CONNECTION_AUTH_VENCRYPT_TLSPLAIN => Self::Tlsplain,
ffi::VNC_CONNECTION_AUTH_VENCRYPT_X509NONE => Self::X509none,
ffi::VNC_CONNECTION_AUTH_VENCRYPT_X509VNC => Self::X509vnc,
ffi::VNC_CONNECTION_AUTH_VENCRYPT_X509PLAIN => Self::X509plain,
ffi::VNC_CONNECTION_AUTH_VENCRYPT_X509SASL => Self::X509sasl,
ffi::VNC_CONNECTION_AUTH_VENCRYPT_TLSSASL => Self::Tlssasl,
value => Self::__Unknown(value),
}
}
}
impl StaticType for ConnectionAuthVencrypt {
fn static_type() -> Type {
unsafe { from_glib(ffi::vnc_connection_auth_vencrypt_get_type()) }
}
}
impl glib::value::ValueType for ConnectionAuthVencrypt {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for ConnectionAuthVencrypt {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
}
}
impl ToValue for ConnectionAuthVencrypt {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "VncConnectionCredential")]
pub enum ConnectionCredential {
#[doc(alias = "VNC_CONNECTION_CREDENTIAL_PASSWORD")]
Password,
#[doc(alias = "VNC_CONNECTION_CREDENTIAL_USERNAME")]
Username,
#[doc(alias = "VNC_CONNECTION_CREDENTIAL_CLIENTNAME")]
Clientname,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ConnectionCredential {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"ConnectionCredential::{}",
match *self {
Self::Password => "Password",
Self::Username => "Username",
Self::Clientname => "Clientname",
_ => "Unknown",
}
)
}
}
#[doc(hidden)]
impl IntoGlib for ConnectionCredential {
type GlibType = ffi::VncConnectionCredential;
fn into_glib(self) -> ffi::VncConnectionCredential {
match self {
Self::Password => ffi::VNC_CONNECTION_CREDENTIAL_PASSWORD,
Self::Username => ffi::VNC_CONNECTION_CREDENTIAL_USERNAME,
Self::Clientname => ffi::VNC_CONNECTION_CREDENTIAL_CLIENTNAME,
Self::__Unknown(value) => value,
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::VncConnectionCredential> for ConnectionCredential {
unsafe fn from_glib(value: ffi::VncConnectionCredential) -> Self {
skip_assert_initialized!();
match value {
ffi::VNC_CONNECTION_CREDENTIAL_PASSWORD => Self::Password,
ffi::VNC_CONNECTION_CREDENTIAL_USERNAME => Self::Username,
ffi::VNC_CONNECTION_CREDENTIAL_CLIENTNAME => Self::Clientname,
value => Self::__Unknown(value),
}
}
}
impl StaticType for ConnectionCredential {
fn static_type() -> Type {
unsafe { from_glib(ffi::vnc_connection_credential_get_type()) }
}
}
impl glib::value::ValueType for ConnectionCredential {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for ConnectionCredential {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
}
}
impl ToValue for ConnectionCredential {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "VncConnectionEncoding")]
pub enum ConnectionEncoding {
#[doc(alias = "VNC_CONNECTION_ENCODING_RAW")]
Raw,
#[doc(alias = "VNC_CONNECTION_ENCODING_COPY_RECT")]
CopyRect,
#[doc(alias = "VNC_CONNECTION_ENCODING_RRE")]
Rre,
#[doc(alias = "VNC_CONNECTION_ENCODING_CORRE")]
Corre,
#[doc(alias = "VNC_CONNECTION_ENCODING_HEXTILE")]
Hextile,
#[doc(alias = "VNC_CONNECTION_ENCODING_TIGHT")]
Tight,
#[doc(alias = "VNC_CONNECTION_ENCODING_ZRLE")]
Zrle,
#[doc(alias = "VNC_CONNECTION_ENCODING_TIGHT_JPEG0")]
TightJpeg0,
#[doc(alias = "VNC_CONNECTION_ENCODING_TIGHT_JPEG1")]
TightJpeg1,
#[doc(alias = "VNC_CONNECTION_ENCODING_TIGHT_JPEG2")]
TightJpeg2,
#[doc(alias = "VNC_CONNECTION_ENCODING_TIGHT_JPEG3")]
TightJpeg3,
#[doc(alias = "VNC_CONNECTION_ENCODING_TIGHT_JPEG4")]
TightJpeg4,
#[doc(alias = "VNC_CONNECTION_ENCODING_TIGHT_JPEG5")]
TightJpeg5,
#[doc(alias = "VNC_CONNECTION_ENCODING_TIGHT_JPEG6")]
TightJpeg6,
#[doc(alias = "VNC_CONNECTION_ENCODING_TIGHT_JPEG7")]
TightJpeg7,
#[doc(alias = "VNC_CONNECTION_ENCODING_TIGHT_JPEG8")]
TightJpeg8,
#[doc(alias = "VNC_CONNECTION_ENCODING_TIGHT_JPEG9")]
TightJpeg9,
#[doc(alias = "VNC_CONNECTION_ENCODING_DESKTOP_RESIZE")]
DesktopResize,
#[doc(alias = "VNC_CONNECTION_ENCODING_LAST_RECT")]
LastRect,
#[doc(alias = "VNC_CONNECTION_ENCODING_WMVi")]
Wmvi,
#[doc(alias = "VNC_CONNECTION_ENCODING_CURSOR_POS")]
CursorPos,
#[doc(alias = "VNC_CONNECTION_ENCODING_RICH_CURSOR")]
RichCursor,
#[doc(alias = "VNC_CONNECTION_ENCODING_XCURSOR")]
Xcursor,
#[doc(alias = "VNC_CONNECTION_ENCODING_POINTER_CHANGE")]
PointerChange,
#[doc(alias = "VNC_CONNECTION_ENCODING_EXT_KEY_EVENT")]
ExtKeyEvent,
#[doc(alias = "VNC_CONNECTION_ENCODING_AUDIO")]
Audio,
#[doc(alias = "VNC_CONNECTION_ENCODING_LED_STATE")]
LedState,
#[doc(alias = "VNC_CONNECTION_ENCODING_DESKTOP_NAME")]
DesktopName,
#[doc(alias = "VNC_CONNECTION_ENCODING_EXTENDED_DESKTOP_RESIZE")]
ExtendedDesktopResize,
#[doc(alias = "VNC_CONNECTION_ENCODING_XVP")]
Xvp,
#[doc(alias = "VNC_CONNECTION_ENCODING_ALPHA_CURSOR")]
AlphaCursor,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ConnectionEncoding {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"ConnectionEncoding::{}",
match *self {
Self::Raw => "Raw",
Self::CopyRect => "CopyRect",
Self::Rre => "Rre",
Self::Corre => "Corre",
Self::Hextile => "Hextile",
Self::Tight => "Tight",
Self::Zrle => "Zrle",
Self::TightJpeg0 => "TightJpeg0",
Self::TightJpeg1 => "TightJpeg1",
Self::TightJpeg2 => "TightJpeg2",
Self::TightJpeg3 => "TightJpeg3",
Self::TightJpeg4 => "TightJpeg4",
Self::TightJpeg5 => "TightJpeg5",
Self::TightJpeg6 => "TightJpeg6",
Self::TightJpeg7 => "TightJpeg7",
Self::TightJpeg8 => "TightJpeg8",
Self::TightJpeg9 => "TightJpeg9",
Self::DesktopResize => "DesktopResize",
Self::LastRect => "LastRect",
Self::Wmvi => "Wmvi",
Self::CursorPos => "CursorPos",
Self::RichCursor => "RichCursor",
Self::Xcursor => "Xcursor",
Self::PointerChange => "PointerChange",
Self::ExtKeyEvent => "ExtKeyEvent",
Self::Audio => "Audio",
Self::LedState => "LedState",
Self::DesktopName => "DesktopName",
Self::ExtendedDesktopResize => "ExtendedDesktopResize",
Self::Xvp => "Xvp",
Self::AlphaCursor => "AlphaCursor",
_ => "Unknown",
}
)
}
}
#[doc(hidden)]
impl IntoGlib for ConnectionEncoding {
type GlibType = ffi::VncConnectionEncoding;
fn into_glib(self) -> ffi::VncConnectionEncoding {
match self {
Self::Raw => ffi::VNC_CONNECTION_ENCODING_RAW,
Self::CopyRect => ffi::VNC_CONNECTION_ENCODING_COPY_RECT,
Self::Rre => ffi::VNC_CONNECTION_ENCODING_RRE,
Self::Corre => ffi::VNC_CONNECTION_ENCODING_CORRE,
Self::Hextile => ffi::VNC_CONNECTION_ENCODING_HEXTILE,
Self::Tight => ffi::VNC_CONNECTION_ENCODING_TIGHT,
Self::Zrle => ffi::VNC_CONNECTION_ENCODING_ZRLE,
Self::TightJpeg0 => ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG0,
Self::TightJpeg1 => ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG1,
Self::TightJpeg2 => ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG2,
Self::TightJpeg3 => ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG3,
Self::TightJpeg4 => ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG4,
Self::TightJpeg5 => ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG5,
Self::TightJpeg6 => ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG6,
Self::TightJpeg7 => ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG7,
Self::TightJpeg8 => ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG8,
Self::TightJpeg9 => ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG9,
Self::DesktopResize => ffi::VNC_CONNECTION_ENCODING_DESKTOP_RESIZE,
Self::LastRect => ffi::VNC_CONNECTION_ENCODING_LAST_RECT,
Self::Wmvi => ffi::VNC_CONNECTION_ENCODING_WMVi,
Self::CursorPos => ffi::VNC_CONNECTION_ENCODING_CURSOR_POS,
Self::RichCursor => ffi::VNC_CONNECTION_ENCODING_RICH_CURSOR,
Self::Xcursor => ffi::VNC_CONNECTION_ENCODING_XCURSOR,
Self::PointerChange => ffi::VNC_CONNECTION_ENCODING_POINTER_CHANGE,
Self::ExtKeyEvent => ffi::VNC_CONNECTION_ENCODING_EXT_KEY_EVENT,
Self::Audio => ffi::VNC_CONNECTION_ENCODING_AUDIO,
Self::LedState => ffi::VNC_CONNECTION_ENCODING_LED_STATE,
Self::DesktopName => ffi::VNC_CONNECTION_ENCODING_DESKTOP_NAME,
Self::ExtendedDesktopResize => ffi::VNC_CONNECTION_ENCODING_EXTENDED_DESKTOP_RESIZE,
Self::Xvp => ffi::VNC_CONNECTION_ENCODING_XVP,
Self::AlphaCursor => ffi::VNC_CONNECTION_ENCODING_ALPHA_CURSOR,
Self::__Unknown(value) => value,
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::VncConnectionEncoding> for ConnectionEncoding {
unsafe fn from_glib(value: ffi::VncConnectionEncoding) -> Self {
skip_assert_initialized!();
match value {
ffi::VNC_CONNECTION_ENCODING_RAW => Self::Raw,
ffi::VNC_CONNECTION_ENCODING_COPY_RECT => Self::CopyRect,
ffi::VNC_CONNECTION_ENCODING_RRE => Self::Rre,
ffi::VNC_CONNECTION_ENCODING_CORRE => Self::Corre,
ffi::VNC_CONNECTION_ENCODING_HEXTILE => Self::Hextile,
ffi::VNC_CONNECTION_ENCODING_TIGHT => Self::Tight,
ffi::VNC_CONNECTION_ENCODING_ZRLE => Self::Zrle,
ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG0 => Self::TightJpeg0,
ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG1 => Self::TightJpeg1,
ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG2 => Self::TightJpeg2,
ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG3 => Self::TightJpeg3,
ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG4 => Self::TightJpeg4,
ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG5 => Self::TightJpeg5,
ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG6 => Self::TightJpeg6,
ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG7 => Self::TightJpeg7,
ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG8 => Self::TightJpeg8,
ffi::VNC_CONNECTION_ENCODING_TIGHT_JPEG9 => Self::TightJpeg9,
ffi::VNC_CONNECTION_ENCODING_DESKTOP_RESIZE => Self::DesktopResize,
ffi::VNC_CONNECTION_ENCODING_LAST_RECT => Self::LastRect,
ffi::VNC_CONNECTION_ENCODING_WMVi => Self::Wmvi,
ffi::VNC_CONNECTION_ENCODING_CURSOR_POS => Self::CursorPos,
ffi::VNC_CONNECTION_ENCODING_RICH_CURSOR => Self::RichCursor,
ffi::VNC_CONNECTION_ENCODING_XCURSOR => Self::Xcursor,
ffi::VNC_CONNECTION_ENCODING_POINTER_CHANGE => Self::PointerChange,
ffi::VNC_CONNECTION_ENCODING_EXT_KEY_EVENT => Self::ExtKeyEvent,
ffi::VNC_CONNECTION_ENCODING_AUDIO => Self::Audio,
ffi::VNC_CONNECTION_ENCODING_LED_STATE => Self::LedState,
ffi::VNC_CONNECTION_ENCODING_DESKTOP_NAME => Self::DesktopName,
ffi::VNC_CONNECTION_ENCODING_EXTENDED_DESKTOP_RESIZE => Self::ExtendedDesktopResize,
ffi::VNC_CONNECTION_ENCODING_XVP => Self::Xvp,
ffi::VNC_CONNECTION_ENCODING_ALPHA_CURSOR => Self::AlphaCursor,
value => Self::__Unknown(value),
}
}
}
impl StaticType for ConnectionEncoding {
fn static_type() -> Type {
unsafe { from_glib(ffi::vnc_connection_encoding_get_type()) }
}
}
impl glib::value::ValueType for ConnectionEncoding {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for ConnectionEncoding {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
}
}
impl ToValue for ConnectionEncoding {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "VncConnectionPowerAction")]
pub enum ConnectionPowerAction {
#[doc(alias = "VNC_CONNECTION_POWER_ACTION_SHUTDOWN")]
Shutdown,
#[doc(alias = "VNC_CONNECTION_POWER_ACTION_REBOOT")]
Reboot,
#[doc(alias = "VNC_CONNECTION_POWER_ACTION_RESET")]
Reset,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ConnectionPowerAction {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"ConnectionPowerAction::{}",
match *self {
Self::Shutdown => "Shutdown",
Self::Reboot => "Reboot",
Self::Reset => "Reset",
_ => "Unknown",
}
)
}
}
#[doc(hidden)]
impl IntoGlib for ConnectionPowerAction {
type GlibType = ffi::VncConnectionPowerAction;
fn into_glib(self) -> ffi::VncConnectionPowerAction {
match self {
Self::Shutdown => ffi::VNC_CONNECTION_POWER_ACTION_SHUTDOWN,
Self::Reboot => ffi::VNC_CONNECTION_POWER_ACTION_REBOOT,
Self::Reset => ffi::VNC_CONNECTION_POWER_ACTION_RESET,
Self::__Unknown(value) => value,
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::VncConnectionPowerAction> for ConnectionPowerAction {
unsafe fn from_glib(value: ffi::VncConnectionPowerAction) -> Self {
skip_assert_initialized!();
match value {
ffi::VNC_CONNECTION_POWER_ACTION_SHUTDOWN => Self::Shutdown,
ffi::VNC_CONNECTION_POWER_ACTION_REBOOT => Self::Reboot,
ffi::VNC_CONNECTION_POWER_ACTION_RESET => Self::Reset,
value => Self::__Unknown(value),
}
}
}
impl StaticType for ConnectionPowerAction {
fn static_type() -> Type {
unsafe { from_glib(ffi::vnc_connection_power_action_get_type()) }
}
}
impl glib::value::ValueType for ConnectionPowerAction {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for ConnectionPowerAction {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
}
}
impl ToValue for ConnectionPowerAction {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "VncConnectionResizeStatus")]
pub enum ConnectionResizeStatus {
#[doc(alias = "VNC_CONNECTION_RESIZE_STATUS_UNSUPPORTED")]
Unsupported,
#[doc(alias = "VNC_CONNECTION_RESIZE_STATUS_OK")]
Ok,
#[doc(alias = "VNC_CONNECTION_RESIZE_STATUS_ADMIN_PROHIBITED")]
AdminProhibited,
#[doc(alias = "VNC_CONNECTION_RESIZE_STATUS_OUT_OF_RESOURCES")]
OutOfResources,
#[doc(alias = "VNC_CONNECTION_RESIZE_STATUS_INVALID_LAOUT")]
InvalidLaout,
#[doc(alias = "VNC_CONNECTION_RESIZE_STATUS_FORWARDED")]
Forwarded,
#[doc(hidden)]
__Unknown(i32),
}
impl fmt::Display for ConnectionResizeStatus {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"ConnectionResizeStatus::{}",
match *self {
Self::Unsupported => "Unsupported",
Self::Ok => "Ok",
Self::AdminProhibited => "AdminProhibited",
Self::OutOfResources => "OutOfResources",
Self::InvalidLaout => "InvalidLaout",
Self::Forwarded => "Forwarded",
_ => "Unknown",
}
)
}
}
#[doc(hidden)]
impl IntoGlib for ConnectionResizeStatus {
type GlibType = ffi::VncConnectionResizeStatus;
fn into_glib(self) -> ffi::VncConnectionResizeStatus {
match self {
Self::Unsupported => ffi::VNC_CONNECTION_RESIZE_STATUS_UNSUPPORTED,
Self::Ok => ffi::VNC_CONNECTION_RESIZE_STATUS_OK,
Self::AdminProhibited => ffi::VNC_CONNECTION_RESIZE_STATUS_ADMIN_PROHIBITED,
Self::OutOfResources => ffi::VNC_CONNECTION_RESIZE_STATUS_OUT_OF_RESOURCES,
Self::InvalidLaout => ffi::VNC_CONNECTION_RESIZE_STATUS_INVALID_LAOUT,
Self::Forwarded => ffi::VNC_CONNECTION_RESIZE_STATUS_FORWARDED,
Self::__Unknown(value) => value,
}
}
}
#[doc(hidden)]
impl FromGlib<ffi::VncConnectionResizeStatus> for ConnectionResizeStatus {
unsafe fn from_glib(value: ffi::VncConnectionResizeStatus) -> Self {
skip_assert_initialized!();
match value {
ffi::VNC_CONNECTION_RESIZE_STATUS_UNSUPPORTED => Self::Unsupported,
ffi::VNC_CONNECTION_RESIZE_STATUS_OK => Self::Ok,
ffi::VNC_CONNECTION_RESIZE_STATUS_ADMIN_PROHIBITED => Self::AdminProhibited,
ffi::VNC_CONNECTION_RESIZE_STATUS_OUT_OF_RESOURCES => Self::OutOfResources,
ffi::VNC_CONNECTION_RESIZE_STATUS_INVALID_LAOUT => Self::InvalidLaout,
ffi::VNC_CONNECTION_RESIZE_STATUS_FORWARDED => Self::Forwarded,
value => Self::__Unknown(value),
}
}
}
impl StaticType for ConnectionResizeStatus {
fn static_type() -> Type {
unsafe { from_glib(ffi::vnc_connection_resize_status_get_type()) }
}
}
impl glib::value::ValueType for ConnectionResizeStatus {
type Type = Self;
}
unsafe impl<'a> FromValue<'a> for ConnectionResizeStatus {
type Checker = glib::value::GenericValueTypeChecker<Self>;
unsafe fn from_value(value: &'a glib::Value) -> Self {
skip_assert_initialized!();
from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
}
}
impl ToValue for ConnectionResizeStatus {
fn to_value(&self) -> glib::Value {
let mut value = glib::Value::for_value_type::<Self>();
unsafe {
glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
}
value
}
fn value_type(&self) -> glib::Type {
Self::static_type()
}
}