freya_terminal/

element.rs

use std::{
    any::Any,
    borrow::Cow,
    cell::RefCell,
    hash::{
        Hash,
        Hasher,
    },
    rc::Rc,
};

use freya_core::{
    data::{
        AccessibilityData,
        LayoutData,
    },
    diff_key::DiffKey,
    element::{
        Element,
        ElementExt,
        EventHandlerType,
    },
    events::name::EventName,
    fifo_cache::FifoCache,
    prelude::*,
    tree::DiffModifies,
};
use freya_engine::prelude::{
    Paint,
    PaintStyle,
    ParagraphBuilder,
    ParagraphStyle,
    SkParagraph,
    SkRect,
    TextStyle,
};
use rustc_hash::{
    FxHashMap,
    FxHasher,
};

use crate::{
    colors::map_vt100_color,
    handle::TerminalHandle,
};

/// Internal terminal rendering element
#[derive(Clone)]
pub struct Terminal {
    handle: TerminalHandle,
    layout_data: LayoutData,
    accessibility: AccessibilityData,
    font_family: String,
    font_size: f32,
    foreground: Color,
    background: Color,
    selection_color: Color,
    on_measured: Option<EventHandler<(f32, f32)>>,
    event_handlers: FxHashMap<EventName, EventHandlerType>,
}

impl PartialEq for Terminal {
    fn eq(&self, other: &Self) -> bool {
        self.handle == other.handle
            && self.font_size == other.font_size
            && self.font_family == other.font_family
            && self.foreground == other.foreground
            && self.background == other.background
            && self.event_handlers.len() == other.event_handlers.len()
    }
}

impl Terminal {
    pub fn new(handle: TerminalHandle) -> Self {
        let mut accessibility = AccessibilityData::default();
        accessibility.builder.set_role(AccessibilityRole::Terminal);
        Self {
            handle,
            layout_data: Default::default(),
            accessibility,
            font_family: "Cascadia Code".to_string(),
            font_size: 14.,
            foreground: (220, 220, 220).into(),
            background: (10, 10, 10).into(),
            selection_color: (60, 179, 214, 0.3).into(),
            on_measured: None,
            event_handlers: FxHashMap::default(),
        }
    }

    /// Set the selection highlight color
    pub fn selection_color(mut self, selection_color: impl Into<Color>) -> Self {
        self.selection_color = selection_color.into();
        self
    }

    /// Set callback for when dimensions are measured (char_width, line_height)
    pub fn on_measured(mut self, callback: impl Into<EventHandler<(f32, f32)>>) -> Self {
        self.on_measured = Some(callback.into());
        self
    }

    pub fn font_family(mut self, font_family: impl Into<String>) -> Self {
        self.font_family = font_family.into();
        self
    }

    pub fn font_size(mut self, font_size: f32) -> Self {
        self.font_size = font_size;
        self
    }

    pub fn foreground(mut self, foreground: impl Into<Color>) -> Self {
        self.foreground = foreground.into();
        self
    }

    pub fn background(mut self, background: impl Into<Color>) -> Self {
        self.background = background.into();
        self
    }
}

impl EventHandlersExt for Terminal {
    fn get_event_handlers(&mut self) -> &mut FxHashMap<EventName, EventHandlerType> {
        &mut self.event_handlers
    }
}

impl LayoutExt for Terminal {
    fn get_layout(&mut self) -> &mut LayoutData {
        &mut self.layout_data
    }
}

impl AccessibilityExt for Terminal {
    fn get_accessibility_data(&mut self) -> &mut AccessibilityData {
        &mut self.accessibility
    }
}

impl ElementExt for Terminal {
    fn diff(&self, other: &Rc<dyn ElementExt>) -> DiffModifies {
        let Some(terminal) = (other.as_ref() as &dyn Any).downcast_ref::<Terminal>() else {
            return DiffModifies::all();
        };

        let mut diff = DiffModifies::empty();

        if self.font_size != terminal.font_size
            || self.font_family != terminal.font_family
            || self.handle != terminal.handle
            || self.event_handlers.len() != terminal.event_handlers.len()
        {
            diff.insert(DiffModifies::STYLE);
            diff.insert(DiffModifies::LAYOUT);
        }

        if self.background != terminal.foreground
            || self.selection_color != terminal.selection_color
        {
            diff.insert(DiffModifies::STYLE);
        }

        if self.accessibility != terminal.accessibility {
            diff.insert(DiffModifies::ACCESSIBILITY);
        }

        diff
    }

    fn layout(&'_ self) -> Cow<'_, LayoutData> {
        Cow::Borrowed(&self.layout_data)
    }

    fn accessibility(&'_ self) -> Cow<'_, AccessibilityData> {
        Cow::Borrowed(&self.accessibility)
    }

    fn events_handlers(&'_ self) -> Option<Cow<'_, FxHashMap<EventName, EventHandlerType>>> {
        Some(Cow::Borrowed(&self.event_handlers))
    }

    fn should_hook_measurement(&self) -> bool {
        true
    }

    fn measure(
        &self,
        context: freya_core::element::LayoutContext,
    ) -> Option<(torin::prelude::Size2D, Rc<dyn Any>)> {
        let mut measure_builder =
            ParagraphBuilder::new(&ParagraphStyle::default(), context.font_collection.clone());
        let mut text_style = TextStyle::new();
        text_style.set_font_size(self.font_size);
        text_style.set_font_families(&[self.font_family.as_str()]);
        measure_builder.push_style(&text_style);
        measure_builder.add_text("W");
        let mut measure_paragraph = measure_builder.build();
        measure_paragraph.layout(f32::MAX);
        let mut line_height = measure_paragraph.height();
        if line_height <= 0.0 || line_height.is_nan() {
            line_height = (self.font_size * 1.2).max(1.0);
        }

        let mut height = context.area_size.height;
        if height <= 0.0 {
            height = (line_height * 24.0).max(200.0);
        }

        let char_width = measure_paragraph.max_intrinsic_width();
        let mut target_cols = if char_width > 0.0 {
            (context.area_size.width / char_width).floor() as u16
        } else {
            1
        };
        if target_cols == 0 {
            target_cols = 1;
        }
        let mut target_rows = if line_height > 0.0 {
            (height / line_height).floor() as u16
        } else {
            1
        };
        if target_rows == 0 {
            target_rows = 1;
        }

        self.handle.resize(target_rows, target_cols);

        // Store dimensions and notify callback
        if let Some(on_measured) = &self.on_measured {
            on_measured.call((char_width, line_height));
        }

        Some((
            torin::prelude::Size2D::new(context.area_size.width.max(100.0), height),
            Rc::new(RefCell::new(FifoCache::<u64, Rc<SkParagraph>>::new())),
        ))
    }

    fn render(&self, context: freya_core::element::RenderContext) {
        let area = context.layout_node.visible_area();
        let cache = context
            .layout_node
            .data
            .as_ref()
            .unwrap()
            .downcast_ref::<RefCell<FifoCache<u64, Rc<SkParagraph>>>>()
            .unwrap();

        let buffer = self.handle.read_buffer();

        let mut paint = Paint::default();
        paint.set_style(PaintStyle::Fill);
        paint.set_color(self.background);
        context.canvas.draw_rect(
            SkRect::new(area.min_x(), area.min_y(), area.max_x(), area.max_y()),
            &paint,
        );

        let mut text_style = TextStyle::new();
        text_style.set_color(self.foreground);
        text_style.set_font_families(&[self.font_family.as_str()]);
        text_style.set_font_size(self.font_size);

        let mut measure_builder =
            ParagraphBuilder::new(&ParagraphStyle::default(), context.font_collection.clone());
        measure_builder.push_style(&text_style);
        measure_builder.add_text("W");
        let mut measure_paragraph = measure_builder.build();
        measure_paragraph.layout(f32::MAX);
        let char_width = measure_paragraph.max_intrinsic_width();
        let mut line_height = measure_paragraph.height();
        if line_height <= 0.0 || line_height.is_nan() {
            line_height = (self.font_size * 1.2).max(1.0);
        }

        let mut y = area.min_y();

        for (row_idx, row) in buffer.rows.iter().enumerate() {
            if y + line_height > area.max_y() {
                break;
            }

            if let Some(selection) = &buffer.selection {
                let (display_start, start_col, display_end, end_col) =
                    selection.display_positions(buffer.scroll_offset);
                let row_i = row_idx as i64;

                if !selection.is_empty() && row_i >= display_start && row_i <= display_end {
                    let sel_start_col = if row_i == display_start { start_col } else { 0 };
                    let sel_end_col = if row_i == display_end {
                        end_col
                    } else {
                        row.len()
                    };

                    for col_idx in sel_start_col..sel_end_col.min(row.len()) {
                        let left = area.min_x() + (col_idx as f32) * char_width;
                        let top = y;
                        let right = left + char_width;
                        let bottom = top + line_height;

                        let mut sel_paint = Paint::default();
                        sel_paint.set_style(PaintStyle::Fill);
                        sel_paint.set_color(self.selection_color);
                        context
                            .canvas
                            .draw_rect(SkRect::new(left, top, right, bottom), &sel_paint);
                    }
                }
            }

            for (col_idx, cell) in row.iter().enumerate() {
                if cell.is_wide_continuation() {
                    continue;
                }
                let cell_bg = map_vt100_color(cell.bgcolor(), self.background);
                if cell_bg != self.background {
                    let left = area.min_x() + (col_idx as f32) * char_width;
                    let top = y;
                    let cell_width = if cell.is_wide() {
                        char_width * 2.0
                    } else {
                        char_width
                    };
                    let right = left + cell_width;
                    let bottom = top + line_height;

                    let mut bg_paint = Paint::default();
                    bg_paint.set_style(PaintStyle::Fill);
                    bg_paint.set_color(cell_bg);
                    context
                        .canvas
                        .draw_rect(SkRect::new(left, top, right, bottom), &bg_paint);
                }
            }

            let mut state = FxHasher::default();
            for cell in row.iter() {
                if cell.is_wide_continuation() {
                    continue;
                }
                let color = map_vt100_color(cell.fgcolor(), self.foreground);
                cell.contents().hash(&mut state);
                color.hash(&mut state);
            }

            let key = state.finish();
            if let Some(paragraph) = cache.borrow().get(&key) {
                paragraph.paint(context.canvas, (area.min_x(), y));
            } else {
                let mut builder = ParagraphBuilder::new(
                    &ParagraphStyle::default(),
                    context.font_collection.clone(),
                );
                for cell in row.iter() {
                    if cell.is_wide_continuation() {
                        continue;
                    }
                    let text = if cell.has_contents() {
                        cell.contents()
                    } else {
                        " "
                    };
                    let mut cell_style = text_style.clone();
                    cell_style.set_color(map_vt100_color(cell.fgcolor(), self.foreground));
                    builder.push_style(&cell_style);
                    builder.add_text(text);
                }
                let mut paragraph = builder.build();
                paragraph.layout(f32::MAX);
                paragraph.paint(context.canvas, (area.min_x(), y));
                cache.borrow_mut().insert(key, Rc::new(paragraph));
            }

            if row_idx == buffer.cursor_row && buffer.scroll_offset == 0 {
                let cursor_idx = buffer.cursor_col;
                let left = area.min_x() + (cursor_idx as f32) * char_width;
                let top = y;
                let right = left + char_width.max(1.0);
                let bottom = top + line_height.max(1.0);

                let mut cursor_paint = Paint::default();
                cursor_paint.set_style(PaintStyle::Fill);
                cursor_paint.set_color(self.foreground);
                context
                    .canvas
                    .draw_rect(SkRect::new(left, top, right, bottom), &cursor_paint);

                let content = row
                    .get(cursor_idx)
                    .map(|cell| {
                        if cell.has_contents() {
                            cell.contents()
                        } else {
                            " "
                        }
                    })
                    .unwrap_or(" ");

                let mut fg_text_style = text_style.clone();
                fg_text_style.set_color(self.background);
                let mut fg_builder = ParagraphBuilder::new(
                    &ParagraphStyle::default(),
                    context.font_collection.clone(),
                );
                fg_builder.push_style(&fg_text_style);
                fg_builder.add_text(content);
                let mut fg_paragraph = fg_builder.build();
                fg_paragraph.layout((right - left).max(1.0));
                fg_paragraph.paint(context.canvas, (left, top));
            }

            y += line_height;
        }

        // Scroll indicator
        if buffer.total_scrollback > 0 {
            let viewport_height = area.height();
            let total_rows = buffer.rows_count + buffer.total_scrollback;
            let total_content_height = total_rows as f32 * line_height;

            let scrollbar_height =
                (viewport_height * viewport_height / total_content_height).max(20.0);
            let track_height = viewport_height - scrollbar_height;

            let scroll_ratio = if buffer.total_scrollback > 0 {
                buffer.scroll_offset as f32 / buffer.total_scrollback as f32
            } else {
                0.0
            };

            let thumb_y_offset = track_height * (1.0 - scroll_ratio);

            let scrollbar_width = 4.0;
            let scrollbar_x = area.max_x() - scrollbar_width;
            let scrollbar_y = area.min_y() + thumb_y_offset;

            let corner_radius = 2.0;
            let mut track_paint = Paint::default();
            track_paint.set_anti_alias(true);
            track_paint.set_style(PaintStyle::Fill);
            track_paint.set_color(Color::from_argb(50, 0, 0, 0));
            context.canvas.draw_round_rect(
                SkRect::new(scrollbar_x, area.min_y(), area.max_x(), area.max_y()),
                corner_radius,
                corner_radius,
                &track_paint,
            );

            let mut thumb_paint = Paint::default();
            thumb_paint.set_anti_alias(true);
            thumb_paint.set_style(PaintStyle::Fill);
            thumb_paint.set_color(Color::from_argb(60, 255, 255, 255));
            context.canvas.draw_round_rect(
                SkRect::new(
                    scrollbar_x,
                    scrollbar_y,
                    area.max_x(),
                    scrollbar_y + scrollbar_height,
                ),
                corner_radius,
                corner_radius,
                &thumb_paint,
            );
        }
    }
}

impl From<Terminal> for Element {
    fn from(value: Terminal) -> Self {
        Element::Element {
            key: DiffKey::None,
            element: Rc::new(value),
            elements: Vec::new(),
        }
    }
}