Struct leftwm_layouts::LayoutDefinition

pub struct LayoutDefinition {
    pub name: String,
    pub column_type: ColumnType,
    pub flipped: Flipped,
    pub rotation: Rotation,
    pub main_window_count: usize,
    pub main_size: Size,
    pub main_split: SplitAxis,
    pub stack_split: SplitAxis,
    pub reserve_column_space: ReserveColumnSpace,
    pub balance_stacks: bool,
}

Fields

name: String

The unique identifier for the layout, there can be only one layout with the same name. If a layout is defined multiple times, it may be overwritten.

column_type: ColumnType

The column type used in this layout. This usually isn’t changed during runtime. See ColumnType for details.

flipped: Flipped

See Flipped for details.

rotation: Rotation

See Rotation for details.

main_window_count: usize

Determines the amount of windows to show in the main column of the layout. If the layout has no main column, this modifier will be ignored.

main_size: Size

The Size of the available space which the main column should occupy. If the layout has no main column, or no window in the main column, this modifier will be ignored. Value can either be absolute Pixels (400px) or a Ratio (eg. 0.5). Defaults to 0.5, meaning 50%.

main_split: SplitAxis

The way to split windows in the main_column when there are more than one window. If the layout has no main column, or no window in the main column, this modifier will be ignored. See SplitAxis for details. Defaults to SplitAxis::Vertical

stack_split: SplitAxis

The way to split windows in the stack_column(s) when there are more than one window. See SplitAxis for details.

reserve_column_space: ReserveColumnSpace

The way to handle empty column space where there is no window. See ReserveColumnSpace for details.

balance_stacks: bool

When set to true stack windows are distributed evenly between stacks, when set to false the first stack gets a single window, and the rest of the windows go to the second stack. This modifier is ignored in layouts that have just one stack

Demonstration

When set to true

+-----+-------+-----+
|  2  |       |  4  |
|     |       |     |
|-----|   1   |-----|
|  3  |       |  5  |
|     |       |     |
+-----+-------+-----+

When set to false

+-----+-------+-----+
|     |       |  3  |
|     |       |-----|
|  2  |   1   |  4  |
|     |       |-----|
|     |       |  5  |
+-----+-------+-----+

Implementations

impl LayoutDefinition

pub fn increase_main_size(&mut self, upper_bound: i32)

pub fn decrease_main_size(&mut self)

pub fn increase_main_window_count(&mut self)

pub fn decrease_main_window_count(&mut self)

pub fn fallback() -> Self

Trait Implementations

impl Clone for LayoutDefinition

fn clone(&self) -> LayoutDefinition

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LayoutDefinition

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

Formats the value using the given formatter.

impl Default for LayoutDefinition

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LayoutDefinition

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<LayoutDefinition> for LayoutDefinition

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for LayoutDefinition

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LayoutDefinition