path: root/src/ui/grid/context.rs

use gtk::prelude::*;
use gtk::DrawingArea;

use crate::ui::color::HlDefs;
use crate::ui::font::Font;
use crate::ui::grid::cursor::Cursor;
use crate::ui::grid::render;
use crate::ui::grid::row::{Cell, Row};

/// Context is manipulated by Grid.
pub struct Context {
    /// Our cairo context, that is evetually drawn to the screen.
    pub cairo_context: cairo::Context,
    /// Our cell metrics.
    pub cell_metrics: CellMetrics,
    /// Cell metrics to be updated.
    pub cell_metrics_update: Option<CellMetrics>,

    /// Internal grid.
    pub rows: Vec<Row>,

    pub cursor: Cursor,
    /// Cairo context for cursor.
    pub cursor_context: cairo::Context,

    /// If the current status is busy or not. When busy, the cursor is not
    /// drawn (like when in terminal mode in inserting text).
    pub busy: bool,

    /// If the grid that this context belongs to is active or not.
    pub active: bool,

    /// Areas to call queue_draw_area on the drawing area on flush.
    pub queue_draw_area: Vec<(f64, f64, f64, f64)>,
}

impl Context {
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        da: &DrawingArea,
        win: &gdk::Window,
        font: Font,
        line_space: i64,
        cols: usize,
        rows: usize,
        hl_defs: &HlDefs,
        enable_cursor_animations: bool,
    ) -> Self {
        let pango_context = da.get_pango_context();

        let font_desc = font.as_pango_font();
        pango_context.set_font_description(&font_desc);

        let mut cell_metrics = CellMetrics::default();
        cell_metrics.font = font;
        cell_metrics.line_space = line_space;
        cell_metrics.update(&pango_context);

        let w = cell_metrics.width * cols as f64;
        let h = cell_metrics.height * rows as f64;
        let surface = win
            .create_similar_surface(
                cairo::Content::Color,
                w.ceil() as i32,
                h.ceil() as i32,
            )
            .unwrap();

        let cairo_context = cairo::Context::new(&surface);

        // Fill the context with default bg color.
        cairo_context.save();
        cairo_context.set_source_rgb(
            hl_defs.default_bg.r,
            hl_defs.default_bg.g,
            hl_defs.default_bg.b,
        );
        cairo_context.paint();
        cairo_context.restore();

        let cursor_context = {
            let surface = win
                .create_similar_surface(
                    cairo::Content::ColorAlpha,
                    (cell_metrics.width * 2.0) as i32, // times two for double width chars.
                    (cell_metrics.height + cell_metrics.ascent).ceil() as i32,
                )
                .unwrap();
            cairo::Context::new(&surface)
        };

        let cursor = Cursor {
            disable_animation: !enable_cursor_animations,
            ..Cursor::default()
        };

        Context {
            cairo_context,
            cell_metrics,
            cell_metrics_update: None,
            rows: vec![],

            cursor,
            cursor_context,

            busy: false,
            active: false,

            queue_draw_area: vec![],
        }
    }

    /// Updates internals that are dependant on the drawing area.
    pub fn resize(
        &mut self,
        da: &DrawingArea,
        win: &gdk::Window,
        cols: usize,
        rows: usize,
        hl_defs: &HlDefs,
    ) {
        let prev_rows = self.rows.len();
        let prev_cols = self.rows.get(0).map(|r| r.len()).unwrap_or(0);

        if self.rows.len() != rows {
            self.rows.resize_with(rows, || Row::new(cols));
        }

        if self.rows.get(0).unwrap().len() != cols {
            for row in self.rows.iter_mut() {
                row.resize(cols);
            }
        }

        let pctx = da.get_pango_context();
        pctx.set_font_description(&self.cell_metrics.font.as_pango_font());

        self.cell_metrics.update(&pctx);

        let w = self.cell_metrics.width * cols as f64;
        let h = self.cell_metrics.height * rows as f64;
        let surface = win
            .create_similar_surface(
                cairo::Content::Color,
                w.ceil() as i32,
                h.ceil() as i32,
            )
            .unwrap();
        let ctx = cairo::Context::new(&surface);

        // Fill the context with default bg color.
        ctx.save();
        ctx.set_source_rgb(
            hl_defs.default_bg.r,
            hl_defs.default_bg.g,
            hl_defs.default_bg.b,
        );
        ctx.paint();
        ctx.restore();

        let s = self.cairo_context.get_target();
        self.cairo_context.save();
        ctx.set_source_surface(&s, 0.0, 0.0);
        ctx.set_operator(cairo::Operator::Source);
        // Make sure we only paint the area that _was_ visible before this update
        // so we don't undo the bg color paint we did earlier. Note that we're
        // calculating the used area based on the current cell metrics. This is
        // becuase if font changes that might reduce the area we "have available".
        // Otherwise, when changing to smaller font, we might draw our "old" surface
        // on a area that wont be cleared by nvim (e.g. over "fresh" whitespace).
        ctx.rectangle(
            0.0,
            0.0,
            self.cell_metrics.width * prev_cols as f64,
            self.cell_metrics.height * prev_rows as f64,
        );
        ctx.fill();
        self.cairo_context.restore();

        self.cairo_context = ctx;
    }

    /// Sets the cell metrics to be updated. If font or line_space is None,
    /// the earlier value for each is used. Call `finish_metrics_update` to
    /// make the update take place.
    pub fn update_metrics(
        &mut self,
        font: Font,
        line_space: i64,
        da: &gtk::DrawingArea,
        win: &gdk::Window,
    ) {
        let pango_context = da.get_pango_context();
        pango_context.set_font_description(&font.as_pango_font());

        self.cell_metrics.font = font;
        self.cell_metrics.line_space = line_space;
        self.cell_metrics.update(&pango_context);

        self.cursor_context = {
            let surface = win
                .create_similar_surface(
                    cairo::Content::ColorAlpha,
                    (self.cell_metrics.width * 2.0).ceil() as i32, // times two for double width chars.
                    (self.cell_metrics.height + self.cell_metrics.ascent).ceil()
                        as i32,
                )
                .unwrap();
            cairo::Context::new(&surface)
        };
    }

    /// Returns x, y, width and height for cursor position on the screen (e.g. might be in middle
    /// of an animation).
    pub fn get_cursor_rect(&self) -> (i32, i32, i32, i32) {
        let double_width = self
            .cell_at_cursor()
            .map(|cell| cell.double_width)
            .unwrap_or(false);

        // Dont use cursor.get_position here, because we want to use the position on the screen.
        let pos = self.cursor.pos.unwrap_or((0.0, 0.0));

        let cm = &self.cell_metrics;
        let (x, y) = render::get_coords(cm.height, cm.width, pos.0, pos.1);
        (
            x.floor() as i32,
            y.floor() as i32,
            if double_width {
                (cm.width * 2.0).ceil() as i32
            } else {
                cm.width.ceil() as i32
            },
            cm.height.ceil() as i32,
        )
    }

    pub fn cursor_goto(&mut self, row: u64, col: u64, clock: &gdk::FrameClock) {
        // Clear old cursor position.
        let (x, y, w, h) = self.get_cursor_rect();
        self.queue_draw_area.push((
            f64::from(x),
            f64::from(y),
            f64::from(w),
            f64::from(h),
        ));
        self.cursor
            .goto(row as f64, col as f64, clock.get_frame_time());

        // Mark the new cursor position to be drawn.
        let (x, y, w, h) = self.get_cursor_rect();
        self.queue_draw_area.push((
            f64::from(x),
            f64::from(y),
            f64::from(w),
            f64::from(h),
        ));
    }

    pub fn tick(&mut self, da: &DrawingArea, clock: &gdk::FrameClock) {
        let