Struct Session 

pub struct Session { /* private fields */ }

GLib type: GObject with reference counted clone semantics.

Implementations

impl Session

pub fn new() -> Session

Examples found in repository

examples/basic.rs (line 9)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let session = Session::new();
    if let Some(uri) = args.get(1) {
        session.set_uri(Some(uri));
    } else {
        session.set_host(Some("localhost"));
        session.set_port(Some("5900"));
    }

    session.connect_channel_new(|_, channel| {
        if let Ok(display) = channel.clone().downcast::<DisplayChannel>() {
            ChannelExt::connect(&display);
            display.connect_channel_event(|channel, event| {
                dbg!((channel, event));
            });
            display.connect_gl_scanout_notify(|display| {
                dbg!(display.gl_scanout().unwrap().fd());
            });
            dbg!(display.monitors());
        }
    });

    session.connect();

    let main_context = glib::MainContext::default();
    let main_loop = glib::MainLoop::new(Some(&main_context), false);
    main_loop.run();
}

pub fn connect(&self) -> bool

Examples found in repository

examples/basic.rs (line 30)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let session = Session::new();
    if let Some(uri) = args.get(1) {
        session.set_uri(Some(uri));
    } else {
        session.set_host(Some("localhost"));
        session.set_port(Some("5900"));
    }

    session.connect_channel_new(|_, channel| {
        if let Ok(display) = channel.clone().downcast::<DisplayChannel>() {
            ChannelExt::connect(&display);
            display.connect_channel_event(|channel, event| {
                dbg!((channel, event));
            });
            display.connect_gl_scanout_notify(|display| {
                dbg!(display.gl_scanout().unwrap().fd());
            });
            dbg!(display.monitors());
        }
    });

    session.connect();

    let main_context = glib::MainContext::default();
    let main_loop = glib::MainLoop::new(Some(&main_context), false);
    main_loop.run();
}

pub fn disconnect(&self)

pub fn channels(&self) -> Vec<Channel>

pub fn proxy_uri(&self) -> Option<URI>

pub fn is_read_only(&self) -> bool

pub fn has_channel_type(&self, type_: i32) -> bool

pub fn is_for_migration(&self) -> bool

pub fn open_fd(&self, fd: i32) -> bool

pub fn ca(&self) -> Option<ByteArray>

pub fn set_ca(&self, ca: Option<&ByteArray>)

pub fn ca_file(&self) -> Option<GString>

pub fn set_ca_file(&self, ca_file: Option<&str>)

pub fn cache_size(&self) -> i32

pub fn set_cache_size(&self, cache_size: i32)

pub fn cert_subject(&self) -> Option<GString>

pub fn set_cert_subject(&self, cert_subject: Option<&str>)

pub fn ciphers(&self) -> Option<GString>

pub fn set_ciphers(&self, ciphers: Option<&str>)

pub fn is_client_sockets(&self) -> bool

pub fn set_client_sockets(&self, client_sockets: bool)

pub fn disable_effects(&self) -> Vec<GString>

pub fn set_disable_effects(&self, disable_effects: &[&str])

pub fn enables_audio(&self) -> bool

pub fn set_enable_audio(&self, enable_audio: bool)

pub fn enables_smartcard(&self) -> bool

pub fn set_enable_smartcard(&self, enable_smartcard: bool)

pub fn enables_usbredir(&self) -> bool

pub fn set_enable_usbredir(&self, enable_usbredir: bool)

pub fn is_gl_scanout(&self) -> bool

pub fn set_gl_scanout(&self, gl_scanout: bool)

pub fn glz_window_size(&self) -> i32

pub fn set_glz_window_size(&self, glz_window_size: i32)

pub fn host(&self) -> Option<GString>

pub fn set_host(&self, host: Option<&str>)

Examples found in repository

examples/basic.rs (line 13)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let session = Session::new();
    if let Some(uri) = args.get(1) {
        session.set_uri(Some(uri));
    } else {
        session.set_host(Some("localhost"));
        session.set_port(Some("5900"));
    }

    session.connect_channel_new(|_, channel| {
        if let Ok(display) = channel.clone().downcast::<DisplayChannel>() {
            ChannelExt::connect(&display);
            display.connect_channel_event(|channel, event| {
                dbg!((channel, event));
            });
            display.connect_gl_scanout_notify(|display| {
                dbg!(display.gl_scanout().unwrap().fd());
            });
            dbg!(display.monitors());
        }
    });

    session.connect();

    let main_context = glib::MainContext::default();
    let main_loop = glib::MainLoop::new(Some(&main_context), false);
    main_loop.run();
}

pub fn is_inhibit_keyboard_grab(&self) -> bool

pub fn set_inhibit_keyboard_grab(&self, inhibit_keyboard_grab: bool)

pub fn migration_state(&self) -> SessionMigration

pub fn name(&self) -> Option<GString>

pub fn password(&self) -> Option<GString>

pub fn set_password(&self, password: Option<&str>)

pub fn port(&self) -> Option<GString>

pub fn set_port(&self, port: Option<&str>)

Examples found in repository

examples/basic.rs (line 14)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let session = Session::new();
    if let Some(uri) = args.get(1) {
        session.set_uri(Some(uri));
    } else {
        session.set_host(Some("localhost"));
        session.set_port(Some("5900"));
    }

    session.connect_channel_new(|_, channel| {
        if let Ok(display) = channel.clone().downcast::<DisplayChannel>() {
            ChannelExt::connect(&display);
            display.connect_channel_event(|channel, event| {
                dbg!((channel, event));
            });
            display.connect_gl_scanout_notify(|display| {
                dbg!(display.gl_scanout().unwrap().fd());
            });
            dbg!(display.monitors());
        }
    });

    session.connect();

    let main_context = glib::MainContext::default();
    let main_loop = glib::MainLoop::new(Some(&main_context), false);
    main_loop.run();
}

pub fn protocol(&self) -> i32

pub fn set_protocol(&self, protocol: i32)

pub fn proxy(&self) -> Option<GString>

pub fn set_proxy(&self, proxy: Option<&str>)

pub fn pubkey(&self) -> Option<ByteArray>

pub fn set_pubkey(&self, pubkey: Option<&ByteArray>)

pub fn set_read_only(&self, read_only: bool)

pub fn secure_channels(&self) -> Vec<GString>

pub fn set_secure_channels(&self, secure_channels: &[&str])

pub fn is_share_dir_ro(&self) -> bool

pub fn set_share_dir_ro(&self, share_dir_ro: bool)

pub fn shared_dir(&self) -> Option<GString>

pub fn set_shared_dir(&self, shared_dir: Option<&str>)

pub fn smartcard_certificates(&self) -> Vec<GString>

pub fn set_smartcard_certificates(&self, smartcard_certificates: &[&str])

pub fn smartcard_db(&self) -> Option<GString>

pub fn set_smartcard_db(&self, smartcard_db: Option<&str>)

pub fn tls_port(&self) -> Option<GString>

pub fn set_tls_port(&self, tls_port: Option<&str>)

pub fn unix_path(&self) -> Option<GString>

pub fn set_unix_path(&self, unix_path: Option<&str>)

pub fn uri(&self) -> Option<GString>

pub fn set_uri(&self, uri: Option<&str>)

Examples found in repository

examples/basic.rs (line 11)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let session = Session::new();
    if let Some(uri) = args.get(1) {
        session.set_uri(Some(uri));
    } else {
        session.set_host(Some("localhost"));
        session.set_port(Some("5900"));
    }

    session.connect_channel_new(|_, channel| {
        if let Ok(display) = channel.clone().downcast::<DisplayChannel>() {
            ChannelExt::connect(&display);
            display.connect_channel_event(|channel, event| {
                dbg!((channel, event));
            });
            display.connect_gl_scanout_notify(|display| {
                dbg!(display.gl_scanout().unwrap().fd());
            });
            dbg!(display.monitors());
        }
    });

    session.connect();

    let main_context = glib::MainContext::default();
    let main_loop = glib::MainLoop::new(Some(&main_context), false);
    main_loop.run();
}

pub fn username(&self) -> Option<GString>

pub fn set_username(&self, username: Option<&str>)

pub fn verify(&self) -> SessionVerify

pub fn set_verify(&self, verify: SessionVerify)

pub fn connect_channel_destroy<F: Fn(&Self, &Channel) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_channel_new<F: Fn(&Self, &Channel) + 'static>( &self, f: F, ) -> SignalHandlerId

Examples found in repository

examples/basic.rs (lines 17-28)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let session = Session::new();
    if let Some(uri) = args.get(1) {
        session.set_uri(Some(uri));
    } else {
        session.set_host(Some("localhost"));
        session.set_port(Some("5900"));
    }

    session.connect_channel_new(|_, channel| {
        if let Ok(display) = channel.clone().downcast::<DisplayChannel>() {
            ChannelExt::connect(&display);
            display.connect_channel_event(|channel, event| {
                dbg!((channel, event));
            });
            display.connect_gl_scanout_notify(|display| {
                dbg!(display.gl_scanout().unwrap().fd());
            });
            dbg!(display.monitors());
        }
    });

    session.connect();

    let main_context = glib::MainContext::default();
    let main_loop = glib::MainLoop::new(Some(&main_context), false);
    main_loop.run();
}

pub fn connect_disconnected<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_mm_time_reset<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_ca_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId

pub fn connect_ca_file_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_cache_size_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_cert_subject_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_ciphers_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_client_sockets_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_disable_effects_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_enable_audio_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_enable_smartcard_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_enable_usbredir_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_gl_scanout_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_glz_window_size_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_host_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_inhibit_keyboard_grab_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_migration_state_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_name_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_password_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_port_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_protocol_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_proxy_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_pubkey_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_read_only_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_secure_channels_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_share_dir_ro_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_shared_dir_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_smartcard_certificates_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_smartcard_db_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_tls_port_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_unix_path_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_uri_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_username_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_uuid_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_verify_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

Trait Implementations

impl Clone for Session

fn clone(&self) -> Self

Makes a clone of this shared reference.

This increments the strong reference count of the object. Dropping the object will decrement it again.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Session

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Session

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Session

impl HasParamSpec for Session

type ParamSpec = ParamSpecObject

type SetValue = Session

Preferred value to be used as setter for the associated ParamSpec.

type BuilderFn = fn(&str) -> ParamSpecObjectBuilder<'_, Session>

fn param_spec_builder() -> Self::BuilderFn

impl Hash for Session

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Hashes the memory address of this object.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Session

fn cmp(&self, other: &Self) -> Ordering

Comparison for two GObjects.

Compares the memory addresses of the provided objects.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl ParentClassIs for Session

type Parent = Object

impl<OT: ObjectType> PartialEq<OT> for Session

fn eq(&self, other: &OT) -> bool

Equality for two GObjects.

Two GObjects are equal if their memory addresses are equal.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<OT: ObjectType> PartialOrd<OT> for Session

fn partial_cmp(&self, other: &OT) -> Option<Ordering>

Partial comparison for two GObjects.

Compares the memory addresses of the provided objects.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for Session

fn static_type() -> Type

Returns the type identifier of Self.