Struct State

pub struct State<H: Handle> {

    pub screens: Vec<Screen<H>>,
    pub windows: Vec<Window<H>>,
    pub workspaces: Vec<Workspace>,
    pub focus_manager: FocusManager<H>,
    pub layout_manager: LayoutManager,
    pub mode: Mode<H>,
    pub active_scratchpads: HashMap<ScratchPadName, VecDeque<ChildID>>,
    pub actions: VecDeque<DisplayAction<H>>,
    pub tags: Tags,
    pub scratchpads: Vec<ScratchPad>,
    pub layout_definitions: Vec<Layout>,
    pub mousekey: Vec<String>,
    pub default_width: i32,
    pub default_height: i32,
    pub disable_tile_drag: bool,
    pub reposition_cursor_on_resize: bool,
    pub insert_behavior: InsertBehavior,
    pub single_window_border: bool,
}

Fields

screens: Vec<Screen<H>>

windows: Vec<Window<H>>

workspaces: Vec<Workspace>

focus_manager: FocusManager<H>

layout_manager: LayoutManager

mode: Mode<H>

active_scratchpads: HashMap<ScratchPadName, VecDeque<ChildID>>

actions: VecDeque<DisplayAction<H>>

tags: Tags

scratchpads: Vec<ScratchPad>

layout_definitions: Vec<Layout>

mousekey: Vec<String>

default_width: i32

default_height: i32

disable_tile_drag: bool

reposition_cursor_on_resize: bool

insert_behavior: InsertBehavior

single_window_border: bool

Implementations

impl<H: Handle> State<H>

pub fn handle_window_focus(&mut self, handle: &WindowHandle<H>)

Focuses a window based upon the FocusBehaviour

pub fn focus_window(&mut self, handle: &WindowHandle<H>)

Focuses the given window.

pub fn focus_workspace(&mut self, workspace: &Workspace)

Focuses the given workspace.

pub fn focus_tag(&mut self, tag: &TagId)

Focuses the given tag.

pub fn focus_workspace_with_point(&mut self, x: i32, y: i32)

Focuses the workspace containing a given point.

pub fn focus_window_with_point(&mut self, x: i32, y: i32)

Focuses the window containing a given point.

pub fn validate_focus_at(&mut self, handle: &WindowHandle<H>)

Validates that the given window is focused.

impl<H: Handle> State<H>

pub fn goto_tag_handler(&mut self, tag_id: TagId) -> Option<bool>

goto_tag_handler is called in response to various Commands. it updates the focus manager and focuses tag_id

Returns Some(true) if changes need to be rendered.

impl<H: Handle> State<H>

pub fn mouse_combo_handler( &mut self, modmask: &ModMask, button: Button, handle: WindowHandle<H>, x: i32, y: i32, ) -> bool

mouse_combo_handler is called when the display server sends DisplayEvent::MouseCombo(modmask, button, handle, x, y)

Returns true if changes need to be rendered.

impl<H: Handle> State<H>

pub fn sort_windows(&mut self)

Sorts the windows and puts them in order of importance.

pub fn handle_single_border(&mut self, border_width: i32)

Removes border if there is a single visible window. Only will run if single_window_border is set to false in the configuration file.

pub fn move_to_top(&mut self, handle: &WindowHandle<H>) -> Option<()>

Moves handle in front of all other windows of the same order of importance. See sort_windows() for the order of importance.

pub fn update_static(&mut self)

pub fn restore_state(&mut self, old_state: &Self)

Apply saved state to a running manager.

Trait Implementations

impl<H: Debug + Handle> Debug for State<H>

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

Formats the value using the given formatter.

impl<'de, H: Handle> Deserialize<'de> for State<H>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<H: Handle> From<&State<H>> for ManagerState

fn from(state: &State<H>) -> Self

Converts to this type from the input type.

impl<H: Handle> Serialize for State<H>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.