Struct Style 

pub struct Style {

    pub fg: Option<Color>,
    pub bg: Option<Color>,
    pub decoration: Option<Vec<Decoration>>,
    pub padding: Option<u8>,
    pub padding_top: Option<u8>,
    pub padding_bottom: Option<u8>,
    pub padding_left: Option<u8>,
    pub padding_right: Option<u8>,
    pub margin: Option<u8>,
    pub margin_top: Option<u8>,
    pub margin_bottom: Option<u8>,
    pub margin_left: Option<u8>,
    pub margin_right: Option<u8>,
    pub border_color: Option<Color>,
    pub border_style: Option<BorderStyle>,
}

Fields

fg: Option<Color>

bg: Option<Color>

decoration: Option<Vec<Decoration>>

padding: Option<u8>

padding_top: Option<u8>

padding_bottom: Option<u8>

padding_left: Option<u8>

padding_right: Option<u8>

margin: Option<u8>

margin_top: Option<u8>

margin_bottom: Option<u8>

margin_left: Option<u8>

margin_right: Option<u8>

border_color: Option<Color>

border_style: Option<BorderStyle>

Implementations

impl Style

pub fn new() -> Self

Creates a new default style.

Examples found in repository

examples/multiple_sources.rs (line 63)

fn main() {
    // Create a new Termio instance
    let mut tcss = Termio::new();

    // Load basic styles from string
    let base_styles = r#"
        @element "base" {
            color: white;
            background: black;
            decoration: bold;
            padding: 1;
        }

        @element "subtle" {
            color: i-black;
            background: black;
            decoration: italic;
        }
    "#;

    // Parse basic styles
    match tcss.parse(base_styles) {
        Ok(_) => println!("Basic styles successfully loaded from string!"),
        Err(e) => {
            eprintln!("Error parsing basic styles: {}", e);
            return;
        }
    }

    // Load additional styles from file
    let additional_styles_path = Path::new("examples/styles.tcss");
    let mut additional_styles = String::new();

    // Read the file
    let mut file = match File::open(&additional_styles_path) {
        Ok(file) => file,
        Err(e) => {
            eprintln!("Failed to open style file: {}", e);
            return;
        }
    };

    if let Err(e) = file.read_to_string(&mut additional_styles) {
        eprintln!("Failed to read style file: {}", e);
        return;
    }

    // Parse additional styles
    match tcss.parse(&additional_styles) {
        Ok(_) => println!("Additional styles successfully loaded from file!"),
        Err(e) => {
            eprintln!("Error parsing additional styles: {}", e);
            return;
        }
    }

    // Add another custom style via API
    let mut custom_style = Style::new();
    custom_style.fg = Some(Color::Magenta);
    custom_style.decoration = Some(vec![Decoration::Bold, Decoration::Underline]);
    custom_style.padding = Some(1);
    custom_style.padding_left = Some(6);
    custom_style.padding_right = Some(6);
    custom_style.border_style = Some(BorderStyle::Rounded);

    // Add style to the parser
    tcss.add_style("custom", custom_style);
    println!("Custom style successfully added via API!");

    let style_from_macros = style! {
        fg: Color::IntenseBlack,
        bg: Color::Black,
        decoration: vec![Decoration::Strikethrough],  
        padding: 1,
        border_style: BorderStyle::Dashed,
    };
    
    tcss.add_style("macros", style_from_macros);
    println!("Macros style successfully added via macros!");

    // Display all styles
    println!("Examples of using styles from different sources:");
    println!("{}", "Base style from string".style("base", &tcss));
    println!("{}", "Subtle style from string".style("subtle", &tcss));
    println!("{}", "Header from file".style("header", &tcss));
    println!("{}", "Warning from file".style("warning", &tcss));
    println!("{}", "Custom style via API".style("custom", &tcss));
    println!("{}", "Macros style".style("macros", &tcss));
}

pub fn fg(self, color: Color) -> Self

Sets the foreground color.

pub fn bg(self, color: Color) -> Self

Sets the background color.

pub fn decoration(self, deco: Vec<Decoration>) -> Self

Sets the text decoration.

pub fn padding(self, pad: u8) -> Self

Sets the padding (spaces inside the border).

pub fn padding_top(self, pad: u8) -> Self

Sets the top padding.

pub fn padding_bottom(self, pad: u8) -> Self

Sets the bottom padding.

pub fn padding_left(self, pad: u8) -> Self

Sets the left padding.

pub fn padding_right(self, pad: u8) -> Self

Sets the right padding.

pub fn margin(self, margin: u8) -> Self

Sets the margin (lines outside the border).

pub fn margin_top(self, margin: u8) -> Self

Sets the top margin.

pub fn margin_bottom(self, margin: u8) -> Self

Sets the bottom margin.

pub fn margin_left(self, margin: u8) -> Self

Sets the left margin.

pub fn margin_right(self, margin: u8) -> Self

Sets the right margin.

pub fn border_color(self, color: Color) -> Self

Sets the border color.

pub fn border_style(self, style: BorderStyle) -> Self

Sets the border style.

Trait Implementations

impl Clone for Style

fn clone(&self) -> Style

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Style

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

Formats the value using the given formatter.

impl Default for Style

fn default() -> Self

Returns the “default value” for a type.