pastel 0.12.0

A command-line tool to generate, analyze, convert and manipulate colors
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::io::Write;

use pastel::ansi::{Brush, ToAnsiStyle};
use pastel::Color;

use crate::Result;

pub struct Canvas {
    height: usize,
    width: usize,
    pixels: Vec<Option<Color>>,
    chars: Vec<Option<char>>,
    brush: Brush,
}

impl Canvas {
    pub fn new(height: usize, width: usize, brush: Brush) -> Self {
        assert!(height % 2 == 0);

        let mut pixels = vec![];
        pixels.resize(height * width, None);
        let mut chars = vec![];
        chars.resize(height / 2 * width, None);

        Canvas {
            height,
            width,
            pixels,
            chars,
            brush,
        }
    }

    pub fn draw_rect(
        &mut self,
        row: usize,
        col: usize,
        height: usize,
        width: usize,
        color: &Color,
    ) {
        for i in 0..height {
            for j in 0..width {
                let px = self.pixel_mut(row + i, col + j);
                *px = Some(match px {
                    Some(backdrop) => backdrop.composite(color),
                    None => color.clone(),
                });
            }
        }
    }

    pub fn draw_checkerboard(
        &mut self,
        row: usize,
        col: usize,
        height: usize,
        width: usize,
        dark: &Color,
        light: &Color,
    ) {
        for i in 0..height {
            for j in 0..width {
                let color = if (i + j) % 2 == 0 { dark } else { light };
                *self.pixel_mut(row + i, col + j) = Some(color.clone());
            }
        }
    }

    pub fn draw_text(&mut self, row: usize, col: usize, text: &str) {
        assert!(row % 2 == 0);

        for (j, c) in text.chars().enumerate() {
            *self.char_mut(row / 2, col + j) = Some(c);
        }
    }

    // The kitty terminal has a feature text_fg_override_threshold that
    // checks the difference in luminosity between text and background and
    // changes the text to black or white to make it readable if the
    // luminosity difference percentage is below the specified threshold.
    // Using block characters for graphics display can trigger this, causing
    // black or white lines or blocks, if the color is the same or too close.
    // The checkerboard should be ok unless the threshold is set fairly high.
    pub fn print(&self, out: &mut dyn Write) -> Result<()> {
        for i_div_2 in 0..self.height / 2 {
            for j in 0..self.width {
                if let Some(c) = self.char(i_div_2, j) {
                    write!(out, "{}", c)?;
                } else {
                    let p_top = self.pixel(2 * i_div_2, j);
                    let p_bottom = self.pixel(2 * i_div_2 + 1, j);

                    match (p_top, p_bottom) {
                        (Some(top), Some(bottom)) => {
                            if top == bottom {
                                write!(
                                    out,
                                    "{}",
                                    self.brush.paint(" ", top.ansi_style().on(bottom))
                                )?
                            } else {
                                write!(
                                    out,
                                    "{}",
                                    self.brush.paint("▀", top.ansi_style().on(bottom))
                                )?
                            }
                        }
                        (Some(top), None) => write!(out, "{}", self.brush.paint("▀", top))?,
                        (None, Some(bottom)) => write!(out, "{}", self.brush.paint("▄", bottom))?,
                        (None, None) => write!(out, " ")?,
                    };
                }
            }
            writeln!(out)?;
        }

        Ok(())
    }

    fn pixel(&self, i: usize, j: usize) -> &Option<Color> {
        assert!(i < self.height);
        assert!(j < self.width);
        &self.pixels[i * self.width + j]
    }

    fn pixel_mut(&mut self, i: usize, j: usize) -> &mut Option<Color> {
        assert!(i < self.height);
        assert!(j < self.width);
        &mut self.pixels[i * self.width + j]
    }

    fn char(&self, i: usize, j: usize) -> &Option<char> {
        assert!(i < self.height / 2);
        assert!(j < self.width);
        &self.chars[i * self.width + j]
    }

    fn char_mut(&mut self, i: usize, j: usize) -> &mut Option<char> {
        assert!(i < self.height / 2);
        assert!(j < self.width);
        &mut self.chars[i * self.width + j]
    }
}