Struct sctk_adwaita::FrameConfig

pub struct FrameConfig {
    pub theme: ColorTheme,
}

The configuration for the AdwaitaFrame frame.

Fields

theme: ColorTheme

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 254)

    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 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.

Trait Implementations

impl Clone for FrameConfig

fn clone(&self) -> FrameConfig

Returns a copy 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.