Modifier and Blink Support

mousefood/src/backend.rs

@@ -1,5 +1,7 @@
 use alloc::boxed::Box;
+use alloc::collections::BTreeMap;
 use core::marker::PhantomData;
+use embedded_graphics::prelude::RgbColor;
 
 use crate::colors::*;
 use crate::default_font;
@@ -116,6 +118,12 @@ where
     columns_rows: layout::Size,
     pixels: layout::Size,
     color_theme: ColorTheme,
+    cursor_visible: bool,
+    cursor_position: layout::Position,
+    blink_counter: u8,
+    blinking_fast: bool,
+    blinking_slow: bool,
+    blink_cells: BTreeMap<(u16, u16), ratatui_core::buffer::Cell>,
 }
 
 impl<'display, D, C> EmbeddedBackend<'display, D, C>
@@ -173,6 +181,12 @@ where
             },
             pixels,
             color_theme,
+            cursor_visible: false,
+            cursor_position: layout::Position::new(0, 0),
+            blink_counter: 0,
+            blinking_fast: false,
+            blinking_slow: false,
+            blink_cells: BTreeMap::new(),
         }
     }
 
@@ -208,91 +222,54 @@ where
     where
         I: Iterator<Item = (u16, u16, &'a ratatui_core::buffer::Cell)>,
     {
-        for (x, y, cell) in content {
-            let position = geometry::Point::new(
-                x as i32 * self.font_regular.character_size.width as i32,
-                y as i32 * self.font_regular.character_size.height as i32,
-            );
+        self.blink_counter = (self.blink_counter + 1) % 60;
+        let prev_slow = self.blinking_slow;
+        let prev_fast = self.blinking_fast;
+        self.blinking_slow = matches!(self.blink_counter, 20..=25);
+        self.blinking_fast = matches!(self.blink_counter % 20, 0..=5);
+        let blink_toggled = self.blinking_slow != prev_slow || self.blinking_fast != prev_fast;
 
-            let mut style_builder = MonoTextStyleBuilder::new()
-                .font(&self.font_regular)
-                .text_color(
-                    TermColor::new(cell.fg, TermColorType::Foreground, &self.color_theme).into(),
-                )
-                .background_color(
-                    TermColor::new(cell.bg, TermColorType::Background, &self.color_theme).into(),
-                );
-
-            for modifier in cell.modifier.iter() {
-                style_builder = match modifier {
-                    style::Modifier::BOLD => match &self.font_bold {
-                        None => style_builder,
-                        Some(font) => style_builder.font(font),
-                    },
-                    style::Modifier::DIM => style_builder, // TODO
-                    style::Modifier::ITALIC => match &self.font_italic {
-                        None => style_builder,
-                        Some(font) => style_builder.font(font),
-                    },
-                    style::Modifier::UNDERLINED => style_builder.underline(),
-                    style::Modifier::SLOW_BLINK => style_builder, // TODO
-                    style::Modifier::RAPID_BLINK => style_builder, // TODO
-                    style::Modifier::REVERSED => style_builder,   // TODO
-                    style::Modifier::HIDDEN => style_builder,     // TODO
-                    style::Modifier::CROSSED_OUT => style_builder.strikethrough(),
-                    _ => style_builder,
-                }
+        for (x, y, cell) in content {
+            if cell.modifier.contains(style::Modifier::SLOW_BLINK)
+                || cell.modifier.contains(style::Modifier::RAPID_BLINK)
+            {
+                self.blink_cells.insert((x, y), cell.clone());
+            } else {
+                self.blink_cells.remove(&(x, y));
             }
 
-            #[cfg(feature = "underline-color")]
-            if cell.underline_color != style::Color::Reset {
-                style_builder = style_builder.underline_with_color(
-                    TermColor::new(
-                        cell.underline_color,
-                        TermColorType::Foreground,
-                        &self.color_theme,
-                    )
-                    .into(),
-                );
-            }
+            self.draw_cell(x, y, cell)?;
+        }
 
-            Text::with_baseline(
-                cell.symbol(),
-                position + self.char_offset,
-                style_builder.build(),
-                embedded_graphics::text::Baseline::Top,
-            )
-            .draw(
-                #[cfg(feature = "framebuffer")]
-                &mut self.buffer,
-                #[cfg(not(feature = "framebuffer"))]
-                self.display,
-            )
-            .map_err(|_| crate::error::Error::DrawError)?;
+        // Avoids redrawing unnecessarily
+        if blink_toggled && !self.blink_cells.is_empty() {
+            // Necessary to mem::take otherwise compiler complains about mutating self while iterating
+            let cells = core::mem::take(&mut self.blink_cells);
+            for (&(x, y), cell) in &cells {
+                self.draw_cell(x, y, cell)?;
+            }
+            self.blink_cells = cells;
         }
+
         Ok(())
     }
 
     fn hide_cursor(&mut self) -> Result<()> {
-        // TODO
+        self.cursor_visible = false;
         Ok(())
     }
 
     fn show_cursor(&mut self) -> Result<()> {
-        // TODO
+        self.cursor_visible = true;
         Ok(())
     }
 
     fn get_cursor_position(&mut self) -> Result<layout::Position> {
-        // TODO
-        Ok(layout::Position::new(0, 0))
+        Ok(self.cursor_position)
     }
 
-    fn set_cursor_position<P: Into<layout::Position>>(
-        &mut self,
-        #[allow(unused_variables)] position: P,
-    ) -> Result<()> {
-        // TODO
+    fn set_cursor_position<P: Into<layout::Position>>(&mut self, position: P) -> Result<()> {
+        self.cursor_position = position.into();
         Ok(())
     }
 
@@ -352,11 +329,128 @@ where
         self.display
             .fill_contiguous(&self.display.bounding_box(), &self.buffer)
             .map_err(|_| crate::error::Error::DrawError)?;
+        // Draw cursor after buffer is copied to display
+        if self.cursor_visible && self.blinking_fast {
+            self.draw_cursor()?;
+        }
+
         (self.flush_callback)(self.display);
         Ok(())
     }
 }
 
+impl<D, C> EmbeddedBackend<'_, D, C>
+where
+    D: DrawTarget<Color = C> + 'static,
+    C: PixelColor + Into<Rgb888> + From<Rgb888> + for<'a> From<TermColor<'a>> + 'static,
+{
+    fn draw_cell(&mut self, x: u16, y: u16, cell: &ratatui_core::buffer::Cell) -> Result<()> {
+        let position = geometry::Point::new(
+            x as i32 * self.font_regular.character_size.width as i32,
+            y as i32 * self.font_regular.character_size.height as i32,
+        );
+        let mut fg_color: C =
+            TermColor::new(cell.fg, TermColorType::Foreground, &self.color_theme).into();
+        let mut bg_color: C =
+            TermColor::new(cell.bg, TermColorType::Background, &self.color_theme).into();
+        let mut style_builder = MonoTextStyleBuilder::new()
+            .font(&self.font_regular)
+            .text_color(fg_color)
+            .background_color(bg_color);
+
+        for modifier in cell.modifier.iter() {
+            style_builder = match modifier {
+                style::Modifier::BOLD => match &self.font_bold {
+                    None => style_builder,
+                    Some(font) => style_builder.font(font),
+                },
+                style::Modifier::DIM => {
+                    fg_color = dim_color(fg_color);
+                    style_builder
+                }
+                style::Modifier::ITALIC => match &self.font_italic {
+                    None => style_builder,
+                    Some(font) => style_builder.font(font),
+                },
+                style::Modifier::UNDERLINED => style_builder.underline(),
+                style::Modifier::SLOW_BLINK => {
+                    if self.blinking_slow {
+                        fg_color = bg_color;
+                    }
+                    style_builder
+                }
+                style::Modifier::RAPID_BLINK => {
+                    if self.blinking_fast {
+                        fg_color = bg_color;
+                    }
+                    style_builder
+                }
+                style::Modifier::REVERSED => {
+                    core::mem::swap(&mut fg_color, &mut bg_color);
+                    style_builder
+                }
+                style::Modifier::HIDDEN => {
+                    fg_color = bg_color;
+                    style_builder
+                }
+                style::Modifier::CROSSED_OUT => style_builder.strikethrough(),
+                _ => style_builder,
+            }
+        }
+
+        style_builder = style_builder
+            .text_color(fg_color)
+            .background_color(bg_color);
+
+        #[cfg(feature = "underline-color")]
+        if cell.underline_color != style::Color::Reset {
+            style_builder = style_builder.underline_with_color(
+                TermColor::new(
+                    cell.underline_color,
+                    TermColorType::Foreground,
+                    &self.color_theme,
+                )
+                .into(),
+            );
+        }
+
+        Text::with_baseline(
+            cell.symbol(),
+            position + self.char_offset,
+            style_builder.build(),
+            embedded_graphics::text::Baseline::Top,
+        )
+        .draw(
+            #[cfg(feature = "framebuffer")]
+            &mut self.buffer,
+            #[cfg(not(feature = "framebuffer"))]
+            self.display,
+        )
+        .map_err(|_| crate::error::Error::DrawError)?;
+
+        Ok(())
+    }
+    fn draw_cursor(&mut self) -> Result<()> {
+        let char_w = self.font_regular.character_size.width as i32;
+        let char_h = self.font_regular.character_size.height as i32;
+
+        let top_left = geometry::Point::new(
+            self.cursor_position.x as i32 * char_w,
+            self.cursor_position.y as i32 * char_h,
+        ) + self.char_offset;
+
+        self.display
+            .fill_solid(
+                &embedded_graphics::primitives::Rectangle::new(
+                    geometry::Point::new(top_left.x, top_left.y + char_h - 2),
+                    geometry::Size::new(char_w as u32, 1),
+                ),
+                Rgb888::WHITE.into(),
+            )
+            .map_err(|_| crate::error::Error::DrawError)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use {

mousefood/src/colors.rs

@@ -175,7 +175,17 @@ impl<'a> From<TermColor<'a>> for BinaryColor {
         }
     }
 }
-
+pub fn dim_color<C>(color: C) -> C
+where
+    C: Into<Rgb888> + From<Rgb888>,
+{
+    let rgb: Rgb888 = color.into();
+    let factor = 77u32; // ~30% brightness
+    let r = ((rgb.r() as u32 * factor + 127) / 255) as u8;
+    let g = ((rgb.g() as u32 * factor + 127) / 255) as u8;
+    let b = ((rgb.b() as u32 * factor + 127) / 255) as u8;
+    Rgb888::new(r, g, b).into()
+}
 #[cfg(feature = "epd-weact")]
 impl<'a> From<TermColor<'a>> for weact_studio_epd::Color {
     fn from(color: TermColor<'a>) -> Self {