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,
    pub disabled: Color,
    pub danger: Color,
    pub success: 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::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: Color

Foreground for a disabled interactive widget. Distinct from dim: dim marks idle-but-usable text as secondary, while disabled marks a widget the user cannot interact with at all, and the two need to read differently at a glance.

danger: Color

Destructive/error emphasis: delete actions, validation failures, critical alerts.

success: Color

Positive/confirmation emphasis: completed states, successful actions.

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. Delegates to WidgetState::of for the precedence order; see there for why disabled now takes priority over everything else.

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::Theme;
use retroglyph_ui::interact::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. Delegates to WidgetState::of for the precedence order.

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::Theme;
use retroglyph_ui::interact::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. Delegates to WidgetState::of for the precedence order.

Resolves both channels at once against a single, shared precedence order, rather than composing bg_for and fg_for independently: that’s 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 disabled for the disabled foreground, distinct from dim’s idle look.

Examples

use retroglyph_ui::theme::Theme;
use retroglyph_ui::interact::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 Copy for Theme

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 Eq for Theme

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 StructuralPartialEq for Theme