Struct cushy::window::Window

pub struct Window<Behavior = WidgetInstance>
where
    Behavior: WindowBehavior,
{
    pub title: Value<String>,
    pub theme: Value<ThemePair>,
    pub load_system_fonts: bool,
    pub serif_font_family: FontFamilyList,
    pub sans_serif_font_family: FontFamilyList,
    pub fantasy_font_family: FontFamilyList,
    pub monospace_font_family: FontFamilyList,
    pub cursive_font_family: FontFamilyList,
    pub fonts: FontCollection,
    pub vsync: bool,
    pub multisample_count: NonZeroU32,
    pub resize_to_fit: Value<bool>,
    /* private fields */
}

A Cushy window that is not yet running.

Fields

title: Value<String>

The title to display in the title bar of the window.

theme: Value<ThemePair>

The colors to use to theme the user interface.

load_system_fonts: bool

When true, the system fonts will be loaded into the font database. This is on by default.

serif_font_family: FontFamilyList

The list of font families to try to find when a FamilyOwned::Serif font is requested.

sans_serif_font_family: FontFamilyList

The list of font families to try to find when a FamilyOwned::SansSerif font is requested.

fantasy_font_family: FontFamilyList

The list of font families to try to find when a FamilyOwned::Fantasy font is requested.

monospace_font_family: FontFamilyList

The list of font families to try to find when a FamilyOwned::Monospace font is requested.

cursive_font_family: FontFamilyList

The list of font families to try to find when a FamilyOwned::Cursive font is requested.

fonts: FontCollection

A collection of fonts that this window will load.

vsync: bool

When true, Cushy will try to use “vertical sync” to try to eliminate graphical tearing that can occur if the graphics card has a new frame presented while the monitor is currently rendering another frame.

Under the hood, Cushy uses wgpu::PresentMode::AutoVsync when true and wgpu::PresentMode::AutoNoVsync when false.

multisample_count: NonZeroU32

The number of samples to perform for each pixel rendered to the screen. When 1, multisampling is disabled.

resize_to_fit: Value<bool>

Resizes the window to fit the contents if true.

Implementations

impl Window

pub fn for_widget<W>(widget: W) -> Self

where W: MakeWidget,

Returns a new instance using widget as its contents.

impl<Behavior> Window<Behavior>

where Behavior: WindowBehavior,

pub fn new(context: Behavior::Context) -> Self

Returns a new instance using context to initialize the window upon opening.

pub const fn handle(&self) -> &WindowHandle

Returns the handle to this window.

pub fn open_centered<App>(self, app: &mut App) -> Result<WindowHandle>

where App: Application + ?Sized,

Opens self in the center of the monitor the window initially appears on.

pub fn focused(self, focused: impl IntoValue<bool>) -> Self

Sets focused to be the dynamic updated when this window’s focus status is changed.

When the window is focused for user input, the dynamic will contain true.

The current value of focused will inform the OS whether the window should be activated upon opening.

pub fn occluded(self, occluded: impl IntoDynamic<bool>) -> Self

Sets occluded to be the dynamic updated when this window’s occlusion status is changed.

When the window is occluded (completely hidden/offscreen/minimized), the dynamic will contain true. If the window is at least partially visible, this value will contain true.

pub fn fullscreen(self, fullscreen: impl IntoValue<Option<Fullscreen>>) -> Self

Sets the full screen mode for this window.

pub fn inner_size(self, inner_size: impl IntoDynamic<Size<UPx>>) -> Self

Sets inner_size to be the dynamic synchronized with this window’s inner size.

When the window is resized, the dynamic will contain its new size. When the dynamic is updated with a new value, a resize request will be made with the new inner size.

pub fn outer_size(self, outer_size: impl IntoDynamic<Size<UPx>>) -> Self

Sets outer_size to be a dynamic synchronized with this window’s size, including decorations.

When the window is resized, the dynamic will contain its new size. Setting this dynamic with a new value does not change the window in any way. To resize the window, use inner_size.

pub fn outer_position( self, position: impl IntoValue<Point<Px>>, automatic_layout: bool, ) -> Self

Sets position to be a dynamic synchronized with this window’s outer position.

If automatic_layout is true, the initial value of position will be ignored and the window server will control the window’s initial position.

When the window is moved, this dynamic will contain its new position. Setting this dynamic will attempt to move the window to the provided location.

pub fn inner_position(self, position: impl IntoDynamic<Point<Px>>) -> Self

Sets position to be a dynamic synchronized with this window’s inner position.

When the window is moved, this dynamic will contain its new position. Setting this dynamic to a new value has no effect. To move a window, use outer_position.

pub fn resize_to_fit(self, resize_to_fit: impl IntoValue<bool>) -> Self

Resizes this window to fit the contents when resize_to_fit is true.

pub fn content_protected(self, protected: impl IntoValue<bool>) -> Self

Prevents the window contents from being captured by other apps.

pub fn cursor_hittest(self, hittest: impl IntoValue<bool>) -> Self

Controls whether the cursor should interact with this window or not.

pub fn cursor_visible(self, visible: impl IntoValue<bool>) -> Self

Sets whether the cursor is visible when above this window.

pub fn cursor_position( self, window_position: impl IntoDynamic<Point<Px>>, ) -> Self

A dynamic providing access to the window coordinate of the cursor, or -1, -1 if the cursor is not currently hovering the window.

In the future, this dynamic will also support setting the position of the cursor within the window.

pub fn decorated(self, decorated: impl IntoValue<bool>) -> Self

Controls whether window decorations are shown around this window.

pub fn enabled_buttons(self, buttons: impl IntoValue<WindowButtons>) -> Self

Sets the enabled buttons for this window.

pub fn window_level(self, window_level: impl IntoValue<WindowLevel>) -> Self

Controls the level of this window.

pub fn minimized(self, minimized: impl IntoDynamic<bool>) -> Self

Provides a dynamic that is updated with the minimized status of this window.

pub fn maximized(self, maximized: impl IntoDynamic<bool>) -> Self

Provides a dynamic that is updated with the maximized status of this window.

pub fn resizable(self, resizable: impl IntoValue<bool>) -> Self

Controls whether the window is resizable by the user or not.

pub fn resize_increments( self, resize_increments: impl IntoValue<Size<UPx>>, ) -> Self

Controls the increments in which the window can be resized.

pub fn transparent(self) -> Self

Sets this window to render with a transparent background.

pub fn visible(self, visible: impl IntoDynamic<bool>) -> Self

Controls the visibility of this window.

pub fn zoom(self, zoom: impl IntoDynamic<Fraction>) -> Self

Sets this window’s zoom factor.

The zoom factor is multiplied with the DPI scaling from the window server to allow an additional scaling factor to be applied.

pub fn themed_mode(self, theme_mode: impl IntoValue<ThemeMode>) -> Self

Sets the ThemeMode for this window.

If a ThemeMode is provided, the window will be set to this theme mode upon creation and will not be updated while the window is running.

If a Dynamic is provided, the initial value will be ignored and the dynamic will be updated when the window opens with the user’s current theme mode. The dynamic will also be updated any time the user’s theme mode changes.

Setting the Dynamic’s value will also update the window with the new mode until a mode change is detected, upon which the new mode will be stored.

pub fn themed(self, theme: impl IntoValue<ThemePair>) -> Self

Applies theme to the widgets in this window.

pub fn loading_font(self, font_data: Vec<u8>) -> Self

Adds font_data to the list of fonts to load for availability when rendering.

All font families contained in font_data will be loaded.

pub fn on_open<Function>(self, on_open: Function) -> Self

where Function: FnOnce(WindowHandle) + Send + 'static,

Invokes on_open when this window is first opened, even if it is not visible.

pub fn on_init<Function>(self, on_init: Function) -> Self

where Function: FnOnce(&Window) + Send + 'static,

Invokes on_init before the window initialization begins.

pub fn on_close<Function>(self, on_close: Function) -> Self

where Function: FnOnce() + Send + 'static,

Invokes on_close when this window is closed.

pub fn on_close_requested<Function>(self, on_close_requested: Function) -> Self

where Function: FnMut(()) -> bool + Send + 'static,

Invokes on_close_requested when the window is requested to be closed.

If the function returns true, the window is allowed to be closed, otherwise the window remains open.

pub fn on_file_drop<Function>(self, on_file_drop: Function) -> Self

where Function: FnMut(FileDrop) + Send + 'static,

Invokes on_file_drop when a file is hovered or dropped on this window.

pub fn titled(self, title: impl IntoValue<String>) -> Self

Sets the window’s title.

pub fn icon(self, icon: impl IntoValue<Option<RgbaImage>>) -> Self

Sets the window’s icon.

pub fn modifiers(self, modifiers: impl IntoDynamic<Modifiers>) -> Self

Sets modifiers to contain the state of the keyboard modifiers when this window has keyboard focus.

pub fn app_name(self, name: impl Into<String>) -> Self

Sets the name of the application.

• WM_CLASS on X11
• application ID on wayland
• class name on windows

pub fn with_shortcut<F>( self, key: impl Into<ShortcutKey>, modifiers: ModifiersState, callback: F, ) -> Self

where F: FnMut(KeyEvent) -> EventHandling + Send + 'static,

Invokes callback when key is pressed while modifiers are pressed.

Widgets have a chance to handle keyboard input before the Window.

pub fn with_shortcuts(self, shortcuts: impl IntoValue<ShortcutMap>) -> Self

Invokes shortcuts when keyboard input is unhandled in this window.

pub fn with_repeating_shortcut<F>( self, key: impl Into<ShortcutKey>, modifiers: ModifiersState, callback: F, ) -> Self

where F: FnMut(KeyEvent) -> EventHandling + Send + 'static,

Invokes callback when key is pressed while modifiers are pressed. If the shortcut is held, the callback will be invoked on repeat events.

Widgets have a chance to handle keyboard input before the Window.

Trait Implementations

impl<Behavior> Default for Window<Behavior>

where Behavior: WindowBehavior, Behavior::Context: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<Behavior> MakeWindow for Window<Behavior>

where Behavior: WindowBehavior,

type Behavior = Behavior

The behavior associated with this window.

fn make_window(self) -> Window<Self::Behavior>

Returns a new window from self.

fn open_centered<App>(self, app: &mut App) -> Result<WindowHandle>

where Self: Sized, App: Application + ?Sized,

Opens self in the center of the monitor the window initially appears on.

fn run_centered(self) -> Result

where Self: Sized,

Runs self in the center of the monitor the window initially appears on.

fn run_centered_in(self, app: PendingApp) -> Result

where Self: Sized,

Runs app after opening self in the center of the monitor the window initially appears on.

impl<Behavior> Run for Window<Behavior>

where Behavior: WindowBehavior,

fn run(self) -> Result

Runs the provided type, returning Ok(()) upon successful execution and program exit. Note that this function may not ever return on some platforms.