Move renderable cell transformation to alacritty

This refactors a large chunk of the alacritty_terminal API to expose all
data necessary for rendering uniformly through the `renderable_content`
call. This also no longer transforms the cells for rendering by a GUI
but instead just reports the content from a terminal emulation
perspective. The transformation into renderable cells is now done inside
the alacritty crate.

Since the terminal itself only ever needs to know about modified color
RGB values, the configuration for colors was moved to the alacritty UI
code.

1 files changed, 167 insertions, 0 deletions

diff --git a/alacritty/src/display/color.rs b/alacritty/src/display/color.rs
new file mode 100644
index 00000000..6e0de048
--- /dev/null
+++ b/alacritty/src/display/color.rs
@@ -0,0 +1,167 @@
+use std::ops::{Index, IndexMut};
+
+use log::trace;
+
+use alacritty_terminal::ansi::NamedColor;
+use alacritty_terminal::term::color::{Rgb, COUNT};
+
+use crate::config::color::Colors;
+
+/// Factor for automatic computation of dim colors.
+pub const DIM_FACTOR: f32 = 0.66;
+
+#[derive(Copy, Clone)]
+pub struct List([Rgb; COUNT]);
+
+impl<'a> From<&'a Colors> for List {
+    fn from(colors: &Colors) -> List {
+        // Type inference fails without this annotation.
+        let mut list = List([Rgb::default(); COUNT]);
+
+        list.fill_named(colors);
+        list.fill_cube(colors);
+        list.fill_gray_ramp(colors);
+
+        list
+    }
+}
+
+impl List {
+    pub fn fill_named(&mut self, colors: &Colors) {
+        // Normals.
+        self[NamedColor::Black] = colors.normal.black;
+        self[NamedColor::Red] = colors.normal.red;
+        self[NamedColor::Green] = colors.normal.green;
+        self[NamedColor::Yellow] = colors.normal.yellow;
+        self[NamedColor::Blue] = colors.normal.blue;
+        self[NamedColor::Magenta] = colors.normal.magenta;
+        self[NamedColor::Cyan] = colors.normal.cyan;
+        self[NamedColor::White] = colors.normal.white;
+
+        // Brights.
+        self[NamedColor::BrightBlack] = colors.bright.black;
+        self[NamedColor::BrightRed] = colors.bright.red;
+        self[NamedColor::BrightGreen] = colors.bright.green;
+        self[NamedColor::BrightYellow] = colors.bright.yellow;
+        self[NamedColor::BrightBlue] = colors.bright.blue;
+        self[NamedColor::BrightMagenta] = colors.bright.magenta;
+        self[NamedColor::BrightCyan] = colors.bright.cyan;
+        self[NamedColor::BrightWhite] = colors.bright.white;
+        self[NamedColor::BrightForeground] =
+            colors.primary.bright_foreground.unwrap_or(colors.primary.foreground);
+
+        // Foreground and background.
+        self[NamedColor::Foreground] = colors.primary.foreground;
+        self[NamedColor::Background] = colors.primary.background;
+
+        // Dims.
+        self[NamedColor::DimForeground] =
+            colors.primary.dim_foreground.unwrap_or(colors.primary.foreground * DIM_FACTOR);
+        match colors.dim {
+            Some(ref dim) => {
+                trace!("Using config-provided dim colors");
+                self[NamedColor::DimBlack] = dim.black;
+                self[NamedColor::DimRed] = dim.red;
+                self[NamedColor::DimGreen] = dim.green;
+                self[NamedColor::DimYellow] = dim.yellow;
+                self[NamedColor::DimBlue] = dim.blue;
+                self[NamedColor::DimMagenta] = dim.magenta;
+                self[NamedColor::DimCyan] = dim.cyan;
+                self[NamedColor::DimWhite] = dim.white;
+            },
+            None => {
+                trace!("Deriving dim colors from normal colors");
+                self[NamedColor::DimBlack] = colors.normal.black * DIM_FACTOR;
+                self[NamedColor::DimRed] = colors.normal.red * DIM_FACTOR;
+                self[NamedColor::DimGreen] = colors.normal.green * DIM_FACTOR;
+                self[NamedColor::DimYellow] = colors.normal.yellow * DIM_FACTOR;
+                self[NamedColor::DimBlue] = colors.normal.blue * DIM_FACTOR;
+                self[NamedColor::DimMagenta] = colors.normal.magenta * DIM_FACTOR;
+                self[NamedColor::DimCyan] = colors.normal.cyan * DIM_FACTOR;
+                self[NamedColor::DimWhite] = colors.normal.white * DIM_FACTOR;
+            },
+        }
+    }
+
+    pub fn fill_cube(&mut self, colors: &Colors) {
+        let mut index: usize = 16;
+        // Build colors.
+        for r in 0..6 {
+            for g in 0..6 {
+                for b in 0..6 {
+                    // Override colors 16..232 with the config (if present).
+                    if let Some(indexed_color) =
+                        colors.indexed_colors.iter().find(|ic| ic.index() == index as u8)
+                    {
+                        self[index] = indexed_color.color;
+                    } else {
+                        self[index] = Rgb {
+                            r: if r == 0 { 0 } else { r * 40 + 55 },
+                            b: if b == 0 { 0 } else { b * 40 + 55 },
+                            g: if g == 0 { 0 } else { g * 40 + 55 },
+                        };
+                    }
+                    index += 1;
+                }
+            }
+        }
+
+        debug_assert!(index == 232);
+    }
+
+    pub fn fill_gray_ramp(&mut self, colors: &Colors) {
+        let mut index: usize = 232;
+
+        for i in 0..24 {
+            // Index of the color is number of named colors + number of cube colors + i.
+            let color_index = 16 + 216 + i;
+
+            // Override colors 232..256 with the config (if present).
+            if let Some(indexed_color) =
+                colors.indexed_colors.iter().find(|ic| ic.index() == color_index)
+            {
+                self[index] = indexed_color.color;
+                index += 1;
+                continue;
+            }
+
+            let value = i * 10 + 8;
+            self[index] = Rgb { r: value, g: value, b: value };
+            index += 1;
+        }
+
+        debug_assert!(index == 256);
+    }
+}
+
+impl Index<usize> for List {
+    type Output = Rgb;
+
+    #[inline]
+    fn index(&self, idx: usize) -> &Self::Output {
+        &self.0[idx]
+    }
+}
+
+impl IndexMut<usize> for List {
+    #[inline]
+    fn index_mut(&mut self, idx: usize) -> &mut Self::Output {
+        &mut self.0[idx]
+    }
+}
+
+impl Index<NamedColor> for List {
+    type Output = Rgb;
+
+    #[inline]
+    fn index(&self, idx: NamedColor) -> &Self::Output {
+        &self.0[idx as usize]
+    }
+}
+
+impl IndexMut<NamedColor> for List {
+    #[inline]
+    fn index_mut(&mut self, idx: NamedColor) -> &mut Self::Output {
+        &mut self.0[idx as usize]
+    }
+}