Struct sctk_adwaita::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 230-237)

    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(),
                )
                .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.

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.