Struct FrameConfig 

pub struct FrameConfig {
    pub theme: ColorTheme,
    pub hide_titlebar: bool,
}

The configuration for the AdwaitaFrame frame.

Fields

theme: ColorTheme

hide_titlebar: bool

Draw decorations but without the titlebar

Implementations

impl FrameConfig

pub fn new(theme: ColorTheme) -> Self

Create the new configuration with the given theme.

pub fn auto() -> Self

This is equivalent of calling FrameConfig::new(ColorTheme::auto()).

For details see ColorTheme::auto.

Examples found in repository

examples/window.rs (line 256)

    fn configure(
        &mut self,
        conn: &Connection,
        qh: &QueueHandle<Self>,
        window: &Window,
        configure: WindowConfigure,
        _serial: u32,
    ) {
        self.buffer = None;

        println!(
            "Configure size {:?}, decorations: {:?}",
            configure.new_size, configure.decoration_mode
        );

        let (width, height) = if configure.decoration_mode == DecorationMode::Client {
            let window_frame = self.window_frame.get_or_insert_with(|| {
                let mut frame = AdwaitaFrame::new(
                    &self.window,
                    &self.shm_state,
                    self.compositor_state.clone(),
                    self.subcompositor_state.clone(),
                    qh.clone(),
                    FrameConfig::auto().hide_titlebar(self.hide_titlebar),
                )
                .expect("failed to create client side decorations frame.");
                frame.set_title(self.title.clone());
                frame
            });

            // Un-hide the frame.
            window_frame.set_hidden(false);

            // Configure state before touching any resizing.
            window_frame.update_state(configure.state);

            // Configure the button state.
            window_frame.update_wm_capabilities(configure.capabilities);

            let (width, height) = match configure.new_size {
                (Some(width), Some(height)) => {
                    // The size could be 0.
                    window_frame.subtract_borders(width, height)
                }
                _ => {
                    // You might want to consider checking for configure bounds.
                    (Some(self.width), Some(self.height))
                }
            };

            // Clamp the size to at least one pixel.
            let width = width.unwrap_or(NonZeroU32::new(1).unwrap());
            let height = height.unwrap_or(NonZeroU32::new(1).unwrap());

            window_frame.resize(width, height);

            let (x, y) = window_frame.location();
            let outer_size = window_frame.add_borders(width.get(), height.get());
            window.xdg_surface().set_window_geometry(
                x,
                y,
                outer_size.0 as i32,
                outer_size.1 as i32,
            );

            (width, height)
        } else {
            // Hide the frame, if any.
            if let Some(frame) = self.window_frame.as_mut() {
                frame.set_hidden(true)
            }
            let width = configure.new_size.0.unwrap_or(self.width);
            let height = configure.new_size.1.unwrap_or(self.height);
            self.window.xdg_surface().set_window_geometry(
                0,
                0,
                width.get() as i32,
                height.get() as i32,
            );
            (width, height)
        };

        // Update new width and height;
        self.width = width;
        self.height = height;

        // Initiate the first draw.
        if self.first_configure {
            self.first_configure = false;
            self.draw(conn, qh);
        }
    }
}

impl SeatHandler for SimpleWindow {
    fn seat_state(&mut self) -> &mut SeatState {
        &mut self.seat_state
    }

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

    fn new_capability(
        &mut self,
        _conn: &Connection,
        qh: &QueueHandle<Self>,
        seat: wl_seat::WlSeat,
        capability: Capability,
    ) {
        if capability == Capability::Pointer && self.themed_pointer.is_none() {
            println!("Set pointer capability");
            println!("Creating pointer theme");
            let surface = self.compositor_state.create_surface(qh);
            let themed_pointer = self
                .seat_state
                .get_pointer_with_theme(
                    qh,
                    &seat,
                    self.shm_state.wl_shm(),
                    surface,
                    ThemeSpec::default(),
                )
                .expect("Failed to create pointer");
            self.themed_pointer.replace(themed_pointer);
        }
    }

    fn remove_capability(
        &mut self,
        _conn: &Connection,
        _: &QueueHandle<Self>,
        _: wl_seat::WlSeat,
        capability: Capability,
    ) {
        if capability == Capability::Pointer && self.themed_pointer.is_some() {
            println!("Unset pointer capability");
            self.themed_pointer.take().unwrap().pointer().release();
        }
    }

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

impl PointerHandler for SimpleWindow {
    fn pointer_frame(
        &mut self,
        _conn: &Connection,
        _qh: &QueueHandle<Self>,
        pointer: &wl_pointer::WlPointer,
        events: &[PointerEvent],
    ) {
        use PointerEventKind::*;
        for event in events {
            let (x, y) = event.position;
            match event.kind {
                Enter { .. } => {
                    self.set_cursor = true;
                    self.cursor_icon = self
                        .window_frame
                        .as_mut()
                        .and_then(|frame| {
                            frame.click_point_moved(Duration::ZERO, &event.surface.id(), x, y)
                        })
                        .unwrap_or(CursorIcon::Crosshair)
                        .to_owned();

                    if &event.surface == self.window.wl_surface() {
                        println!("Pointer entered @{:?}", event.position);
                    }
                }
                Leave { .. } => {
                    if &event.surface != self.window.wl_surface() {
                        if let Some(window_frame) = self.window_frame.as_mut() {
                            window_frame.click_point_left();
                        }
                    }
                    println!("Pointer left");
                }
                Motion { time } => {
                    if let Some(new_cursor) = self.window_frame.as_mut().and_then(|frame| {
                        frame.click_point_moved(
                            Duration::from_millis(time as u64),
                            &event.surface.id(),
                            x,
                            y,
                        )
                    }) {
                        self.set_cursor = true;
                        self.cursor_icon = new_cursor.to_owned();
                    }
                }
                Press {
                    button,
                    serial,
                    time,
                }
                | Release {
                    button,
                    serial,
                    time,
                } => {
                    let pressed = if matches!(event.kind, Press { .. }) {
                        true
                    } else {
                        false
                    };
                    if &event.surface != self.window.wl_surface() {
                        let click = match button {
                            0x110 => FrameClick::Normal,
                            0x111 => FrameClick::Alternate,
                            _ => continue,
                        };

                        if let Some(action) = self.window_frame.as_mut().and_then(|frame| {
                            frame.on_click(Duration::from_millis(time as u64), click, pressed)
                        }) {
                            self.frame_action(pointer, serial, action);
                        }
                    } else if pressed {
                        println!("Press {:x} @ {:?}", button, event.position);

                        // Hide/Show titlebar on right click
                        if button == 0x111 {
                            self.hide_titlebar = !self.hide_titlebar;

                            if let Some(frame) = self.window_frame.as_mut() {
                                // FrameConfig::auto() is not free, this shouldn't be called here
                                let config = FrameConfig::auto();

                                if self.hide_titlebar {
                                    frame.set_config(config.hide_titlebar(true));
                                    self.window.xdg_surface().set_window_geometry(
                                        0,
                                        0,
                                        self.width.get() as i32,
                                        self.height.get() as i32,
                                    );
                                } else {
                                    let (width, height) = (self.width, self.height);

                                    frame.set_config(config.hide_titlebar(false));
                                    frame.resize(width, height);

                                    let (x, y) = frame.location();
                                    let outer_size = frame.add_borders(width.get(), height.get());
                                    self.window.xdg_surface().set_window_geometry(
                                        x,
                                        y,
                                        outer_size.0 as i32,
                                        outer_size.1 as i32,
                                    );

                                    // Update new width and height;
                                    self.width = width;
                                    self.height = height;
                                }
                            }
                        } else {
                            self.shift = self.shift.xor(Some(0));
                        }
                    }
                }
                Axis {
                    horizontal,
                    vertical,
                    ..
                } => {
                    if &event.surface == self.window.wl_surface() {
                        println!("Scroll H:{horizontal:?}, V:{vertical:?}");
                    }
                }
            }
        }
    }

pub fn light() -> Self

This is equivalent of calling FrameConfig::new(ColorTheme::light()).

For details see ColorTheme::light.

pub fn dark() -> Self

This is equivalent of calling FrameConfig::new(ColorTheme::dark()).

For details see ColorTheme::dark.

pub fn hide_titlebar(self, hide: bool) -> Self

Draw decorations but without the titlebar

Examples found in repository

examples/window.rs (line 256)

    fn configure(
        &mut self,
        conn: &Connection,
        qh: &QueueHandle<Self>,
        window: &Window,
        configure: WindowConfigure,
        _serial: u32,
    ) {
        self.buffer = None;

        println!(
            "Configure size {:?}, decorations: {:?}",
            configure.new_size, configure.decoration_mode
        );

        let (width, height) = if configure.decoration_mode == DecorationMode::Client {
            let window_frame = self.window_frame.get_or_insert_with(|| {
                let mut frame = AdwaitaFrame::new(
                    &self.window,
                    &self.shm_state,
                    self.compositor_state.clone(),
                    self.subcompositor_state.clone(),
                    qh.clone(),
                    FrameConfig::auto().hide_titlebar(self.hide_titlebar),
                )
                .expect("failed to create client side decorations frame.");
                frame.set_title(self.title.clone());
                frame
            });

            // Un-hide the frame.
            window_frame.set_hidden(false);

            // Configure state before touching any resizing.
            window_frame.update_state(configure.state);

            // Configure the button state.
            window_frame.update_wm_capabilities(configure.capabilities);

            let (width, height) = match configure.new_size {
                (Some(width), Some(height)) => {
                    // The size could be 0.
                    window_frame.subtract_borders(width, height)
                }
                _ => {
                    // You might want to consider checking for configure bounds.
                    (Some(self.width), Some(self.height))
                }
            };

            // Clamp the size to at least one pixel.
            let width = width.unwrap_or(NonZeroU32::new(1).unwrap());
            let height = height.unwrap_or(NonZeroU32::new(1).unwrap());

            window_frame.resize(width, height);

            let (x, y) = window_frame.location();
            let outer_size = window_frame.add_borders(width.get(), height.get());
            window.xdg_surface().set_window_geometry(
                x,
                y,
                outer_size.0 as i32,
                outer_size.1 as i32,
            );

            (width, height)
        } else {
            // Hide the frame, if any.
            if let Some(frame) = self.window_frame.as_mut() {
                frame.set_hidden(true)
            }
            let width = configure.new_size.0.unwrap_or(self.width);
            let height = configure.new_size.1.unwrap_or(self.height);
            self.window.xdg_surface().set_window_geometry(
                0,
                0,
                width.get() as i32,
                height.get() as i32,
            );
            (width, height)
        };

        // Update new width and height;
        self.width = width;
        self.height = height;

        // Initiate the first draw.
        if self.first_configure {
            self.first_configure = false;
            self.draw(conn, qh);
        }
    }
}

impl SeatHandler for SimpleWindow {
    fn seat_state(&mut self) -> &mut SeatState {
        &mut self.seat_state
    }

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

    fn new_capability(
        &mut self,
        _conn: &Connection,
        qh: &QueueHandle<Self>,
        seat: wl_seat::WlSeat,
        capability: Capability,
    ) {
        if capability == Capability::Pointer && self.themed_pointer.is_none() {
            println!("Set pointer capability");
            println!("Creating pointer theme");
            let surface = self.compositor_state.create_surface(qh);
            let themed_pointer = self
                .seat_state
                .get_pointer_with_theme(
                    qh,
                    &seat,
                    self.shm_state.wl_shm(),
                    surface,
                    ThemeSpec::default(),
                )
                .expect("Failed to create pointer");
            self.themed_pointer.replace(themed_pointer);
        }
    }

    fn remove_capability(
        &mut self,
        _conn: &Connection,
        _: &QueueHandle<Self>,
        _: wl_seat::WlSeat,
        capability: Capability,
    ) {
        if capability == Capability::Pointer && self.themed_pointer.is_some() {
            println!("Unset pointer capability");
            self.themed_pointer.take().unwrap().pointer().release();
        }
    }

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

impl PointerHandler for SimpleWindow {
    fn pointer_frame(
        &mut self,
        _conn: &Connection,
        _qh: &QueueHandle<Self>,
        pointer: &wl_pointer::WlPointer,
        events: &[PointerEvent],
    ) {
        use PointerEventKind::*;
        for event in events {
            let (x, y) = event.position;
            match event.kind {
                Enter { .. } => {
                    self.set_cursor = true;
                    self.cursor_icon = self
                        .window_frame
                        .as_mut()
                        .and_then(|frame| {
                            frame.click_point_moved(Duration::ZERO, &event.surface.id(), x, y)
                        })
                        .unwrap_or(CursorIcon::Crosshair)
                        .to_owned();

                    if &event.surface == self.window.wl_surface() {
                        println!("Pointer entered @{:?}", event.position);
                    }
                }
                Leave { .. } => {
                    if &event.surface != self.window.wl_surface() {
                        if let Some(window_frame) = self.window_frame.as_mut() {
                            window_frame.click_point_left();
                        }
                    }
                    println!("Pointer left");
                }
                Motion { time } => {
                    if let Some(new_cursor) = self.window_frame.as_mut().and_then(|frame| {
                        frame.click_point_moved(
                            Duration::from_millis(time as u64),
                            &event.surface.id(),
                            x,
                            y,
                        )
                    }) {
                        self.set_cursor = true;
                        self.cursor_icon = new_cursor.to_owned();
                    }
                }
                Press {
                    button,
                    serial,
                    time,
                }
                | Release {
                    button,
                    serial,
                    time,
                } => {
                    let pressed = if matches!(event.kind, Press { .. }) {
                        true
                    } else {
                        false
                    };
                    if &event.surface != self.window.wl_surface() {
                        let click = match button {
                            0x110 => FrameClick::Normal,
                            0x111 => FrameClick::Alternate,
                            _ => continue,
                        };

                        if let Some(action) = self.window_frame.as_mut().and_then(|frame| {
                            frame.on_click(Duration::from_millis(time as u64), click, pressed)
                        }) {
                            self.frame_action(pointer, serial, action);
                        }
                    } else if pressed {
                        println!("Press {:x} @ {:?}", button, event.position);

                        // Hide/Show titlebar on right click
                        if button == 0x111 {
                            self.hide_titlebar = !self.hide_titlebar;

                            if let Some(frame) = self.window_frame.as_mut() {
                                // FrameConfig::auto() is not free, this shouldn't be called here
                                let config = FrameConfig::auto();

                                if self.hide_titlebar {
                                    frame.set_config(config.hide_titlebar(true));
                                    self.window.xdg_surface().set_window_geometry(
                                        0,
                                        0,
                                        self.width.get() as i32,
                                        self.height.get() as i32,
                                    );
                                } else {
                                    let (width, height) = (self.width, self.height);

                                    frame.set_config(config.hide_titlebar(false));
                                    frame.resize(width, height);

                                    let (x, y) = frame.location();
                                    let outer_size = frame.add_borders(width.get(), height.get());
                                    self.window.xdg_surface().set_window_geometry(
                                        x,
                                        y,
                                        outer_size.0 as i32,
                                        outer_size.1 as i32,
                                    );

                                    // Update new width and height;
                                    self.width = width;
                                    self.height = height;
                                }
                            }
                        } else {
                            self.shift = self.shift.xor(Some(0));
                        }
                    }
                }
                Axis {
                    horizontal,
                    vertical,
                    ..
                } => {
                    if &event.surface == self.window.wl_surface() {
                        println!("Scroll H:{horizontal:?}, V:{vertical:?}");
                    }
                }
            }
        }
    }

Trait Implementations

impl Clone for FrameConfig

fn clone(&self) -> FrameConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FrameConfig

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

Formats the value using the given formatter.