Struct AppTheme 

pub struct AppTheme {

    pub primary: Color,
    pub secondary: Color,
    pub accent: Color,
    pub error: Color,
    pub warning: Color,
    pub success: Color,
    pub info: Color,
    pub text: Color,
    pub text_muted: Color,
    pub selected_text: Color,
    pub background: Color,
    pub background_panel: Color,
    pub background_element: Color,
    pub background_menu: Color,
    pub border: Color,
    pub border_active: Color,
    pub border_subtle: Color,
    pub diff: DiffColors,
    pub markdown: MarkdownColors,
    pub syntax: SyntaxColors,
}

Available on crate feature theme only.

Comprehensive application theme with all widget colors.

This struct provides a complete color scheme for TUI applications, covering all common UI elements and specialized widget colors.

Theme Structure

The theme is organized into:

1. UI Colors - Semantic colors for interactive elements
2. Text Colors - Colors for text content
3. Background Colors - Surface and container backgrounds
4. Border Colors - Border and divider colors
5. Diff Colors - Colors for diff rendering
6. Markdown Colors - Colors for markdown content
7. Syntax Colors - Colors for code syntax highlighting

Loading from JSON

Use AppTheme::from_json or the loader module to load themes from opencode-format JSON files.

Fields

primary: Color

Primary UI color for main interactive elements.

Used for primary buttons, active selections, and key UI elements.

secondary: Color

Secondary UI color for supporting elements.

Used for secondary buttons and less prominent interactive elements.

accent: Color

Accent color for highlighting and emphasis.

Used to draw attention to specific UI elements.

error: Color

Error color for error states and messages.

Used for error indicators, validation errors, and destructive actions.

warning: Color

Warning color for warning states and messages.

Used for warnings and caution indicators.

success: Color

Success color for success states and messages.

Used for success indicators and confirmation feedback.

info: Color

Info color for informational elements.

Used for help text, hints, and informational messages.

text: Color

Primary text color for main content.

The default color for body text and content.

text_muted: Color

Muted text color for secondary content.

Used for less important text, placeholders, and hints.

selected_text: Color

Text color for selected items.

Used for text within selected or highlighted regions.

background: Color

Main background color.

The primary application background.

background_panel: Color

Panel background color.

Used for content panels and cards.

background_element: Color

Element background color.

Used for interactive elements like buttons and inputs.

background_menu: Color

Menu background color.

Used for dropdown menus and popover backgrounds.

border: Color

Default border color.

Used for container borders and dividers.

border_active: Color

Active border color.

Used for focused or active element borders.

border_subtle: Color

Subtle border color.

Used for subtle dividers and less prominent borders.

diff: DiffColors

Colors for diff rendering.

Contains all colors needed for the CodeDiff widget.

markdown: MarkdownColors

Colors for markdown rendering.

Contains all colors needed for the MarkdownWidget.

syntax: SyntaxColors

Colors for syntax highlighting.

Contains all colors needed for code syntax highlighting.

Implementations

impl AppTheme

pub fn from_json(json: &str, variant: ThemeVariant) -> Result<Self, String>

Creates an AppTheme from a JSON string in opencode format.

This parses the JSON, resolves all color references from the defs section, and constructs a complete theme.

Arguments

• json - The JSON string in opencode theme format
• variant - Which theme variant (dark/light) to use

Returns

Ok(AppTheme) if parsing succeeds, Err with a description otherwise.

Errors

Returns an error if:

• The JSON is malformed
• Color values cannot be resolved

Example

use ratatui_toolkit::services::theme::{AppTheme, ThemeVariant};

let json = r#"{
  "defs": { "myBlue": "#0066ff" },
  "theme": { "primary": { "dark": "myBlue", "light": "myBlue" } }
}"#;

let theme = AppTheme::from_json(json, ThemeVariant::Dark)
    .expect("Failed to parse theme");

pub fn from_json_file<P: AsRef<Path>>( path: P, variant: ThemeVariant, ) -> Result<Self, String>

Creates an AppTheme from a JSON file path.

Reads the file and parses it as an opencode theme.

Arguments

• path - Path to the JSON theme file
• variant - Which theme variant (dark/light) to use

Returns

Ok(AppTheme) if the file can be read and parsed, Err with a description otherwise.

Errors

Returns an error if:

• The file cannot be read
• The JSON is malformed
• Color values cannot be resolved

Example

use ratatui_toolkit::services::theme::{AppTheme, ThemeVariant};

let theme = AppTheme::from_json_file("themes/gruvbox.json", ThemeVariant::Dark)
    .expect("Failed to load theme");

impl AppTheme

pub fn new( primary: Color, secondary: Color, accent: Color, error: Color, warning: Color, success: Color, info: Color, text: Color, text_muted: Color, selected_text: Color, background: Color, background_panel: Color, background_element: Color, background_menu: Color, border: Color, border_active: Color, border_subtle: Color, diff: DiffColors, markdown: MarkdownColors, syntax: SyntaxColors, ) -> Self

Creates a new AppTheme with all colors specified.

This is a low-level constructor that requires all colors to be provided. For most use cases, prefer AppTheme::default() or AppTheme::from_json().

Arguments

• primary - Primary UI color
• secondary - Secondary UI color
• accent - Accent color
• error - Error color
• warning - Warning color
• success - Success color
• info - Info color
• text - Primary text color
• text_muted - Muted text color
• selected_text - Selected text color
• background - Main background color
• background_panel - Panel background color
• background_element - Element background color
• background_menu - Menu background color
• border - Default border color
• border_active - Active border color
• border_subtle - Subtle border color
• diff - Diff colors
• markdown - Markdown colors
• syntax - Syntax colors

Returns

A new AppTheme instance with all colors configured.

Example

use ratatui::style::Color;
use ratatui_toolkit::services::theme::{AppTheme, DiffColors, MarkdownColors, SyntaxColors};

let theme = AppTheme::new(
    Color::Blue, Color::Magenta, Color::Cyan,
    Color::Red, Color::Yellow, Color::Green, Color::LightBlue,
    Color::White, Color::Gray, Color::White,
    Color::Black, Color::DarkGray, Color::DarkGray, Color::DarkGray,
    Color::Gray, Color::White, Color::DarkGray,
    DiffColors::default(),
    MarkdownColors::default(),
    SyntaxColors::default(),
);

impl AppTheme

pub fn get_color(&self, name: &str) -> Option<Color>

Gets a semantic color by name.

This method allows looking up theme colors by their semantic name, which is useful for dynamic color resolution from configuration.

Arguments

• name - The semantic name of the color (e.g., “primary”, “error”)

Returns

Some(Color) if the name matches a known semantic color, None otherwise.

Supported Names

• UI: primary, secondary, accent, error, warning, success, info
• Text: text, text_muted, selected_text
• Background: background, background_panel, background_element, background_menu
• Border: border, border_active, border_subtle

Example

use ratatui_toolkit::services::theme::AppTheme;

let theme = AppTheme::default();
let primary = theme.get_color("primary");
assert!(primary.is_some());

Trait Implementations

impl Clone for AppTheme

fn clone(&self) -> AppTheme

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AppTheme

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

Formats the value using the given formatter.

impl Default for AppTheme

fn default() -> Self

Creates a default application theme based on the Gruvbox dark theme.

This provides a cohesive dark theme that works well in most terminals and provides good contrast and readability.

Returns

An AppTheme instance with Gruvbox dark colors.

impl PartialEq for AppTheme

fn eq(&self, other: &AppTheme) -> 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 Eq for AppTheme

impl StructuralPartialEq for AppTheme