Struct Theme 

pub struct Theme {
    pub bg: Color,
    pub panel_bg: Color,
    pub border: Color,
    pub title_bg: Color,
    pub fg: Color,
    pub accent: Color,
    pub hover_bg: Color,
    pub press_bg: Color,
    pub dim: Color,
}

A palette of named color roles, rather than a CSS-style cascade: draw code picks the role it means (theme.accent, theme.border) and the active Theme decides what color that resolves to.

This crate has no opinion on how an app picks between DARK and LIGHT (a manual toggle key, a SystemTheme from Event::ThemeChanged, or just always the same one): it only owns the two palettes themselves, so an app doesn’t have to invent one from scratch.

Examples

use retroglyph_ui::Theme;

let theme = Theme::DARK;
assert_eq!(theme.fg, Theme::DARK.fg);
assert_ne!(theme.bg, Theme::LIGHT.bg);

Fields

bg: Color

The window/screen background, behind every panel.

panel_bg: Color

A panel’s own background, layered over bg.

border: Color

Panel borders and dividers.

title_bg: Color

A panel title bar’s background.

fg: Color

Default (non-emphasized) text.

accent: Color

Emphasis: selection, focus rings, primary actions.

hover_bg: Color

An interactive widget’s background while hovered.

press_bg: Color

An interactive widget’s background while pressed.

dim: Color

De-emphasized text (hints, secondary labels, disabled-looking text).

Implementations

impl Theme

pub const DARK: Self

A dark palette: light text on a near-black background.

pub const LIGHT: Self

A light palette: dark text on a near-white background. Same role relationships as DARK (accent stays a legible blue, hover_bg/press_bg stay a step apart from panel_bg), inverted for contrast against a light background rather than just flipping each channel.

Contrast is higher than a typical OS light theme: retroglyph’s pseudo-graphics (gauges, progress bars, log lines) draw with a 2-color paletted look where every panel-bg/border/text pair has to be distinct at a glance with no sub-pixel anti-aliasing to soften the edges.

pub const fn bg_for<Id>(&self, response: &Response<Id>, base: Color) -> Color

The background for an interactive widget in response’s current state, over base when idle. Precedence: pressed, then hovered, then base.

base is caller-supplied rather than defaulted to panel_bg so this composes with widgets that already take a backdrop, e.g. a bar drawn over title_bg instead of a panel.

Examples

use retroglyph_ui::Theme;
use retroglyph_ui::Interaction;
use retroglyph_core::grid::{Pos, Rect};

let theme = Theme::DARK;
let mut interaction = Interaction::<u32>::default();
let response = interaction.interact(Rect::new(0, 0, 1, 1), 1, Default::default());
assert_eq!(theme.bg_for(&response, theme.panel_bg), theme.panel_bg);

pub const fn fg_for<Id>(&self, response: &Response<Id>) -> Color

The foreground for an interactive widget in response’s current state. Precedence: pressed or focused, then hovered, then dim.

Idle interactive text reads as dim rather than fg: an interactive widget that looks identical to static text at rest gives no visual hint that it’s interactive at all, so the state that actually needs fg’s full contrast is hover, not idle.

Examples

use retroglyph_ui::Theme;
use retroglyph_ui::Interaction;
use retroglyph_core::grid::{Pos, Rect};

let theme = Theme::DARK;
let mut interaction = Interaction::<u32>::default();
let response = interaction.interact(Rect::new(0, 0, 1, 1), 1, Default::default());
assert_eq!(theme.fg_for(&response), theme.dim);

pub fn style_for<Id>(&self, response: &Response<Id>, base: Color) -> Style

The resolved Style for an interactive widget in response’s current state, over base when idle. Precedence: disabled, then pressed, then focused, then hovered, then idle.

Unlike bg_for/fg_for, which resolve each channel independently, style_for resolves both at once against a single, shared precedence order: that’s the only place disabled can cleanly take priority over everything else, and the only place a press (accent on press_bg) and a focus ring (accent on base, no background change) can be told apart instead of both collapsing into the same accent foreground.

base is caller-supplied for the same reason as bg_for: so this composes with widgets that already have their own backdrop.

This uses dim for the disabled foreground, same as idle; retroglyph has no separate disabled color role yet.

Examples

use retroglyph_ui::Theme;
use retroglyph_ui::Interaction;
use retroglyph_core::grid::{Pos, Rect};

let theme = Theme::DARK;
let mut interaction = Interaction::<u32>::default();
let response = interaction.interact(Rect::new(0, 0, 1, 1), 1, Default::default());
let style = theme.style_for(&response, theme.panel_bg);
assert_eq!(style.foreground(), theme.dim);
assert_eq!(style.background(), theme.panel_bg);

Trait Implementations

impl Clone for Theme

fn clone(&self) -> Theme

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Theme

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Theme

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Theme

fn eq(&self, other: &Theme) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Theme

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Theme

impl Eq for Theme

impl StructuralPartialEq for Theme