Struct Seat

pub struct Seat(pub u64);

A seat.

Tuple Fields

0: u64

Implementations

impl Seat

pub const INVALID: Self

pub fn is_invalid(self) -> bool

Returns whether the seat is invalid.

pub fn use_hardware_cursor(self, use_hardware_cursor: bool)

Sets whether this seat’s cursor uses the hardware cursor if available.

Only one seat at a time can use the hardware cursor. Setting this to true for a seat automatically unsets it for all other seats.

By default, the first created seat uses the hardware cursor.

pub fn set_cursor_size(self, size: i32)

Sets the size of the cursor theme.

Default: 16.

pub fn bind<T: Into<ModifiedKeySym>, F: FnMut() + 'static>( self, mod_sym: T, f: F, )

Creates a compositor-wide hotkey.

The closure is invoked when the user presses the last key of the modified keysym. Note that the keysym is calculated without modifiers applied. To perform an action when SHIFT+k is pressed, use SHIFT | SYM_k not SHIFT | SYM_K.

CapsLock and NumLock are ignored during modifier evaluation. Therefore, bindings containing these modifiers will never be invoked.

pub fn bind_masked<T: Into<ModifiedKeySym>, F: FnMut() + 'static>( self, mod_mask: Modifiers, mod_sym: T, f: F, )

Creates a compositor-wide hotkey while ignoring some modifiers.

This is similar to bind except that only the masked modifiers are considered.

For example, if this function is invoked with mod_mask = Modifiers::NONE and mod_sym = SYM_XF86AudioRaiseVolume, then the callback will be invoked whenever SYM_XF86AudioRaiseVolume is pressed. Even if the user is simultaneously holding the shift key which would otherwise prevent the callback from taking effect.

For example, if this function is invoked with mod_mask = CTRL | SHIFT and mod_sym = CTRL | SYM_x, then the callback will be invoked whenever the user presses ctrl+x without pressing the shift key. Even if the user is simultaneously holding the alt key.

If mod_sym contains any modifiers, then these modifiers are automatically added to the mask. The synthetic RELEASE modifier is always added to the mask.

pub fn latch<F: FnOnce() + 'static>(self, f: F)

Registers a callback to be executed when the currently pressed key is released.

This should only be called in callbacks for key-press binds.

The callback will be executed once when the key is released regardless of any modifiers.

pub fn unbind<T: Into<ModifiedKeySym>>(self, mod_sym: T)

Unbinds a hotkey.

pub fn focus(self, direction: Direction)

Moves the keyboard focus of the seat in the specified direction.

pub fn move_(self, direction: Direction)

Moves the focused window in the specified direction.

pub fn set_keymap(self, keymap: Keymap)

Sets the keymap of the seat.

pub fn repeat_rate(self) -> (i32, i32)

Returns the repeat rate of the seat.

The returned tuple is (rate, delay) where rate is the number of times keys repeat per second and delay is the time after the button press after which keys start repeating.

pub fn set_repeat_rate(self, rate: i32, delay: i32)

Sets the repeat rate of the seat.

pub fn mono(self) -> bool

Returns whether the parent-container of the currently focused window is in mono-mode.

pub fn set_mono(self, mono: bool)

Sets whether the parent-container of the currently focused window is in mono-mode.

pub fn toggle_mono(self)

Toggles whether the parent-container of the currently focused window is in mono-mode.

pub fn split(self) -> Axis

Returns the split axis of the parent-container of the currently focused window.

pub fn set_split(self, axis: Axis)

Sets the split axis of the parent-container of the currently focused window.

pub fn toggle_split(self)

Toggles the split axis of the parent-container of the currently focused window.

pub fn input_devices(self) -> Vec<InputDevice>

Returns the input devices assigned to this seat.

pub fn create_split(self, axis: Axis)

Creates a new container with the specified split in place of the currently focused window.

pub fn focus_parent(self)

Focuses the parent node of the currently focused window.

pub fn close(self)

Requests the currently focused window to be closed.

pub fn get_floating(self) -> bool

Returns whether the currently focused window is floating.

pub fn set_floating(self, floating: bool)

Sets whether the currently focused window is floating.

pub fn toggle_floating(self)

Toggles whether the currently focused window is floating.

You can do the same by double-clicking on the header.

pub fn get_workspace(self) -> Workspace

Returns the workspace that is currently active on the output that contains the seat’s cursor.

If no such workspace exists, exists returns false for the returned workspace.

pub fn show_workspace(self, workspace: Workspace)

Shows the workspace and sets the keyboard focus of the seat to that workspace.

If the workspace doesn’t currently exist, it is created on the output that contains the seat’s cursor.

pub fn set_workspace(self, workspace: Workspace)

Moves the currently focused window to the workspace.

pub fn toggle_fullscreen(self)

Toggles whether the currently focused window is fullscreen.

pub fn fullscreen(self) -> bool

Returns whether the currently focused window is fullscreen.

pub fn set_fullscreen(self, fullscreen: bool)

Sets whether the currently focused window is fullscreen.

pub fn disable_pointer_constraint(self)

Disables the currently active pointer constraint on this seat.

pub fn move_to_output(self, connector: Connector)

Moves the currently focused workspace to another output.

pub fn set_forward(self, forward: bool)

Set whether the current key event is forwarded to the focused client.

This only has an effect if called from a keyboard shortcut.

By default, release events are forwarded and press events are consumed. Note that consuming release events can cause clients to get stuck in the pressed state.

pub fn forward(self)

This is a shorthand for set_forward(true).

pub fn consume(self)

This is a shorthand for set_forward(false).

pub fn set_focus_follows_mouse_mode(self, mode: FocusFollowsMouseMode)

Sets the focus-follows-mouse mode.

pub fn set_window_management_enabled(self, enabled: bool)

Enables or disable window management mode.

In window management mode, floating windows can be moved by pressing the left mouse button and all windows can be resize by pressing the right mouse button.

pub fn set_window_management_key<T: Into<ModifiedKeySym>>(self, mod_sym: T)

Sets a key that enables window management mode while pressed.

This is a shorthand for

self.bind(mod_sym, move || {
    self.set_window_management_enabled(true);
    self.forward();
    self.latch(move || {
        self.set_window_management_enabled(false);
    });
});

Trait Implementations

impl Clone for Seat

fn clone(&self) -> Seat

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Seat

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Seat

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Seat

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

Feeds this value into the given Hasher.

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 PartialEq for Seat

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

Tests for self and other values to be equal, and is used by ==.

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 Serialize for Seat

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Seat

impl Eq for Seat

impl StructuralPartialEq for Seat