Struct WindowConfig 

pub struct WindowConfig { /* private fields */ }

Window configuration for run_windowed / run_app.

Renderer-agnostic: pixel dimensions, not grid/font/scale. Use fit to derive the pixel size from a presenter’s own cell geometry.

Several builder methods below (resizable, decorations, transparency, fullscreen) target an OS-level window control that a wasm32 canvas doesn’t have; on that target winit’s web backend either ignores the value outright or can’t reliably apply it (see each method for which, and why). The value is still applied for source-level parity with native either way, so the same call chain compiles and runs on both targets, it just may not visibly do anything in the browser.

Implementations

impl WindowConfig

pub fn fit<P: Presenter>( presenter: &P, title: impl Into<String>, target_fps: Option<u32>, event_driven: bool, ) -> Self

Size the window to exactly fit presenter’s grid: cols x cell_w by rows x cell_h physical pixels.

This is why renderer crates don’t need their own windowing code: the grid/cell geometry already lives behind Output::size and Presenter::cell_size.

target_fps and event_driven are independent controls, on native and wasm32 alike:

• target_fps is the frame-rate cap applied whenever a frame is actually rendered: None is uncapped (render as fast as the loop reaches a redraw), Some(fps) paces redraws to no more than fps per second.
• event_driven picks between the two redraw-triggering modes:
  • true is redraw-on-demand: a frame is rendered only after something happened (an input or window event, an injected Event::Custom, window creation), and the loop sleeps otherwise. Right for event-driven retro/terminal UIs, which are idle most of the time; wrong for anything that animates from Frame::delta, which will render one frame and then sit still until the next stray event.
  • false is continuous: a frame is rendered every tick whether or not anything happened, which is what a retroglyph_ui::Tween/ FrameClock-driven app needs.

The two combine independently: (Some(fps), false) is the common capped-animation shape (see Self::animated for a shorthand), (None, true) is the common idle-UI shape, and (None, false) (render every tick, uncapped) is the one combination that was previously inexpressible, useful for e.g. measuring a render loop’s raw throughput.

On wasm32 the browser owns frame pacing: winit’s web backend delivers each requested redraw on the next requestAnimationFrame, so an uncapped or event_driven: false loop still runs at the display refresh rate and target_fps’s specific number is advisory (there is no way to render faster than requestAnimationFrame, and rendering slower would mean discarding frames the browser already scheduled). Only the event_driven choice carries across unaffected.

pub fn title(&self) -> &str

The window title, as set by fit.

pub const fn width(&self) -> u32

Initial inner width in physical pixels, as computed by fit.

pub const fn height(&self) -> u32

Initial inner height in physical pixels, as computed by fit.

pub fn animated<P: Presenter>( presenter: &P, title: impl Into<String>, fps: u32, ) -> Self

Shorthand for fit with continuous, non-event-driven, fps-capped redraws: the shape most animated apps want. Equivalent to Self::fit(presenter, title, Some(fps), false).

pub const fn target_fps(&self) -> Option<u32>

The frame-rate cap passed to fit; see its doc comment for what None vs. Some(fps) means and how it combines with event_driven.

pub const fn event_driven(&self) -> bool

The redraw-triggering mode passed to fit; see its doc comment for what true vs. false means and how it combines with target_fps.

pub const fn fill_viewport(self, fill_viewport: bool) -> Self

Sets whether to size (and keep resizing) the canvas to fill the browser viewport on wasm32, instead of the pixel size fit computed: a full-screen, mobile-web-app feel for games that want it. Has no effect on native, where the OS window is already sized by fit and the window manager owns further resizing either way.

Defaults to false: most demos/examples should render at their natural grid size (cols x cell_w by rows x cell_h) wherever they land on the page, not stretch to fill whatever viewport happens to be hosting them. Opt in explicitly for an app-like, full-screen game.

pub const fn resizable(self, resizable: bool) -> Self

Sets whether the window can be resized by the user/window manager after creation.

Defaults to true (winit’s own default). Set to false for fixed-size retro windows where the grid is meant to stay put: resizing a pseudo-graphic UI usually means picking a new grid size, not stretching cells, and most callers that care already size the window to their content via fit.

On wasm32, winit’s web backend ignores this: there is no OS-level resize grip on a canvas.

pub const fn decorations(self, decorations: bool) -> Self

Sets whether the window has OS chrome: title bar, borders, close/minimize/maximize buttons.

Defaults to true (winit’s own default). Set to false for a borderless window (custom-drawn title bars, retro full-bleed layouts).

On wasm32, winit’s web backend ignores this: a canvas has no OS chrome to begin with.

pub const fn min_size(self, width: u32, height: u32) -> Self

Sets the minimum inner (content) size in physical pixels.

Defaults to no minimum.

pub const fn max_size(self, width: u32, height: u32) -> Self

Sets the maximum inner (content) size in physical pixels.

Defaults to no maximum.

pub const fn initial_position(self, x: i32, y: i32) -> Self

Sets the desired initial outer window position in physical pixels.

Defaults to letting the platform choose.

On wasm32, winit’s web backend maps this to the canvas’s position: absolute left/top, which only does anything if the page’s CSS has already opted the canvas into absolute/relative positioning; otherwise normal document flow overrides it.

pub const fn fullscreen(self, fullscreen: bool) -> Self

Sets whether to request borderless fullscreen (on the window’s current monitor) at creation.

Defaults to false. This only exposes borderless fullscreen, not winit’s exclusive-fullscreen video-mode API: retro/terminal-style apps render a fixed cell grid, not a resolution-dependent 3D scene, so there is no benefit to an exclusive video-mode switch, only extra platform-specific complexity (enumerating VideoModeHandles) for a mode real games would rarely want here.

On wasm32, winit’s web backend maps this to the browser’s Fullscreen API (Element.requestFullscreen), which most browsers refuse to grant without a user gesture; requesting it unconditionally at window-creation time (before any gesture) is liable to silently fail there.

pub const fn transparency(self, transparency: bool) -> Self

Sets whether the window’s background supports transparency (alpha blending with whatever is behind it).

Defaults to false (winit’s own default).

On wasm32, winit’s web backend ignores this: a canvas is already alpha-blended with the page behind it via normal CSS compositing.