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

use cairo;
use gtk::prelude::*;
use gtk::DrawingArea;
use pango;
use pango::Attribute;
use pangocairo;

use crate::nvim_bridge::GridLineSegment;
use crate::ui::color::Highlight;
use crate::ui::color::HlDefs;
use crate::ui::grid::context::{CellMetrics, Context};
use crate::ui::grid::row::{Cell, Segment};

/// Renders text to `cr`.
///
/// * `cr` - The cairo context to render to.
/// * `pango_context` - The pango context to use for text rendering.
/// * `cm` - Cell metrics to use for text placement.
/// * `hl` - The highlighting to use.
/// * `hl_defs` - Global hl defs. Used to get default values.
/// * `text` - The text to render.
/// * `x` - Target x coordinate for `cr`.
/// * `y` - Target y coordinate for `cr`.
/// * `w` - Target width for `cr`.
/// * `h` - Target height for `cr`.
fn render_text(
    cr: &cairo::Context,
    pango_context: &pango::Context,
    cm: &CellMetrics,
    hl: &Highlight,
    hl_defs: &HlDefs,
    text: &str,
    x: f64,
    y: f64,
    w: f64,
    h: f64,
) {
    let (fg, bg) = if hl.reverse {
        (
            hl.background.unwrap_or(hl_defs.default_bg),
            hl.foreground.unwrap_or(hl_defs.default_fg),
        )
    } else {
        (
            hl.foreground.unwrap_or(hl_defs.default_fg),
            hl.background.unwrap_or(hl_defs.default_bg),
        )
    };

    cr.save();
    cr.set_source_rgb(bg.r, bg.g, bg.b);
    cr.rectangle(x, y, w, h);
    cr.fill();
    cr.restore();

    let attrs = pango::AttrList::new();

    if hl.bold {
        let attr = Attribute::new_weight(pango::Weight::Bold).unwrap();
        attrs.insert(attr);
    }
    if hl.italic {
        let attr = Attribute::new_style(pango::Style::Italic).unwrap();
        attrs.insert(attr);
    }

    cr.save();
    cr.set_source_rgb(fg.r, fg.g, fg.b);

    let items =
        pango::itemize(pango_context, text, 0, text.len() as i32, &attrs, None);

    let mut x_offset = 0.0;
    for item in items {
        let a = item.analysis();
        let item_offset = item.offset() as usize;
        let mut glyphs = pango::GlyphString::new();

        pango::shape(
            &text[item_offset..item_offset + item.length() as usize],
            &a,
            &mut glyphs,
        );

        cr.move_to(x + x_offset, y + cm.ascent);
        pangocairo::functions::show_glyph_string(&cr, &a.font(), &mut glyphs);

        x_offset += f64::from(item.num_chars()) * cm.width;
        //x_offset += f64::from(glyphs.get_width());
    }

    // Since we can't (for some reason) use pango attributes to draw
    // underline and undercurl, we'll have to do that manually.
    let sp = hl.special.unwrap_or(hl_defs.default_sp);
    cr.set_source_rgb(sp.r, sp.g, sp.b);
    if hl.undercurl {
        pangocairo::functions::show_error_underline(
            cr,
            x,
            y + h + cm.underline_position - cm.underline_thickness,
            w,
            cm.underline_thickness * 2.0,
        );
    }
    if hl.underline {
        let y = y + h + cm.underline_position;
        cr.rectangle(x, y, w, cm.underline_thickness);
        cr.fill();
    }

    cr.restore();
}

/// Draws (inverted) cell to `cr`.
pub fn cursor_cell(
    cr: &cairo::Context,
    pango_context: &pango::Context,
    cell: &Cell,
    cm: &CellMetrics,
    hl_defs: &HlDefs,
) {
    let mut hl = hl_defs.get(&cell.hl_id).unwrap().clone();

    hl.reverse = !hl.reverse;

    let x = 0.0;
    let y = 0.0;
    let w = if cell.double_width {
        cm.width * 2.0
    } else {
        cm.width
    };
    let h = cm.height;

    render_text(cr, pango_context, cm, &hl, hl_defs, &cell.text, x, y, w, h);
}

/// Renders `segments` to `cr`.
fn put_segments(
    cr: &cairo::Context,
    pango_context: &pango::Context,
    queue_draw_area: &mut Vec<(f64, f64, f64, f64)>,
    cm: &CellMetrics,
    hl_defs: &HlDefs,
    segments: Vec<Segment>,
    row: usize,
) {
    let cw = cm.width;
    let ch = cm.height;

    for seg in segments {
        let hl = hl_defs.get(&seg.hl_id).unwrap();

        let x = (seg.start as f64 * cw).floor();
        let y = (row as f64 * ch).floor();
        let w = (seg.len as f64 * cw).ceil();
        let h = ch.ceil();

        let text = &seg.text;
        render_text(cr, pango_context, cm, &hl, hl_defs, &text, x, y, w, h);

        queue_draw_area.push((x, y, w, h));
    }
}

pub fn redraw(
    context: &mut Context,
    pango_context: &pango::Context,
    hl_defs: &HlDefs,
) {
    for (i, row) in context.rows.iter_mut().enumerate() {
        let segments = row.as_segments(0, row.len);

        put_segments(
            &context.cairo_context,
            pango_context,
            &mut context.queue_draw_area,
            &context.cell_metrics,
            hl_defs,
            segments,
            i,
        );
    }
}

/// Renders `line` to `context.cairo_context`.
pub fn put_line(
    context: &mut Context,
    pango_context: &pango::Context,
    line: GridLineSegment,
    hl_defs: &HlDefs,
) {
    let row = line.row as usize;
    let mut affected_segments = context
        .rows
        .get_mut(row)
        .expect(&format!("Failed to get row {}", line.row))
        .update(line);

    // NOTE(ville): I haven't noticed any cases where a character is overflowing
    //              to the left. Probably doesn't apply to languages that goes
    //              from right to left, instead of left to right.
    // Rendering the segments in reversed order fixes issues when some character
    // is overflowing to the right.
    affected_segments.reverse();
    put_segments(
        &context.cairo_context,
        pango_context,
        &mut context.queue_draw_area,
        &context.cell_metrics,
        hl_defs,
        affected_segments,
        row,
    );
}

/// Clears whole `da` with `hl_defs.default_bg`.
pub fn clear(da: &DrawingArea, ctx: &mut Context, hl_defs: &HlDefs) {
    let cr = &ctx.cairo_context;
    let w = da.get_allocated_width();
    let h = da.get_allocated_height();
    let bg = &hl_defs.default_bg;

    cr.save();
    cr.set_source_rgb(bg.r, bg.g, bg.b);
    cr.rectangle(0.0, 0.0, f64::from(w), f64::from(h));
    cr.fill();
    cr.restore();

    ctx.queue_draw_area
        .push((0.0, 0.0, f64::from(w), f64::from(h)));
}

/// Scrolls contents in `ctx.cairo_context` and `ctx.rows`, based on `reg`.
pub fn scroll(ctx: &mut Context, hl_defs: &HlDefs, reg: [u64; 4], count: i64) {
    let cr = &ctx.cairo_context;
    let cm = &ctx.cell_metrics;
    let bg = &hl_defs.default_bg;

    let s = cr.get_target();

    let top = reg[0];
    let bot = reg[1];
    let left = reg[2];
    let right = reg[3];

    let (src_top, src_bot<