Struct Root 

pub struct Root { /* private fields */ }

Implementations

impl Root

pub fn new( globals: &GlobalList, event_queue: &mut EventQueue<Root>, bar: Option<Bar>, ) -> Result<Root>

Examples found in repository

examples/toml_config/main.rs (line 11)

fn main() -> Result<()> {
    let config = Config::parse_toml("./examples/toml_config/config.toml".into())?;

    let conn = Connection::connect_to_env()?;
    let (globals, mut event_queue) = registry_queue_init(&conn)?;

    let mut capybar = Root::new(&globals, &mut event_queue, None)?;
    capybar.apply_config(config)?;

    capybar.run(&mut event_queue)?;

    Ok(())
}

examples/basic/main.rs (line 115)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let catpuccin_mocha = Palete {
        background: Color::from_hex(0x1e1e2eff),
        border: Color::from_hex(0x74c7ecff),
        font: Color::from_hex(0xf5e0dcff),
    };

    let conn = Connection::connect_to_env()?;
    let (globals, mut event_queue) = registry_queue_init(&conn)?;

    let mut bar = Bar::new(
        None,
        BarSettings {
            default_data: WidgetData {
                width: 1920,
                ..WidgetData::default()
            },
            padding: (10, 10, 10),

            style: Style {
                background: Some(catpuccin_mocha.background),
                border: Some((1, catpuccin_mocha.border)),

                ..Style::default()
            },

            ..BarSettings::default()
        },
    )?;

    // Left widgets
    bar.create_widget_left(
        CPU::new,
        CPUSettings {
            update_rate: 1000,
            text_settings: TextSettings {
                font_color: catpuccin_mocha.font,
                size: 25.0,

                ..TextSettings::default()
            },
            default_data: WidgetData {
                ..WidgetData::default()
            },
            style: Style {
                margin: Margin {
                    left: 10,
                    right: 0,
                    up: 0,
                    down: 0,
                },
                ..Default::default()
            },
            ..CPUSettings::default()
        },
    )?;

    //Center widgets
    bar.create_widget_center(
        Clock::new,
        ClockSettings {
            font_color: catpuccin_mocha.font,
            size: 25.0,

            ..ClockSettings::default()
        },
    )?;

    // Right widgets
    bar.create_widget_right(
        Battery::new,
        BatterySettings {
            text_settings: TextSettings {
                font_color: catpuccin_mocha.font,
                size: 25.0,

                ..TextSettings::default()
            },
            default_data: WidgetData {
                ..WidgetData::default()
            },
            style: Style {
                margin: Margin {
                    left: 0,
                    right: 10,
                    up: 0,
                    down: 0,
                },
                ..Default::default()
            },
            ..BatterySettings::default()
        },
    )?;

    let mut capybar = Root::new(&globals, &mut event_queue, Some(bar))?;

    // Fonts can be replaces by your liking. The first font added will be used for normal text, the
    // second for emoji
    //capybar.add_font_by_name("mono")?;
    capybar.add_font_by_name("jetbrainsmononerdfont")?;
    capybar.add_font_by_name("jetbrainsmononerdfont")?;

    capybar.run(&mut event_queue)?;

    Ok(())
}

pub fn apply_config(&mut self, config: Config) -> Result<()>

Examples found in repository

examples/toml_config/main.rs (line 12)

fn main() -> Result<()> {
    let config = Config::parse_toml("./examples/toml_config/config.toml".into())?;

    let conn = Connection::connect_to_env()?;
    let (globals, mut event_queue) = registry_queue_init(&conn)?;

    let mut capybar = Root::new(&globals, &mut event_queue, None)?;
    capybar.apply_config(config)?;

    capybar.run(&mut event_queue)?;

    Ok(())
}

pub fn run(&mut self, event_queue: &mut EventQueue<Root>) -> Result<&mut Self>

Examples found in repository

examples/toml_config/main.rs (line 14)

fn main() -> Result<()> {
    let config = Config::parse_toml("./examples/toml_config/config.toml".into())?;

    let conn = Connection::connect_to_env()?;
    let (globals, mut event_queue) = registry_queue_init(&conn)?;

    let mut capybar = Root::new(&globals, &mut event_queue, None)?;
    capybar.apply_config(config)?;

    capybar.run(&mut event_queue)?;

    Ok(())
}

examples/basic/main.rs (line 123)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let catpuccin_mocha = Palete {
        background: Color::from_hex(0x1e1e2eff),
        border: Color::from_hex(0x74c7ecff),
        font: Color::from_hex(0xf5e0dcff),
    };

    let conn = Connection::connect_to_env()?;
    let (globals, mut event_queue) = registry_queue_init(&conn)?;

    let mut bar = Bar::new(
        None,
        BarSettings {
            default_data: WidgetData {
                width: 1920,
                ..WidgetData::default()
            },
            padding: (10, 10, 10),

            style: Style {
                background: Some(catpuccin_mocha.background),
                border: Some((1, catpuccin_mocha.border)),

                ..Style::default()
            },

            ..BarSettings::default()
        },
    )?;

    // Left widgets
    bar.create_widget_left(
        CPU::new,
        CPUSettings {
            update_rate: 1000,
            text_settings: TextSettings {
                font_color: catpuccin_mocha.font,
                size: 25.0,

                ..TextSettings::default()
            },
            default_data: WidgetData {
                ..WidgetData::default()
            },
            style: Style {
                margin: Margin {
                    left: 10,
                    right: 0,
                    up: 0,
                    down: 0,
                },
                ..Default::default()
            },
            ..CPUSettings::default()
        },
    )?;

    //Center widgets
    bar.create_widget_center(
        Clock::new,
        ClockSettings {
            font_color: catpuccin_mocha.font,
            size: 25.0,

            ..ClockSettings::default()
        },
    )?;

    // Right widgets
    bar.create_widget_right(
        Battery::new,
        BatterySettings {
            text_settings: TextSettings {
                font_color: catpuccin_mocha.font,
                size: 25.0,

                ..TextSettings::default()
            },
            default_data: WidgetData {
                ..WidgetData::default()
            },
            style: Style {
                margin: Margin {
                    left: 0,
                    right: 10,
                    up: 0,
                    down: 0,
                },
                ..Default::default()
            },
            ..BatterySettings::default()
        },
    )?;

    let mut capybar = Root::new(&globals, &mut event_queue, Some(bar))?;

    // Fonts can be replaces by your liking. The first font added will be used for normal text, the
    // second for emoji
    //capybar.add_font_by_name("mono")?;
    capybar.add_font_by_name("jetbrainsmononerdfont")?;
    capybar.add_font_by_name("jetbrainsmononerdfont")?;

    capybar.run(&mut event_queue)?;

    Ok(())
}

pub fn add_font_by_name(&mut self, name: &'static str) -> Result<(), FontsError>

Examples found in repository

examples/basic/main.rs (line 120)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let catpuccin_mocha = Palete {
        background: Color::from_hex(0x1e1e2eff),
        border: Color::from_hex(0x74c7ecff),
        font: Color::from_hex(0xf5e0dcff),
    };

    let conn = Connection::connect_to_env()?;
    let (globals, mut event_queue) = registry_queue_init(&conn)?;

    let mut bar = Bar::new(
        None,
        BarSettings {
            default_data: WidgetData {
                width: 1920,
                ..WidgetData::default()
            },
            padding: (10, 10, 10),

            style: Style {
                background: Some(catpuccin_mocha.background),
                border: Some((1, catpuccin_mocha.border)),

                ..Style::default()
            },

            ..BarSettings::default()
        },
    )?;

    // Left widgets
    bar.create_widget_left(
        CPU::new,
        CPUSettings {
            update_rate: 1000,
            text_settings: TextSettings {
                font_color: catpuccin_mocha.font,
                size: 25.0,

                ..TextSettings::default()
            },
            default_data: WidgetData {
                ..WidgetData::default()
            },
            style: Style {
                margin: Margin {
                    left: 10,
                    right: 0,
                    up: 0,
                    down: 0,
                },
                ..Default::default()
            },
            ..CPUSettings::default()
        },
    )?;

    //Center widgets
    bar.create_widget_center(
        Clock::new,
        ClockSettings {
            font_color: catpuccin_mocha.font,
            size: 25.0,

            ..ClockSettings::default()
        },
    )?;

    // Right widgets
    bar.create_widget_right(
        Battery::new,
        BatterySettings {
            text_settings: TextSettings {
                font_color: catpuccin_mocha.font,
                size: 25.0,

                ..TextSettings::default()
            },
            default_data: WidgetData {
                ..WidgetData::default()
            },
            style: Style {
                margin: Margin {
                    left: 0,
                    right: 10,
                    up: 0,
                    down: 0,
                },
                ..Default::default()
            },
            ..BatterySettings::default()
        },
    )?;

    let mut capybar = Root::new(&globals, &mut event_queue, Some(bar))?;

    // Fonts can be replaces by your liking. The first font added will be used for normal text, the
    // second for emoji
    //capybar.add_font_by_name("mono")?;
    capybar.add_font_by_name("jetbrainsmononerdfont")?;
    capybar.add_font_by_name("jetbrainsmononerdfont")?;

    capybar.run(&mut event_queue)?;

    Ok(())
}

pub fn create_service<W, F>( &mut self, f: F, settings: W::Settings, ) -> Result<()>

where W: ServiceNew + Service + 'static, F: FnOnce(Option<Rc<Environment>>, W::Settings) -> Result<W, ServiceError>,

pub fn bar(&self) -> &Option<Bar>

Trait Implementations

impl CompositorHandler for Root

fn scale_factor_changed( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _surface: &WlSurface, _new_factor: i32, )

The surface has either been moved into or out of an output and the output has a different scale factor.

fn transform_changed( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _surface: &WlSurface, _new_transform: Transform, )

The surface has either been moved into or out of an output and the output has different transform.

fn frame( &mut self, _conn: &Connection, qh: &QueueHandle<Self>, _surface: &WlSurface, _time: u32, )

A frame callback has been completed.

fn surface_enter( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _surface: &WlSurface, _output: &WlOutput, )

The surface has entered an output.

fn surface_leave( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _surface: &WlSurface, _output: &WlOutput, )

The surface has left an output.

impl Dispatch<WlCallback, WlSurface> for Root

fn event( state: &mut Self, proxy: &WlCallback, event: <WlCallback as Proxy>::Event, data: &WlSurface, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlCompositor, GlobalData> for Root

fn event( state: &mut Self, proxy: &WlCompositor, event: <WlCompositor as Proxy>::Event, data: &GlobalData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlKeyboard, KeyboardData<Root>> for Root

fn event( state: &mut Self, proxy: &WlKeyboard, event: <WlKeyboard as Proxy>::Event, data: &KeyboardData<Root>, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlOutput, OutputData> for Root

fn event( state: &mut Self, proxy: &WlOutput, event: <WlOutput as Proxy>::Event, data: &OutputData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlPointer, PointerData> for Root

fn event( state: &mut Self, proxy: &WlPointer, event: <WlPointer as Proxy>::Event, data: &PointerData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlRegistry, GlobalListContents> for Root

fn event( state: &mut Self, proxy: &WlRegistry, event: <WlRegistry as Proxy>::Event, data: &GlobalListContents, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlSeat, SeatData> for Root

fn event( state: &mut Self, proxy: &WlSeat, event: <WlSeat as Proxy>::Event, data: &SeatData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlShm, GlobalData> for Root

fn event( state: &mut Self, proxy: &WlShm, event: <WlShm as Proxy>::Event, data: &GlobalData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WlSurface, SurfaceData> for Root

fn event( state: &mut Self, proxy: &WlSurface, event: <WlSurface as Proxy>::Event, data: &SurfaceData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WpCursorShapeDeviceV1, GlobalData> for Root

fn event( state: &mut Self, proxy: &WpCursorShapeDeviceV1, event: <WpCursorShapeDeviceV1 as Proxy>::Event, data: &GlobalData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<WpCursorShapeManagerV1, GlobalData> for Root

fn event( state: &mut Self, proxy: &WpCursorShapeManagerV1, event: <WpCursorShapeManagerV1 as Proxy>::Event, data: &GlobalData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<ZwlrLayerShellV1, GlobalData> for Root

fn event( state: &mut Self, proxy: &ZwlrLayerShellV1, event: <ZwlrLayerShellV1 as Proxy>::Event, data: &GlobalData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<ZwlrLayerSurfaceV1, LayerSurfaceData> for Root

fn event( state: &mut Self, proxy: &ZwlrLayerSurfaceV1, event: <ZwlrLayerSurfaceV1 as Proxy>::Event, data: &LayerSurfaceData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<ZxdgOutputManagerV1, GlobalData> for Root

fn event( state: &mut Self, proxy: &ZxdgOutputManagerV1, event: <ZxdgOutputManagerV1 as Proxy>::Event, data: &GlobalData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl Dispatch<ZxdgOutputV1, OutputData> for Root

fn event( state: &mut Self, proxy: &ZxdgOutputV1, event: <ZxdgOutputV1 as Proxy>::Event, data: &OutputData, conn: &Connection, qhandle: &QueueHandle<Self>, )

Called when an event from the server is processed

fn event_created_child( opcode: u16, qhandle: &QueueHandle<Self>, ) -> Arc<dyn ObjectData>

Method used to initialize the user-data of objects created by events

impl KeyboardHandler for Root

fn enter( &mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlKeyboard, surface: &WlSurface, _: u32, _: &[u32], _: &[Keysym], )

The keyboard has entered a surface.

fn leave( &mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlKeyboard, surface: &WlSurface, _: u32, )

The keyboard has left a surface.

fn press_key( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _: &WlKeyboard, _: u32, _: KeyEvent, )

A key has been pressed on the keyboard.

fn release_key( &mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlKeyboard, _: u32, _: KeyEvent, )

A key has been released.

fn update_modifiers( &mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlKeyboard, _serial: u32, _: Modifiers, _layout: u32, )

Keyboard modifiers have been updated.

fn update_repeat_info( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _keyboard: &WlKeyboard, _info: RepeatInfo, )

The keyboard has updated the rate and delay between repeating key inputs.

fn update_keymap( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _keyboard: &WlKeyboard, _keymap: Keymap<'_>, )

Keyboard keymap has been updated.

impl LayerShellHandler for Root

fn closed( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _layer: &LayerSurface, )

The layer surface has been closed.

fn configure( &mut self, _conn: &Connection, qh: &QueueHandle<Self>, _layer: &LayerSurface, configure: LayerSurfaceConfigure, _serial: u32, )

Apply a suggested surface change.

impl OutputHandler for Root

fn output_state(&mut self) -> &mut OutputState

fn new_output( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _output: WlOutput, )

A new output has been advertised.

fn update_output( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _output: WlOutput, )

An existing output has changed.

fn output_destroyed( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _output: WlOutput, )

An output is no longer advertised.

impl PointerHandler for Root

fn pointer_frame( &mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _pointer: &WlPointer, events: &[PointerEvent], )

One or more pointer events are available.

impl ProvidesRegistryState for Root

fn registry(&mut self) -> &mut RegistryState

Returns a mutable reference to the registry state.

fn runtime_add_global( &mut self, conn: &Connection, qh: &QueueHandle<Self>, name: u32, interface: &str, version: u32, )

Called when a new global has been advertised by the compositor.

fn runtime_remove_global( &mut self, conn: &Connection, qh: &QueueHandle<Self>, name: u32, interface: &str, )

Called when a global has been destroyed by the compositor.

impl SeatHandler for Root

fn seat_state(&mut self) -> &mut SeatState

fn new_seat(&mut self, _: &Connection, _: &QueueHandle<Self>, _: WlSeat)

A new seat has been created.

fn new_capability( &mut self, _conn: &Connection, qh: &QueueHandle<Self>, seat: WlSeat, capability: Capability, )

A new capability is available on the seat.

fn remove_capability( &mut self, _conn: &Connection, _: &QueueHandle<Self>, _: WlSeat, capability: Capability, )

A capability has been removed from the seat.

fn remove_seat(&mut self, _: &Connection, _: &QueueHandle<Self>, _: WlSeat)

A seat has been removed.

impl ShmHandler for Root

fn shm_state(&mut self) -> &mut Shm