Struct AdwaitaFrame 

pub struct AdwaitaFrame<State> { /* private fields */ }

A simple set of decorations

Implementations

impl<State> AdwaitaFrame<State>

where State: Dispatch<WlSurface, SurfaceData> + Dispatch<WlSubsurface, SubsurfaceData> + 'static,

pub fn new( base_surface: &impl WaylandSurface, shm: &Shm, compositor: Arc<CompositorState>, subcompositor: Arc<SubcompositorState>, queue_handle: QueueHandle<State>, frame_config: FrameConfig, ) -> Result<Self, Box<dyn Error>>

Examples found in repository

examples/window.rs (lines 250-257)

    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);
        }
    }

pub fn set_config(&mut self, config: FrameConfig)

Update the current frame config.

Examples found in repository

examples/window.rs (line 462)

    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<State: Debug> Debug for AdwaitaFrame<State>

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

Formats the value using the given formatter.

impl<State> DecorationsFrame for AdwaitaFrame<State>

where State: Dispatch<WlSurface, SurfaceData> + Dispatch<WlSubsurface, SubsurfaceData> + 'static,

fn update_state(&mut self, state: WindowState)

Update the state of the frame.

fn update_wm_capabilities(&mut self, wm_capabilities: WindowManagerCapabilities)

Update the window manager capabilites.

fn set_hidden(&mut self, hidden: bool)

Set the frame as hidden.

fn set_resizable(&mut self, resizable: bool)

Mark the frame as resizable.

fn resize(&mut self, width: NonZeroU32, height: NonZeroU32)

Resize the window to the new size.

fn draw(&mut self) -> bool

Draw the decorations frame.

fn subtract_borders( &self, width: NonZeroU32, height: NonZeroU32, ) -> (Option<NonZeroU32>, Option<NonZeroU32>)

Subtract the borders from the given width and height.

fn add_borders(&self, width: u32, height: u32) -> (u32, u32)

Add the borders to the given width and height.

fn location(&self) -> (i32, i32)

Return the coordinates of the top-left corner of the borders relative to the content.

fn set_title(&mut self, title: impl Into<String>)

Set the frames title.

fn on_click( &mut self, timestamp: Duration, click: FrameClick, pressed: bool, ) -> Option<FrameAction>

Emulate click on the decorations.

fn set_scaling_factor(&mut self, scale_factor: f64)

Set the scaling of the decorations frame.

fn click_point_moved( &mut self, _timestamp: Duration, surface: &ObjectId, x: f64, y: f64, ) -> Option<CursorIcon>

Emulate pointer moved event on the decorations frame.

fn click_point_left(&mut self)

All clicks left the decorations.

fn is_dirty(&self) -> bool

Whether the given frame is dirty and should be redrawn.

fn is_hidden(&self) -> bool

Get the frame hidden state.