Struct Columns 

pub struct Columns {
    pub flip: Flip,
    pub rotate: Rotation,
    pub main: Option<Main>,
    pub stack: Stack,
    pub second_stack: Option<SecondStack>,
}

Describes the columns of a layout. There are only 3 columns which are a fixed part of leftwm_layouts, those are main, stack, and second_stack.

+------+------+------+
|      |      |      |
|      |      |      |
|      |      |      |
+------+------+------+
 stack   main  second
               stack

Modifiers

Modifiers like Flip and Rotation are applied only to the columns themselves and not their contents.

For example, if you wish for the Stack to be on the left side instead of the right side in a MainAndStack layout configuration, the Flip property could be set to Flip::Vertical, which results in the columns being flipped, but not their contents.

Fields

flip: Flip

How the columns should be flipped, does not apply to their contents

rotate: Rotation

How the columns should be rotated, does not apply to their contents

main: Option<Main>

Configurations concerning the main column. This can be set to None, in which case the layout will not have a main column. For example, in single-column layouts like EvenVertical, Monocle, etc. See Main for more information.

stack: Stack

Configurations concerning the stack column. Other than main and second_stack, this column is always present. See Stack for more information.

second_stack: Option<SecondStack>

Configurations concerning the second_stack column. This can be set to None, in which case the layout is going to be a two-column layout like MainAndStack, Fibonacci, etc.

Note: If this is present but main is absent, it is condiered an invalid layout configuration. The second_stack configuration may be ignored if main is None See SecondStack for more information.

Trait Implementations

impl Clone for Columns

fn clone(&self) -> Columns

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Columns

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

Formats the value using the given formatter.

impl Default for Columns

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Columns

where Columns: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Columns

fn eq(&self, other: &Columns) -> 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 Columns

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 Columns