Enum Color 

pub enum Color {
    Black,
    Red,
    Green,
    Yellow,
    Blue,
    Magenta,
    Cyan,
    White,
    Empty,
    RGB(u8, u8, u8),
    Color256(u8),
    HEX(&'static str),
    HSV(u16, u8, u8),
    HSL(u16, u8, u8),
}

Variants

Black

Red

Green

Yellow

Blue

Magenta

Cyan

White

Empty

RGB(u8, u8, u8)

Color256(u8)

HEX(&'static str)

HSV(u16, u8, u8)

HSL(u16, u8, u8)

Implementations

impl Color

pub fn new_rgb(r: u8, g: u8, b: u8) -> Result<Self, ColorError>

Create a new RGB color

Arguments

• r - Red component (0-255)
• g - Green component (0-255)
• b - Blue component (0-255)

Returns

• Ok(Color) - RGB color

Examples

use inksac::Color;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let orange = Color::new_rgb(255, 165, 0)?;
    let purple = Color::new_rgb(128, 0, 128)?;
    Ok(())
}

Examples found in repository

examples/rainbow_text.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let text = "Rainbow Text Example";
    let colors = [
        (255, 0, 0),   // Red
        (255, 127, 0), // Orange
        (255, 255, 0), // Yellow
        (0, 255, 0),   // Green
        (0, 0, 255),   // Blue
        (75, 0, 130),  // Indigo
        (148, 0, 211), // Violet
    ];

    // Print each character with a different color
    for (i, c) in text.chars().enumerate() {
        let color_idx = i % colors.len();
        let (r, g, b) = colors[color_idx];

        let style = Style::builder()
            .foreground(Color::new_rgb(r, g, b)?)
            .bold()
            .build();

        print!("{}", c.to_string().style(style));
    }
    println!();

    Ok(())
}

examples/table.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let header_style = Style::builder()
        .foreground(Color::White)
        .background(Color::Blue)
        .bold()
        .build();

    let alt_row_style = Style::builder()
        .background(Color::new_rgb(240, 240, 240)?)
        .build();

    // Print header
    println!(
        "{}",
        format!("{:<20} {:<15} {:<10}", "Name", "Role", "Status").style(header_style)
    );

    // Print rows
    let data = [
        ("Alice Smith", "Developer", "Active"),
        ("Bob Johnson", "Designer", "Away"),
        ("Carol White", "Manager", "Busy"),
    ];

    for (i, (name, role, status)) in data.iter().enumerate() {
        let row = format!("{:<20} {:<15} {:<10}", name, role, status);
        if i % 2 == 1 {
            println!("{}", row.style(alt_row_style));
        } else {
            println!("{}", row);
        }
    }

    Ok(())
}

examples/progress_bar.rs (line 25)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let total = 50;
    // More vibrant and pleasing colors
    let start_color = (86, 171, 255); // Light blue
    let mid_color = (255, 135, 255); // Pink/Purple
    let end_color = (98, 255, 161); // Mint green

    // Styles for different parts of the progress bar
    let empty_style = Style::builder()
        .foreground(Color::new_rgb(70, 70, 70)?) // Darker gray for empty section
        .build();

    let border_style = Style::builder()
        .foreground(Color::new_rgb(150, 150, 150)?) // Lighter gray for borders
        .bold()
        .build();

    let percent_style = Style::builder().foreground(Color::White).bold().build();

    print!("\n"); // Start with a newline for better spacing

    for i in 0..=total {
        let progress = i as f32 / total as f32;
        let filled = (progress * 30.0) as usize; // Slightly shorter bar
        let empty = 30 - filled;

        // Two-stage color interpolation for smoother gradient
        let (r, g, b) = if progress < 0.5 {
            lerp_color(start_color, mid_color, progress * 2.0)
        } else {
            lerp_color(mid_color, end_color, (progress - 0.5) * 2.0)
        };

        let bar_style = Style::builder()
            .foreground(Color::new_rgb(r, g, b)?)
            .bold()
            .build();

        // Using better characters for the progress bar
        print!("\r  "); // Add some left padding
        print!("{}", "├".style(border_style));
        print!("{}", "━".repeat(filled).style(bar_style));
        print!("{}", "─".repeat(empty).style(empty_style));
        print!("{}", "┤".style(border_style));

        // Percentage with padding to prevent jitter
        print!(
            " {}%",
            format!("{:>3}", (progress * 100.0) as u8).style(percent_style)
        );

        // Existing spinner for visual feedback
        let spinner = match i % 10 {
            0 => "⠋",
            1 => "⠙",
            2 => "⠹",
            3 => "⠸",
            4 => "⠼",
            5 => "⠴",
            6 => "⠦",
            7 => "⠧",
            8 => "⠇",
            9 => "⠏",
            _ => "",
        };
        print!(" {}", spinner.style(bar_style));

        // Added spinning circle indicator on the right
        let circle_spinner = match i % 4 {
            0 => "◐",
            1 => "◓",
            2 => "◑",
            3 => "◒",
            _ => "",
        };
        print!(" {}", circle_spinner.style(bar_style));

        std::io::stdout().flush()?;
        thread::sleep(Duration::from_millis(50));
    }
    println!("\n"); // Add final newlines for spacing

    Ok(())
}

examples/print_color.rs (line 43)

fn print_color_demo() -> Result<(), Box<dyn std::error::Error>> {
    // First, check color support
    let support = check_color_support()?;
    println!("Color Support Level: {}\n", support);

    // Basic colors
    let basic_colors = [
        ("Black", Color::Black),
        ("Red", Color::Red),
        ("Green", Color::Green),
        ("Yellow", Color::Yellow),
        ("Blue", Color::Blue),
        ("Magenta", Color::Magenta),
        ("Cyan", Color::Cyan),
        ("White", Color::White),
    ];

    println!("Basic Colors:");
    for (name, color) in basic_colors {
        let style = Style::builder().foreground(color).bold().build();
        println!("{:<8}: {}", name, "■■■■".style(style));
    }
    println!();

    // RGB Colors (if supported)
    if matches!(support, ColorSupport::TrueColor) {
        println!("RGB Colors:");
        let rgb_colors = [
            (255, 100, 0),
            (100, 255, 0),
            (0, 255, 100),
            (0, 100, 255),
            (100, 0, 255),
            (255, 0, 100),
        ];

        for (r, g, b) in rgb_colors {
            let style = Style::builder()
                .foreground(Color::new_rgb(r, g, b)?)
                .build();
            println!("RGB({}, {}, {}): {}", r, g, b, "■■■■".style(style));
        }
        println!();

        // Color manipulation
        let base_color = Color::new_rgb(255, 100, 0)?;
        println!("Color Manipulation:");
        println!(
            "Original: {}",
            "■■■■".style(Style::builder().foreground(base_color).build())
        );

        let lighter = base_color.lighten(30)?;
        println!(
            "Lighter : {}",
            "■■■■".style(Style::builder().foreground(lighter).build())
        );

        let darker = base_color.darken(30)?;
        println!(
            "Darker  : {}",
            "■■■■".style(Style::builder().foreground(darker).build())
        );
        println!();
    }

    // Text styles
    println!("Text Styles:");
    let text = "Styled Text";

    let bold = Style::builder().bold().build();
    println!("Bold:      {}", text.style(bold));

    let italic = Style::builder().italic().build();
    println!("Italic:    {}", text.style(italic));

    let underline = Style::builder().underline().build();
    println!("Underline: {}", text.style(underline));

    let dim = Style::builder().dim().build();
    println!("Dim:       {}", text.style(dim));

    // Combined styles
    let combined = Style::builder()
        .foreground(Color::Green)
        .background(Color::Black)
        .bold()
        .italic()
        .build();
    println!("\nCombined Styles:");
    println!("{}", "Multiple styles combined!".style(combined));

    Ok(())
}

examples/color_conversion.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Color Conversion Comparison (RGB → 256 → Basic):");
    println!("----------------------------------------------");

    let test_colors = [
        ((0, 0, 0), "Black"),
        ((255, 255, 255), "White"),
        ((128, 128, 128), "Mid Gray"),
        ((255, 0, 0), "Red"),
        ((0, 255, 0), "Green"),
        ((0, 0, 255), "Blue"),
        ((255, 255, 0), "Yellow"),
        ((255, 0, 255), "Magenta"),
        ((0, 255, 255), "Cyan"),
        ((128, 64, 32), "Brown"),
        ((70, 130, 180), "Steel Blue"),
    ];

    for ((r, g, b), name) in test_colors {
        // Original RGB color
        let rgb_style = Style::builder()
            .foreground(Color::new_rgb(r, g, b)?)
            .bold()
            .build();

        // Get the 256-color code
        let code_256 = Color::rgb_to_256(r, g, b);
        let color_256 = Color::Color256(code_256);
        let style_256 = Style::builder().foreground(color_256).bold().build();

        // Get the basic ANSI color
        let basic = Color::rgb_to_basic(r, g, b);
        let basic_style = Style::builder().foreground(basic).bold().build();

        println!(
            "{:<15} RGB({:>3},{:>3},{:>3}): {} | 256({:>3}): {} | Basic: {}",
            name,
            r,
            g,
            b,
            "■■■■".style(rgb_style),
            code_256,
            "■■■■".style(style_256),
            "■■■■".style(basic_style),
        );
    }

    // Show some edge cases
    println!("\nEdge Cases and Special Colors:");
    println!("-----------------------------");

    let edge_cases = [
        // Brown variations
        ((139, 69, 19), "Saddle Brown"),
        ((128, 64, 0), "Brown"),
        ((165, 42, 42), "Brown 2"),
        ((160, 82, 45), "Sienna"),
        ((210, 105, 30), "Chocolate"),
        ((184, 134, 11), "Dark Goldenrod"),
        ((153, 76, 0), "Darker Brown"),
        ((102, 51, 0), "Deep Brown"),
        // Very dark gray (specific test case)
        ((32, 32, 32), "Very Dark Gray"),
        // Near-boundary cases
        ((51, 51, 51), "Dark Gray"),
        ((102, 102, 102), "Medium Gray"),
        ((204, 204, 204), "Light Gray"),
        ((254, 254, 254), "Almost White"),
        ((1, 1, 1), "Almost Black"),
        // Almost-primary colors
        ((254, 0, 0), "Near Red"),
        ((0, 254, 0), "Near Green"),
        ((0, 0, 254), "Near Blue"),
        // Web colors
        ((147, 112, 219), "Medium Purple"),
        ((64, 224, 208), "Turquoise"),
        ((250, 128, 114), "Salmon"),
        ((85, 107, 47), "Dark Olive"),
        ((219, 112, 147), "Pale Violet"),
        // Subtle variations
        ((128, 0, 0), "Maroon"),
        ((128, 0, 128), "Purple"),
        ((0, 128, 128), "Teal"),
        // Mixed intensities
        ((192, 64, 64), "Light Red"),
        ((64, 192, 64), "Light Green"),
        ((64, 64, 192), "Light Blue"),
        // Color cube edge cases
        ((51, 0, 0), "Dark Red"),
        ((102, 0, 0), "Medium Red"),
        ((204, 0, 0), "Bright Red"),
        // Pastels
        ((255, 182, 193), "Light Pink"),
        ((176, 224, 230), "Powder Blue"),
        ((255, 218, 185), "Peach Puff"),
        // Earth tones
        ((210, 180, 140), "Tan"),
        // Neon colors
        ((255, 0, 127), "Neon Pink"),
        ((127, 255, 0), "Neon Green"),
        ((0, 127, 255), "Neon Blue"),
        // Gradient steps
        ((51, 51, 51), "20% Gray"),
        ((102, 102, 102), "40% Gray"),
        ((153, 153, 153), "60% Gray"),
        ((204, 204, 204), "80% Gray"),
        // Color blends
        ((64, 0, 128), "Deep Purple"),
        ((0, 128, 64), "Sea Green"),
    ];

    for ((r, g, b), name) in edge_cases {
        let rgb_style = Style::builder()
            .foreground(Color::new_rgb(r, g, b)?)
            .bold()
            .build();

        let code_256 = Color::rgb_to_256(r, g, b);
        let style_256 = Style::builder()
            .foreground(Color::Color256(code_256))
            .bold()
            .build();

        let basic = Color::rgb_to_basic(r, g, b);
        let basic_style = Style::builder().foreground(basic).bold().build();

        println!(
            "{:<15} RGB({:>3},{:>3},{:>3}): {} | 256({:>3}): {} | Basic: {}",
            name,
            r,
            g,
            b,
            "■■■■".style(rgb_style),
            code_256,
            "■■■■".style(style_256),
            "■■■■".style(basic_style),
        );
    }

    Ok(())
}

pub fn new_hex(hex: &'static str) -> Result<Self, ColorError>

Create a new color from a hexadecimal color code

The hex code must start with ‘#’ and be followed by exactly 6 hexadecimal digits (e.g., “#FF0000” for red).

Arguments

• hex - Hexadecimal color code (e.g., “#FF0000”)

Returns

• Ok(Color) if the hex code is valid
• Err(ColorError) if the hex code is invalid

Examples

use inksac::Color;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let red = Color::new_hex("#FF0000")?;
    let green = Color::new_hex("#00FF00")?;
    Ok(())
}

pub fn new_hsv(h: u16, s: u8, v: u8) -> Result<Self, ColorError>

Create a new HSV color

Arguments

• h - Hue (0-360)
• s - Saturation (0-100)
• v - Value (0-100)

Returns

• Ok(Color) if the values are valid
• Err(ColorError) if the values are out of range

pub fn new_hsl(h: u16, s: u8, l: u8) -> Result<Self, ColorError>

Create a new HSL color

Arguments

• h - Hue (0-360)
• s - Saturation (0-100)
• l - Lightness (0-100)

Returns

• Ok(Color) if the values are valid
• Err(ColorError) if the values are out of range

impl Color

pub fn rgb_to_256(r: u8, g: u8, b: u8) -> u8

Convert RGB color values to the nearest 256-color code

This function maps RGB colors to the 256-color palette used by many terminals. It handles both the 6x6x6 color cube (216 colors) and the grayscale ramp (24 levels).

Arguments

• r - Red component (0-255)
• g - Green component (0-255)
• b - Blue component (0-255)

Returns

• u8 - The nearest 256-color code (16-255)

Examples found in repository

examples/color_conversion.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Color Conversion Comparison (RGB → 256 → Basic):");
    println!("----------------------------------------------");

    let test_colors = [
        ((0, 0, 0), "Black"),
        ((255, 255, 255), "White"),
        ((128, 128, 128), "Mid Gray"),
        ((255, 0, 0), "Red"),
        ((0, 255, 0), "Green"),
        ((0, 0, 255), "Blue"),
        ((255, 255, 0), "Yellow"),
        ((255, 0, 255), "Magenta"),
        ((0, 255, 255), "Cyan"),
        ((128, 64, 32), "Brown"),
        ((70, 130, 180), "Steel Blue"),
    ];

    for ((r, g, b), name) in test_colors {
        // Original RGB color
        let rgb_style = Style::builder()
            .foreground(Color::new_rgb(r, g, b)?)
            .bold()
            .build();

        // Get the 256-color code
        let code_256 = Color::rgb_to_256(r, g, b);
        let color_256 = Color::Color256(code_256);
        let style_256 = Style::builder().foreground(color_256).bold().build();

        // Get the basic ANSI color
        let basic = Color::rgb_to_basic(r, g, b);
        let basic_style = Style::builder().foreground(basic).bold().build();

        println!(
            "{:<15} RGB({:>3},{:>3},{:>3}): {} | 256({:>3}): {} | Basic: {}",
            name,
            r,
            g,
            b,
            "■■■■".style(rgb_style),
            code_256,
            "■■■■".style(style_256),
            "■■■■".style(basic_style),
        );
    }

    // Show some edge cases
    println!("\nEdge Cases and Special Colors:");
    println!("-----------------------------");

    let edge_cases = [
        // Brown variations
        ((139, 69, 19), "Saddle Brown"),
        ((128, 64, 0), "Brown"),
        ((165, 42, 42), "Brown 2"),
        ((160, 82, 45), "Sienna"),
        ((210, 105, 30), "Chocolate"),
        ((184, 134, 11), "Dark Goldenrod"),
        ((153, 76, 0), "Darker Brown"),
        ((102, 51, 0), "Deep Brown"),
        // Very dark gray (specific test case)
        ((32, 32, 32), "Very Dark Gray"),
        // Near-boundary cases
        ((51, 51, 51), "Dark Gray"),
        ((102, 102, 102), "Medium Gray"),
        ((204, 204, 204), "Light Gray"),
        ((254, 254, 254), "Almost White"),
        ((1, 1, 1), "Almost Black"),
        // Almost-primary colors
        ((254, 0, 0), "Near Red"),
        ((0, 254, 0), "Near Green"),
        ((0, 0, 254), "Near Blue"),
        // Web colors
        ((147, 112, 219), "Medium Purple"),
        ((64, 224, 208), "Turquoise"),
        ((250, 128, 114), "Salmon"),
        ((85, 107, 47), "Dark Olive"),
        ((219, 112, 147), "Pale Violet"),
        // Subtle variations
        ((128, 0, 0), "Maroon"),
        ((128, 0, 128), "Purple"),
        ((0, 128, 128), "Teal"),
        // Mixed intensities
        ((192, 64, 64), "Light Red"),
        ((64, 192, 64), "Light Green"),
        ((64, 64, 192), "Light Blue"),
        // Color cube edge cases
        ((51, 0, 0), "Dark Red"),
        ((102, 0, 0), "Medium Red"),
        ((204, 0, 0), "Bright Red"),
        // Pastels
        ((255, 182, 193), "Light Pink"),
        ((176, 224, 230), "Powder Blue"),
        ((255, 218, 185), "Peach Puff"),
        // Earth tones
        ((210, 180, 140), "Tan"),
        // Neon colors
        ((255, 0, 127), "Neon Pink"),
        ((127, 255, 0), "Neon Green"),
        ((0, 127, 255), "Neon Blue"),
        // Gradient steps
        ((51, 51, 51), "20% Gray"),
        ((102, 102, 102), "40% Gray"),
        ((153, 153, 153), "60% Gray"),
        ((204, 204, 204), "80% Gray"),
        // Color blends
        ((64, 0, 128), "Deep Purple"),
        ((0, 128, 64), "Sea Green"),
    ];

    for ((r, g, b), name) in edge_cases {
        let rgb_style = Style::builder()
            .foreground(Color::new_rgb(r, g, b)?)
            .bold()
            .build();

        let code_256 = Color::rgb_to_256(r, g, b);
        let style_256 = Style::builder()
            .foreground(Color::Color256(code_256))
            .bold()
            .build();

        let basic = Color::rgb_to_basic(r, g, b);
        let basic_style = Style::builder().foreground(basic).bold().build();

        println!(
            "{:<15} RGB({:>3},{:>3},{:>3}): {} | 256({:>3}): {} | Basic: {}",
            name,
            r,
            g,
            b,
            "■■■■".style(rgb_style),
            code_256,
            "■■■■".style(style_256),
            "■■■■".style(basic_style),
        );
    }

    Ok(())
}

pub fn code_to_rgb(code: u8) -> (u8, u8, u8)

Convert 256-color code to RGB color values

Arguments

• code - The 256-color code (16-255)

Returns

• (u8, u8, u8) - RGB color components (0-255)

pub fn rgb_to_basic(r: u8, g: u8, b: u8) -> Color

Convert RGB color values to the nearest basic ANSI color

This function maps RGB colors to the 8 basic ANSI colors by analyzing the relative luminance and dominant color components.

Arguments

• r - Red component (0-255)
• g - Green component (0-255)
• b - Blue component (0-255)

Returns

• Color - The nearest basic ANSI color

Examples found in repository

examples/color_conversion.rs (line 36)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Color Conversion Comparison (RGB → 256 → Basic):");
    println!("----------------------------------------------");

    let test_colors = [
        ((0, 0, 0), "Black"),
        ((255, 255, 255), "White"),
        ((128, 128, 128), "Mid Gray"),
        ((255, 0, 0), "Red"),
        ((0, 255, 0), "Green"),
        ((0, 0, 255), "Blue"),
        ((255, 255, 0), "Yellow"),
        ((255, 0, 255), "Magenta"),
        ((0, 255, 255), "Cyan"),
        ((128, 64, 32), "Brown"),
        ((70, 130, 180), "Steel Blue"),
    ];

    for ((r, g, b), name) in test_colors {
        // Original RGB color
        let rgb_style = Style::builder()
            .foreground(Color::new_rgb(r, g, b)?)
            .bold()
            .build();

        // Get the 256-color code
        let code_256 = Color::rgb_to_256(r, g, b);
        let color_256 = Color::Color256(code_256);
        let style_256 = Style::builder().foreground(color_256).bold().build();

        // Get the basic ANSI color
        let basic = Color::rgb_to_basic(r, g, b);
        let basic_style = Style::builder().foreground(basic).bold().build();

        println!(
            "{:<15} RGB({:>3},{:>3},{:>3}): {} | 256({:>3}): {} | Basic: {}",
            name,
            r,
            g,
            b,
            "■■■■".style(rgb_style),
            code_256,
            "■■■■".style(style_256),
            "■■■■".style(basic_style),
        );
    }

    // Show some edge cases
    println!("\nEdge Cases and Special Colors:");
    println!("-----------------------------");

    let edge_cases = [
        // Brown variations
        ((139, 69, 19), "Saddle Brown"),
        ((128, 64, 0), "Brown"),
        ((165, 42, 42), "Brown 2"),
        ((160, 82, 45), "Sienna"),
        ((210, 105, 30), "Chocolate"),
        ((184, 134, 11), "Dark Goldenrod"),
        ((153, 76, 0), "Darker Brown"),
        ((102, 51, 0), "Deep Brown"),
        // Very dark gray (specific test case)
        ((32, 32, 32), "Very Dark Gray"),
        // Near-boundary cases
        ((51, 51, 51), "Dark Gray"),
        ((102, 102, 102), "Medium Gray"),
        ((204, 204, 204), "Light Gray"),
        ((254, 254, 254), "Almost White"),
        ((1, 1, 1), "Almost Black"),
        // Almost-primary colors
        ((254, 0, 0), "Near Red"),
        ((0, 254, 0), "Near Green"),
        ((0, 0, 254), "Near Blue"),
        // Web colors
        ((147, 112, 219), "Medium Purple"),
        ((64, 224, 208), "Turquoise"),
        ((250, 128, 114), "Salmon"),
        ((85, 107, 47), "Dark Olive"),
        ((219, 112, 147), "Pale Violet"),
        // Subtle variations
        ((128, 0, 0), "Maroon"),
        ((128, 0, 128), "Purple"),
        ((0, 128, 128), "Teal"),
        // Mixed intensities
        ((192, 64, 64), "Light Red"),
        ((64, 192, 64), "Light Green"),
        ((64, 64, 192), "Light Blue"),
        // Color cube edge cases
        ((51, 0, 0), "Dark Red"),
        ((102, 0, 0), "Medium Red"),
        ((204, 0, 0), "Bright Red"),
        // Pastels
        ((255, 182, 193), "Light Pink"),
        ((176, 224, 230), "Powder Blue"),
        ((255, 218, 185), "Peach Puff"),
        // Earth tones
        ((210, 180, 140), "Tan"),
        // Neon colors
        ((255, 0, 127), "Neon Pink"),
        ((127, 255, 0), "Neon Green"),
        ((0, 127, 255), "Neon Blue"),
        // Gradient steps
        ((51, 51, 51), "20% Gray"),
        ((102, 102, 102), "40% Gray"),
        ((153, 153, 153), "60% Gray"),
        ((204, 204, 204), "80% Gray"),
        // Color blends
        ((64, 0, 128), "Deep Purple"),
        ((0, 128, 64), "Sea Green"),
    ];

    for ((r, g, b), name) in edge_cases {
        let rgb_style = Style::builder()
            .foreground(Color::new_rgb(r, g, b)?)
            .bold()
            .build();

        let code_256 = Color::rgb_to_256(r, g, b);
        let style_256 = Style::builder()
            .foreground(Color::Color256(code_256))
            .bold()
            .build();

        let basic = Color::rgb_to_basic(r, g, b);
        let basic_style = Style::builder().foreground(basic).bold().build();

        println!(
            "{:<15} RGB({:>3},{:>3},{:>3}): {} | 256({:>3}): {} | Basic: {}",
            name,
            r,
            g,
            b,
            "■■■■".style(rgb_style),
            code_256,
            "■■■■".style(style_256),
            "■■■■".style(basic_style),
        );
    }

    Ok(())
}

impl Color

pub fn lighten(self, percent: u8) -> Result<Self, ColorError>

Lighten a color by a percentage

Arguments

• percent - Amount to lighten (0-100)

Returns

• Ok(Color) - Lightened color
• Err(ColorError) - If color manipulation fails

Examples

use inksac::Color;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let color = Color::new_rgb(255, 100, 0)?;
    let lighter = color.lighten(30)?;
    Ok(())
}

Examples found in repository

examples/print_color.rs (line 57)

fn print_color_demo() -> Result<(), Box<dyn std::error::Error>> {
    // First, check color support
    let support = check_color_support()?;
    println!("Color Support Level: {}\n", support);

    // Basic colors
    let basic_colors = [
        ("Black", Color::Black),
        ("Red", Color::Red),
        ("Green", Color::Green),
        ("Yellow", Color::Yellow),
        ("Blue", Color::Blue),
        ("Magenta", Color::Magenta),
        ("Cyan", Color::Cyan),
        ("White", Color::White),
    ];

    println!("Basic Colors:");
    for (name, color) in basic_colors {
        let style = Style::builder().foreground(color).bold().build();
        println!("{:<8}: {}", name, "■■■■".style(style));
    }
    println!();

    // RGB Colors (if supported)
    if matches!(support, ColorSupport::TrueColor) {
        println!("RGB Colors:");
        let rgb_colors = [
            (255, 100, 0),
            (100, 255, 0),
            (0, 255, 100),
            (0, 100, 255),
            (100, 0, 255),
            (255, 0, 100),
        ];

        for (r, g, b) in rgb_colors {
            let style = Style::builder()
                .foreground(Color::new_rgb(r, g, b)?)
                .build();
            println!("RGB({}, {}, {}): {}", r, g, b, "■■■■".style(style));
        }
        println!();

        // Color manipulation
        let base_color = Color::new_rgb(255, 100, 0)?;
        println!("Color Manipulation:");
        println!(
            "Original: {}",
            "■■■■".style(Style::builder().foreground(base_color).build())
        );

        let lighter = base_color.lighten(30)?;
        println!(
            "Lighter : {}",
            "■■■■".style(Style::builder().foreground(lighter).build())
        );

        let darker = base_color.darken(30)?;
        println!(
            "Darker  : {}",
            "■■■■".style(Style::builder().foreground(darker).build())
        );
        println!();
    }

    // Text styles
    println!("Text Styles:");
    let text = "Styled Text";

    let bold = Style::builder().bold().build();
    println!("Bold:      {}", text.style(bold));

    let italic = Style::builder().italic().build();
    println!("Italic:    {}", text.style(italic));

    let underline = Style::builder().underline().build();
    println!("Underline: {}", text.style(underline));

    let dim = Style::builder().dim().build();
    println!("Dim:       {}", text.style(dim));

    // Combined styles
    let combined = Style::builder()
        .foreground(Color::Green)
        .background(Color::Black)
        .bold()
        .italic()
        .build();
    println!("\nCombined Styles:");
    println!("{}", "Multiple styles combined!".style(combined));

    Ok(())
}

pub fn darken(self, percent: u8) -> Result<Self, ColorError>

Darken a color by a percentage

Arguments

• percent - Amount to darken (0-100)

Returns

• Ok(Color) - Darkened color
• Err(ColorError) - If color manipulation fails

Examples

use inksac::Color;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let color = Color::new_rgb(255, 100, 0)?;
    let darker = color.darken(30)?;
    Ok(())
}

Examples found in repository

examples/print_color.rs (line 63)

fn print_color_demo() -> Result<(), Box<dyn std::error::Error>> {
    // First, check color support
    let support = check_color_support()?;
    println!("Color Support Level: {}\n", support);

    // Basic colors
    let basic_colors = [
        ("Black", Color::Black),
        ("Red", Color::Red),
        ("Green", Color::Green),
        ("Yellow", Color::Yellow),
        ("Blue", Color::Blue),
        ("Magenta", Color::Magenta),
        ("Cyan", Color::Cyan),
        ("White", Color::White),
    ];

    println!("Basic Colors:");
    for (name, color) in basic_colors {
        let style = Style::builder().foreground(color).bold().build();
        println!("{:<8}: {}", name, "■■■■".style(style));
    }
    println!();

    // RGB Colors (if supported)
    if matches!(support, ColorSupport::TrueColor) {
        println!("RGB Colors:");
        let rgb_colors = [
            (255, 100, 0),
            (100, 255, 0),
            (0, 255, 100),
            (0, 100, 255),
            (100, 0, 255),
            (255, 0, 100),
        ];

        for (r, g, b) in rgb_colors {
            let style = Style::builder()
                .foreground(Color::new_rgb(r, g, b)?)
                .build();
            println!("RGB({}, {}, {}): {}", r, g, b, "■■■■".style(style));
        }
        println!();

        // Color manipulation
        let base_color = Color::new_rgb(255, 100, 0)?;
        println!("Color Manipulation:");
        println!(
            "Original: {}",
            "■■■■".style(Style::builder().foreground(base_color).build())
        );

        let lighter = base_color.lighten(30)?;
        println!(
            "Lighter : {}",
            "■■■■".style(Style::builder().foreground(lighter).build())
        );

        let darker = base_color.darken(30)?;
        println!(
            "Darker  : {}",
            "■■■■".style(Style::builder().foreground(darker).build())
        );
        println!();
    }

    // Text styles
    println!("Text Styles:");
    let text = "Styled Text";

    let bold = Style::builder().bold().build();
    println!("Bold:      {}", text.style(bold));

    let italic = Style::builder().italic().build();
    println!("Italic:    {}", text.style(italic));

    let underline = Style::builder().underline().build();
    println!("Underline: {}", text.style(underline));

    let dim = Style::builder().dim().build();
    println!("Dim:       {}", text.style(dim));

    // Combined styles
    let combined = Style::builder()
        .foreground(Color::Green)
        .background(Color::Black)
        .bold()
        .italic()
        .build();
    println!("\nCombined Styles:");
    println!("{}", "Multiple styles combined!".style(combined));

    Ok(())
}

Trait Implementations

impl Clone for Color

fn clone(&self) -> Color

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Color

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

Formats the value using the given formatter.

impl Default for Color

fn default() -> Color

Returns the “default value” for a type.

impl PartialEq for Color

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

impl Eq for Color

impl StructuralPartialEq for Color