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_history(self, timeline: Timeline)

Moves the focus in the focus history.

pub fn focus_history_set_only_visible(self, only_visible: bool)

Configures whether the focus history only includes visible windows.

If this is false, then hidden windows will be made visible before moving the focus to them.

The default is false.

pub fn focus_history_set_same_workspace(self, same_workspace: bool)

Configures whether the focus history only includes windows on the same workspace as the currently focused window.

The default is false.

pub fn focus_layer_rel(self, direction: LayerDirection)

Moves the keyboard focus of the seat to the layer above or below the current layer.

pub fn focus_tiles(self)

Moves the keyboard focus to the tile layer.

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 get_keyboard_workspace(self) -> Workspace

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

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);
    });
});

pub fn float_pinned(self) -> bool

Gets whether the currently focused window is pinned.

If a floating window is pinned, it will stay visible even when switching to a different workspace.

pub fn set_float_pinned(self, pinned: bool)

Sets whether the currently focused window is pinned.

pub fn toggle_float_pinned(self)

Toggles whether the currently focused window is pinned.

pub fn window(self) -> Window

Returns the focused window.

If no window is focused, Window::exists returns false.

pub fn focus_window(self, window: Window)

Puts the keyboard focus on the window.

This has no effect if the window is not visible.

pub fn set_pointer_revert_key(self, sym: KeySym)

Sets the key that can be used to revert the pointer to the default state.

Pressing this key cancels any grabs, drags, selections, etc.

The default is SYM_Escape. Setting this to SYM_NoSymbol effectively disables this functionality.

pub fn create_mark(self, kc: Option<u32>)

Creates a mark for the currently focused window.

kc should be an evdev keycode. If kc is none, then the keycode will be inferred from the next key press. Pressing escape during this interactive selection aborts the process.

Currently very few u32 are valid keycodes. Large numbers can therefore be used to create marks that do not correspond to a key. However, kc should always be less than u32::MAX - 8.

pub fn jump_to_mark(self, kc: Option<u32>)

Moves the keyboard focus to a window identified by a mark.

See Seat::create_mark for information about the kc parameter.

pub fn copy_mark(self, src: u32, dst: u32)

Copies a mark from one keycode to another.

If the src keycode identifies a mark before this function is called, the dst keycode will identify the same mark afterwards.

Trait Implementations

impl Clone for Seat

fn clone(&self) -> Seat

Returns a duplicate 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