/*
 *   mooterm/mootermdraw.c
 *
 *   Copyright (C) 2004-2005 by Yevgen Muntyan <muntyan@math.tamu.edu>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   See COPYING file that comes with this distribution.
 */

#define MOOTERM_COMPILATION
#include "mooterm/mooterm-private.h"
#include "mooterm/mooterm-selection.h"
#include "mooterm/mootermbuffer-private.h"
#include <string.h>

#define CHAR_WIDTH(term)    ((term)->priv->font->width)
#define CHAR_HEIGHT(term)   ((term)->priv->font->height)
#define CHAR_ASCENT(term)   ((term)->priv->font->ascent)
#define PIXEL_WIDTH(term)   (CHAR_WIDTH (term) * (term)->priv->width)
#define PIXEL_HEIGHT(term)  (CHAR_HEIGHT (term) * (term)->priv->height)

#define CHARS \
"`1234567890-=~!@#$%^&*()_+qwertyuiop[]\\QWERTYUIOP"\
"{}|asdfghjkl;'ASDFGHJKL:\"zxcvbnm,./ZXCVBNM<>?"

#define HOW_MANY(x, y) (((x) + (y) - 1) / (y))


static void moo_term_invalidate_content_all (MooTerm        *term);
static void moo_term_invalidate_content_rect(MooTerm        *term,
                                             GdkRectangle   *rect);


static void font_calculate  (MooTermFont *font)
{
    PangoRectangle logical;
    PangoLayout *layout;
    PangoLayoutIter *iter;

    g_assert (font->ctx != NULL);

    layout = pango_layout_new (font->ctx);
    pango_layout_set_text (layout, CHARS, strlen(CHARS));
    pango_layout_get_extents (layout, NULL, &logical);

    font->width = HOW_MANY (logical.width, strlen (CHARS));
    font->width = PANGO_PIXELS (font->width);

    iter = pango_layout_get_iter (layout);
    font->height = PANGO_PIXELS (logical.height);
    font->ascent = PANGO_PIXELS (pango_layout_iter_get_baseline (iter));

    pango_layout_iter_free (iter);
    g_object_unref (layout);
}


static MooTermFont  *moo_term_font_new  (PangoContext   *ctx)
{
    MooTermFont *font = g_new0 (MooTermFont, 1);

    font->ctx = ctx;
    g_object_ref (ctx);

    font_calculate (font);

    return font;
}


void        moo_term_set_font_from_string   (MooTerm        *term,
                                             const char     *font)
{
    PangoFontDescription *font_desc;

    if (font)
    {
        font_desc = pango_font_description_from_string (font);
    }
    else
    {
        GtkWidget *widget = GTK_WIDGET (term);
        gtk_widget_ensure_style (widget);
        font_desc =
                pango_font_description_copy_static (widget->style->font_desc);
    }

    g_return_if_fail (font_desc != NULL);

    if (!pango_font_description_get_size (font_desc))
    {
        pango_font_description_free (font_desc);
        g_return_if_reached ();
    }

    g_free (term->priv->font->name);
    term->priv->font->name = g_strdup (font);
    pango_context_set_font_description (term->priv->font->ctx, font_desc);

    font_calculate (term->priv->font);

    if (GTK_WIDGET_REALIZED (term))
        moo_term_size_changed (term);

    pango_font_description_free (font_desc);
}


void        moo_term_init_font_stuff    (MooTerm        *term)
{
    PangoContext *ctx;

    if (term->priv->font)
        moo_term_font_free (term->priv->font);

    gtk_widget_ensure_style (GTK_WIDGET (term));

    ctx = gtk_widget_create_pango_context (GTK_WIDGET (term));
    g_return_if_fail (ctx != NULL);

    term->priv->font = moo_term_font_new (ctx);
    term->priv->layout = pango_layout_new (ctx);

    g_object_unref (ctx);

    gtk_widget_set_size_request (GTK_WIDGET (term),
                                 term->priv->font->width * MIN_TERMINAL_WIDTH,
                                 term->priv->font->height * MIN_TERMINAL_HEIGHT);
}


void    moo_term_font_free  (MooTermFont    *font)
{
    if (font)
    {
        g_object_unref (font->ctx);
        g_free (font->name);
        g_free (font);
    }
}


static gboolean process_updates     (MooTerm    *term)
{
    gdk_window_process_updates (GTK_WIDGET(term)->window, FALSE);
    term->priv->pending_expose = 0;
    return FALSE;
}

static void     add_update_timeout  (MooTerm    *term)
{
    if (!term->priv->pending_expose)
    {
        term->priv->pending_expose =
                g_timeout_add_full (EXPOSE_PRIORITY,
                                    EXPOSE_TIMEOUT,
                                    (GSourceFunc) process_updates,
                                    term,
                                    NULL);
    }
}

static void     remove_update_timeout   (MooTerm    *term)
{
    if (term->priv->pending_expose)
        g_source_remove (term->priv->pending_expose);

    term->priv->pending_expose = 0;
}


void        moo_term_invalidate_all         (MooTerm        *term)
{
    GdkRectangle rec = {0, 0, term->priv->width, term->priv->height};
    moo_term_invalidate_rect (term, &rec);
}


void        moo_term_invalidate_rect    (MooTerm        *term,
                                         GdkRectangle   *rect)
{
    if (GTK_WIDGET_REALIZED (term))
    {
        GdkRectangle r = {
            rect->x * CHAR_WIDTH(term),
            rect->y * CHAR_HEIGHT(term),
            rect->width * CHAR_WIDTH(term),
            rect->height * CHAR_HEIGHT(term)
        };

        gdk_window_invalidate_rect (GTK_WIDGET(term)->window,
                                    &r, FALSE);
        moo_term_invalidate_content_rect (term, rect);
        add_update_timeout (term);
    }
}


void        moo_term_init_palette       (MooTerm        *term)
{
    int i;
    GtkWidget *widget = GTK_WIDGET (term);

    gtk_widget_ensure_style (widget);

    term->priv->fg_color[0] = widget->style->text[GTK_STATE_NORMAL];
    term->priv->fg_color[1] = widget->style->text[GTK_STATE_NORMAL];
    term->priv->bg_color = widget->style->base[GTK_STATE_NORMAL];

    for (i = 0; i < 2; ++i)
    {
        gdk_color_parse ("black", &term->priv->palette[8*i + MOO_TERM_BLACK]);
        gdk_color_parse ("red", &term->priv->palette[8*i + MOO_TERM_RED]);
        gdk_color_parse ("green", &term->priv->palette[8*i + MOO_TERM_GREEN]);
        gdk_color_parse ("yellow", &term->priv->palette[8*i + MOO_TERM_YELLOW]);
        gdk_color_parse ("blue", &term->priv->palette[8*i + MOO_TERM_BLUE]);
        gdk_color_parse ("magenta", &term->priv->palette[8*i + MOO_TERM_MAGENTA]);
        gdk_color_parse ("cyan", &term->priv->palette[8*i + MOO_TERM_CYAN]);
        gdk_color_parse ("white", &term->priv->palette[8*i + MOO_TERM_WHITE]);
    }
}


void        moo_term_setup_palette      (MooTerm        *term)
{
    int i, j;
    GtkWidget *widget = GTK_WIDGET (term);
    GdkColormap *colormap;
    GdkGCValues vals;

    g_return_if_fail (GTK_WIDGET_REALIZED (widget));

    colormap = gdk_colormap_get_system ();
    g_return_if_fail (colormap != NULL);

    gdk_colormap_alloc_color (colormap, &term->priv->fg_color[0],
                              TRUE, TRUE);
    gdk_colormap_alloc_color (colormap, &term->priv->fg_color[1],
                              TRUE, TRUE);
    gdk_colormap_alloc_color (colormap, &term->priv->bg_color,
                              TRUE, TRUE);

    term->priv->fg[0] =
            gdk_gc_new_with_values (widget->window, &vals, 0);
    term->priv->fg[1] =
            gdk_gc_new_with_values (widget->window, &vals, 0);
    term->priv->bg =
            gdk_gc_new_with_values (widget->window, &vals, 0);

    gdk_gc_set_foreground (term->priv->fg[0], &term->priv->fg_color[0]);
    gdk_gc_set_foreground (term->priv->fg[1], &term->priv->fg_color[1]);
    gdk_gc_set_foreground (term->priv->bg, &term->priv->bg_color);

    gdk_window_set_background (widget->window, &term->priv->bg_color);

    for (i = 0; i < MOO_TERM_COLOR_MAX; ++i)
        for (j = 0; j < 2; ++j)
            gdk_colormap_alloc_color (colormap,
                                      &term->priv->palette[8*j + i],
                                      TRUE, TRUE);

    for (i = 0; i < MOO_TERM_COLOR_MAX; ++i)
        for (j = 0; j < 2; ++j)
    {
        vals.foreground = term->priv->palette[8*j + i];
        term->priv->color[8*j + i] =
                gdk_gc_new_with_values (widget->window,
                                        &vals,
                                        GDK_GC_FOREGROUND);
    }
}


static void invalidate_screen_cell      (MooTerm        *term,
                                         guint           row,
                                         guint           column)
{
    int scrollback, top_line;
    GdkRectangle small_rect = {0, 0, 1, 1};

    scrollback = buf_scrollback (term->priv->buffer);
    top_line = term_top_line (term);

    small_rect.x = column;
    small_rect.y = row + scrollback - top_line;

    moo_term_invalidate_rect (term, &small_rect);
}


void        moo_term_cursor_moved       (MooTerm        *term,
                                         MooTermBuffer  *buf)
{
    int new_row, new_col;

    if (buf != term->priv->buffer)
        return;

    new_row = buf_cursor_row (buf);
    new_col = buf_cursor_col (buf);

    if (term->priv->cursor_visible && term->priv->blink_cursor_visible)
    {
        invalidate_screen_cell (term,
                                term->priv->cursor_row,
                                term->priv->cursor_col);
        invalidate_screen_cell (term, new_row, new_col);
    }

    term->priv->cursor_col = new_col;
    term->priv->cursor_row = new_row;
}


void        moo_term_init_back_pixmap       (MooTerm        *term)
{
    if (term->priv->back_pixmap)
        return;

    term->priv->back_pixmap =
            gdk_pixmap_new (GTK_WIDGET(term)->window,
                            PIXEL_WIDTH(term), PIXEL_HEIGHT(term), -1);

    term->priv->clip = gdk_gc_new (term->priv->back_pixmap);
    gdk_gc_set_clip_origin (term->priv->clip, 0, 0);

    moo_term_invalidate_content_all (term);
}


void        moo_term_resize_back_pixmap     (MooTerm        *term)
{
    if (term->priv->font_changed)
    {
        GdkPixmap *pix;

        term->priv->font_changed = FALSE;

        pix = gdk_pixmap_new (term->priv->back_pixmap,
                              PIXEL_WIDTH(term), PIXEL_HEIGHT(term), -1);

        g_object_unref (term->priv->back_pixmap);
        term->priv->back_pixmap = pix;

        moo_term_invalidate_content_all (term);
    }
    else
    {
        GdkPixmap *pix;
        GdkRegion *region;
        int old_width, old_height;
        int width = PIXEL_WIDTH(term);
        int height = PIXEL_HEIGHT(term);
        GdkRectangle rec = {0, 0, width, height};

        pix = gdk_pixmap_new (term->priv->back_pixmap,
                              width, height, -1);

        gdk_drawable_get_size (term->priv->back_pixmap,
                               &old_width, &old_height);

        gdk_gc_set_clip_rectangle (term->priv->clip, &rec);
        gdk_draw_drawable (pix, term->priv->clip,
                           term->priv->back_pixmap,
                           0, 0, 0, 0,
                           MIN (width, old_width),
                           MIN (height, old_height));

        if (width > old_width)
        {
            rec.x = old_width / CHAR_WIDTH(term);
            rec.width = (width - old_width) / CHAR_WIDTH(term);
            rec.y = 0;
            rec.height = height / CHAR_HEIGHT(term);
            moo_term_invalidate_content_rect (term, &rec);
        }

        if (height > old_height)
        {
            rec.x = 0;
            rec.width = width / CHAR_WIDTH(term);
            rec.y = old_height / CHAR_HEIGHT(term);
            rec.height = (height - old_height) / CHAR_HEIGHT(term);
            moo_term_invalidate_content_rect (term, &rec);
        }

        rec.x = rec.y = 0;
        rec.width = width / CHAR_WIDTH(term);
        rec.height = height / CHAR_HEIGHT(term);
        if (term->priv->changed_content)
        {
            region = gdk_region_rectangle (&rec);
            gdk_region_intersect (term->priv->changed_content, region);
            gdk_region_destroy (region);
        }

        g_object_unref (term->priv->back_pixmap);
        term->priv->back_pixmap = pix;
    }
}


/* absolute row */
static void term_draw_range                 (MooTerm        *term,
                                             guint           row,
                                             guint           start,
                                             guint           len);

void        moo_term_update_back_pixmap     (MooTerm        *term)
{
    GdkRectangle *rects = NULL;
    int n_rects;
    int i, j;
    int top_line = term_top_line (term);
    int width = term->priv->width;
    int height = term->priv->height;
    GdkRectangle clip = {0, 0, width, height};

    if (!term->priv->changed_content)
        return;

    gdk_region_get_rectangles (term->priv->changed_content,
                               &rects, &n_rects);

    for (i = 0; i < n_rects; ++i)
    {
        if (gdk_rectangle_intersect (&rects[i], &clip, &rects[i]))
        {
            for (j = 0; j < rects[i].height; ++j)
                term_draw_range (term, top_line + rects[i].y + j,
                                 rects[i].x, rects[i].width);
        }
    }

    g_free (rects);
    gdk_region_destroy (term->priv->changed_content);
    term->priv->changed_content = NULL;
}


static void moo_term_invalidate_content_all (MooTerm        *term)
{
    GdkRectangle rect = {0, 0, term->priv->width, term->priv->height};
    moo_term_invalidate_content_rect (term, &rect);
}


static void moo_term_invalidate_content_rect(MooTerm        *term,
                                             GdkRectangle   *rect)
{
    if (term->priv->changed_content)
        gdk_region_union_with_rect (term->priv->changed_content, rect);
    else
        term->priv->changed_content = gdk_region_rectangle (rect);
}


gboolean    moo_term_expose_event       (GtkWidget      *widget,
                                         GdkEventExpose *event)
{
    GdkRectangle text_rec = {0, 0, 0, 0};
    GdkRegion *text_reg;

    MooTerm *term = MOO_TERM (widget);

    g_assert (term_top_line (term) <= buf_scrollback (term->priv->buffer));

    remove_update_timeout (term);

    text_rec.width = PIXEL_WIDTH(term);
    text_rec.height = PIXEL_HEIGHT(term);

    if (event->area.x + event->area.width >= text_rec.width)
    {
        gdk_draw_rectangle (widget->window,
                            term->priv->bg, TRUE,
                            text_rec.width, 0,
                            CHAR_WIDTH(term),
                            widget->allocation.height);
    }

    if (event->area.y + event->area.height >= text_rec.height)
    {
        gdk_draw_rectangle (widget->window,
                            term->priv->bg, TRUE,
                            0, text_rec.height,
                            widget->allocation.width,
                            CHAR_HEIGHT(term));
    }

    text_reg = gdk_region_rectangle (&text_rec);
    gdk_region_intersect (event->region, text_reg);
    gdk_region_destroy (text_reg);

    if (!gdk_region_empty (event->region))
    {
        moo_term_update_back_pixmap (term);
        gdk_gc_set_clip_region (term->priv->clip,
                                event->region);
        gdk_draw_drawable (event->window,
                           term->priv->clip,
                           term->priv->back_pixmap,
                           0, 0, 0, 0,
                           text_rec.width,
                           text_rec.height);
    }

    return TRUE;
}


/****************************************************************************/
/* Drawing
 */

static void term_draw_range_simple          (MooTerm        *term,
                                             guint           abs_row,
                                             guint           start,
                                             guint           len,
                                             int             selected);
static void term_draw_cells                 (MooTerm        *term,
                                             guint           abs_row,
                                             guint           start,
                                             guint           len,
                                             MooTermTextAttr *attr,
                                             int             selected);
static void term_draw_cursor                (MooTerm        *term);

static void term_draw_range                 (MooTerm        *term,
                                             guint           abs_row,
                                             guint           start,
                                             guint           len)
{
    int selected;
    guint first = start;
    guint last = start + len;

    g_return_if_fail (len != 0);
    g_assert (start + len <= term->priv->width);
    g_assert (abs_row < buf_total_height (term->priv->buffer));

    if (term->priv->cursor_visible && term->priv->blink_cursor_visible &&
        term->priv->cursor_row + buf_scrollback (term->priv->buffer) == abs_row)
    {
        guint cursor = buf_cursor_col (term->priv->buffer);

        if (cursor >= start && cursor < start + len)
        {
            if (cursor > start)
                term_draw_range (term, abs_row,
                                 start, cursor - start);

            term_draw_cursor (term);

            if (cursor < start + len - 1)
                term_draw_range (term, abs_row,
                                 cursor + 1, start + len - 1 - cursor);

            return;
        }
    }

    selected = moo_term_row_selected (term, abs_row);

    switch (selected)
    {
        case FULL_SELECTED:
        case NOT_SELECTED:
            term_draw_range_simple (term, abs_row, first, len, selected);
            break;

        case PART_SELECTED:
        {
            guint l_row, l_col, r_row, r_col;

            moo_term_get_selection_bounds (term, &l_row, &l_col,
                                           &r_row, &r_col);

            if (l_row == r_row)
            {
                g_assert (abs_row == l_row);

                if (r_col <= first || last <= l_col)
                {
                    term_draw_range_simple (term, abs_row,
                                            first, len, FALSE);
                }
                else if (l_col <= first && last <= r_col)
                {
                    term_draw_range_simple (term, abs_row,
                                            first, len, TRUE);
                }
                else if (first < l_col)
                {
                    term_draw_range_simple (term, abs_row,
                                       first, l_col - first, FALSE);
                    term_draw_range_simple (term, abs_row, l_col,
                                       MIN (last, r_col) - l_col, TRUE);

                    if (r_col < last)
                        term_draw_range_simple (term, abs_row,
                                           r_col, last - r_col, FALSE);
                }
                else
                {
                    term_draw_range_simple (term, abs_row, first,
                                       MIN (last, r_col) - first, TRUE);

                    if (r_col < last)
                        term_draw_range_simple (term, abs_row,
                                           r_col, last - r_col, FALSE);
                }
            }
            else if (l_row == abs_row)
            {
                if (last <= l_col)
                {
                    term_draw_range_simple (term, abs_row,
                                       first, len, FALSE);
                }
                else if (l_col <= first)
                {
                    term_draw_range_simple (term, abs_row,
                                       first, len, TRUE);
                }
                else
                {
                    term_draw_range_simple (term, abs_row,
                                       first, l_col - first, FALSE);
                    term_draw_range_simple (term, abs_row,
                                       l_col, last - l_col, TRUE);
                }
            }
            else
            {
                g_assert (abs_row == r_row);

                if (last <= r_col)
                {
                    term_draw_range_simple (term, abs_row,
                                       first, len, TRUE);
                }
                else if (r_col <= first)
                {
                    term_draw_range_simple (term, abs_row,
                                       first, len, FALSE);
                }
                else {
                    term_draw_range_simple (term, abs_row,
                                       first, r_col - first, TRUE);
                    term_draw_range_simple (term, abs_row,
                                       r_col, last - r_col, FALSE);
                }
            }
            break;
        }

        default:
            g_assert_not_reached ();
    }
}


static void term_draw_range_simple          (MooTerm        *term,
                                             guint           abs_row,
                                             guint           start,
                                             guint           len,
                                             gboolean        selected)
{
    MooTermLine *line = buf_line (term->priv->buffer, abs_row);
    int y = (abs_row - term_top_line (term)) * CHAR_HEIGHT(term);
    GdkGC *bg;
    guint invert;

    g_assert (selected == 0 || selected == 1);

    invert = (selected ? 1 : 0) + (term->priv->colors_inverted ? 1 : 0);
    invert %= 2;

    if (!invert)
        bg = term->priv->bg;
    else
        bg = term->priv->fg[COLOR_NORMAL];

    if (start >= moo_term_line_len (line))
    {
        gdk_draw_rectangle (term->priv->back_pixmap,
                            bg,
                            TRUE,
                            start * CHAR_WIDTH(term),
                            y,
                            len * CHAR_WIDTH(term),
                            CHAR_HEIGHT(term));

        return;
    }
    else if (start + len > moo_term_line_len (line))
    {
        gdk_draw_rectangle (term->priv->back_pixmap,
                            bg,
                            TRUE,
                            moo_term_line_len (line) * CHAR_WIDTH(term),
                            y,
                            (start + len - moo_term_line_len (line)) * CHAR_WIDTH(term),
                            CHAR_HEIGHT(term));

        len = moo_term_line_len (line) - start;
    }

    g_assert (start + len <= moo_term_line_len (line));

    while (len)
    {
        guint i;
        MooTermTextAttr *attr = moo_term_line_attr (line, start);

        for (i = 1; i < len && !ATTR_CMP (attr, moo_term_line_attr (line, start + i)); ++i) ;

        term_draw_cells (term, abs_row, start, i, attr, selected);

        len -= i;
        start += i;
    }
}


static void term_draw_cells                 (MooTerm        *term,
                                             guint           abs_row,
                                             guint           start,
                                             guint           len,
                                             MooTermTextAttr *attr,
                                             gboolean        selected)
{
    static char buf[8 * MAX_TERMINAL_WIDTH];
    guint buf_len;
    GdkGC *fg = NULL;
    GdkGC *bg = NULL;
    guint bold;
    guint invert;

    MooTermLine *line = buf_line (term->priv->buffer, abs_row);

    g_assert (len != 0);
    g_assert (start + len <= moo_term_line_len (line));

    buf_len = moo_term_line_get_chars (line, buf, start, len);
    g_return_if_fail (buf_len != 0);

    pango_layout_set_text (term->priv->layout, buf, buf_len);

    bold = (attr->mask & MOO_TERM_TEXT_BOLD) ? COLOR_BOLD : COLOR_NORMAL;

    if (attr->mask & MOO_TERM_TEXT_FOREGROUND)
    {
        g_return_if_fail (attr->foreground < MOO_TERM_COLOR_MAX);
        fg = term->priv->color[8*bold + attr->foreground];
    }
    else
    {
        fg = term->priv->fg[bold];
    }

    if (attr->mask & MOO_TERM_TEXT_BACKGROUND)
    {
        g_return_if_fail (attr->foreground < MOO_TERM_COLOR_MAX);
        bg = term->priv->color[8*bold + attr->background];
    }
    else
    {
        bg = term->priv->bg;
    }

    invert = (selected ? 1 : 0) + (term->priv->colors_inverted ? 1 : 0) +
            (attr->mask & MOO_TERM_TEXT_REVERSE ? 1 : 0);
    invert %= 2;

    if (invert)
    {
        GdkGC *tmp = fg;
        fg = bg;
        bg = tmp;
    }

    gdk_draw_rectangle (term->priv->back_pixmap,
                        bg,
                        TRUE,
                        start * CHAR_WIDTH(term),
                        (abs_row - term_top_line (term)) * CHAR_HEIGHT(term),
                        len * CHAR_WIDTH(term),
                        CHAR_HEIGHT(term));

    gdk_draw_layout (term->priv->back_pixmap,
                     fg,
                     start * CHAR_WIDTH(term),
                     (abs_row - term_top_line (term)) * CHAR_HEIGHT(term),
                     term->priv->layout);

    if ((attr->mask & MOO_TERM_TEXT_BOLD) && term->priv->settings.allow_bold)
        gdk_draw_layout (term->priv->back_pixmap,
                         fg,
                         start * CHAR_WIDTH(term) + 1,
                         (abs_row - term_top_line (term)) * CHAR_HEIGHT(term),
                         term->priv->layout);

    if (attr->mask & MOO_TERM_TEXT_UNDERLINE)
        gdk_draw_line (term->priv->back_pixmap,
                       fg,
                       start * CHAR_WIDTH(term),
                       (abs_row - term_top_line (term)) * CHAR_HEIGHT(term) + CHAR_ASCENT(term) + 1,
                       (start + len) * CHAR_WIDTH(term) + 1,
                       (abs_row - term_top_line (term)) * CHAR_HEIGHT(term) + CHAR_ASCENT(term) + 1);
}


static void term_draw_cursor                (MooTerm        *term)
{
    guint scrollback = buf_scrollback (term->priv->buffer);
    guint abs_row = term->priv->cursor_row + scrollback;
    guint column = term->priv->cursor_col;
    MooTermLine *line = buf_line (term->priv->buffer, abs_row);

    if (moo_term_line_len (line) > column)
    {
        return term_draw_cells (term, abs_row, column, 1,
                                moo_term_line_attr (line, column),
                                !moo_term_cell_selected (term, abs_row, column));
    }
    else
    {
        GdkGC *color;
        guint invert;

        invert = 1 + (moo_term_cell_selected (term, abs_row, column) ? 1 : 0) +
                (term->priv->colors_inverted ? 1 : 0);
        invert %= 2;

        if (invert)
            color = term->priv->fg[COLOR_NORMAL];
        else
            color = term->priv->bg;

        gdk_draw_rectangle (term->priv->back_pixmap,
                            color,
                            TRUE,
                            column * CHAR_WIDTH(term),
                            (abs_row - term_top_line (term)) * CHAR_HEIGHT(term),
                            CHAR_WIDTH(term),
                            CHAR_HEIGHT(term));
    }
}


void        moo_term_buf_content_changed(MooTerm        *term,
                                         MooTermBuffer  *buf)
{
    GdkRectangle *rect = NULL;
    GdkRegion *dirty, *changed;
    int n_rect, i;
    guint top_line, scrollback;
    int height;

    changed = buf_get_changed (buf);

    if (buf != term->priv->buffer || !changed || gdk_region_empty (changed))
        return;

    /* TODO TODO TODO*/
    buf->priv->changed = NULL;
    buf->priv->changed_all = FALSE;

    top_line = term_top_line (term);
    scrollback = buf_scrollback (buf);
    height = term->priv->height;

    g_assert (top_line <= scrollback);

    if (top_line != scrollback)
    {
        GdkRectangle clip = {0, 0, term->priv->width, height};
        GdkRegion *tmp;

        gdk_region_offset (changed, 0, scrollback - top_line);

        tmp = gdk_region_rectangle (&clip);
        gdk_region_intersect (changed, tmp);
        gdk_region_destroy (tmp);
    }

    if (gdk_region_empty (changed))
    {
        gdk_region_destroy (changed);
        return;
    }

    gdk_region_get_rectangles (changed, &rect, &n_rect);
    g_return_if_fail (rect != NULL);

    dirty = gdk_region_new ();

    for (i = 0; i < n_rect; ++i)
    {
        moo_term_invalidate_content_rect (term, &rect[i]);

        rect[i].x *= CHAR_WIDTH(term);
        rect[i].y *= CHAR_HEIGHT(term);
        rect[i].width *= CHAR_WIDTH(term);
        rect[i].height *= CHAR_HEIGHT(term);

        gdk_region_union_with_rect (dirty, &rect[i]);
    }

    gdk_window_invalidate_region (GTK_WIDGET(term)->window,
                                  dirty, FALSE);
    add_update_timeout (term);

    g_free (rect);
    gdk_region_destroy (changed);
    gdk_region_destroy (dirty);
}


void        moo_term_force_update           (MooTerm        *term)
{
    GdkRegion *region;
    GdkWindow *window = GTK_WIDGET (term)->window;

    region = gdk_window_get_update_area (window);

    if (region)
    {
        GdkEvent *event = gdk_event_new (GDK_EXPOSE);
        event->expose.window = g_object_ref (window);
        event->expose.send_event = TRUE;
        gdk_region_get_clipbox (region, &event->expose.area);
        event->expose.region = region;
        gtk_main_do_event (event);
        gdk_event_free (event);
    }
}


void        moo_term_invert_colors          (MooTerm    *term,
                                             gboolean    invert)
{
    if (invert != term->priv->colors_inverted)
    {
        moo_term_invalidate_all (term);
        term->priv->colors_inverted = invert;
    }
}


void        moo_term_set_cursor_visible     (MooTerm    *term,
                                             gboolean    visible)
{
    term->priv->cursor_visible = visible;
    invalidate_screen_cell (term,
                            term->priv->cursor_row,
                            term->priv->cursor_col);
}


static gboolean blink (MooTerm *term)
{
    term->priv->blink_cursor_visible =
            !term->priv->blink_cursor_visible;
    invalidate_screen_cell (term,
                            term->priv->cursor_row,
                            term->priv->cursor_col);
    return TRUE;
}


static void start_cursor_blinking  (MooTerm        *term)
{
    if (!term->priv->cursor_blink_timeout_id && term->priv->cursor_blinks)
        term->priv->cursor_blink_timeout_id =
                g_timeout_add (term->priv->cursor_blink_time,
                               (GSourceFunc) blink,
                               term);
}


static void stop_cursor_blinking   (MooTerm        *term)
{
    if (term->priv->cursor_blink_timeout_id)
    {
        g_source_remove (term->priv->cursor_blink_timeout_id);
        term->priv->cursor_blink_timeout_id = 0;
        term->priv->blink_cursor_visible = TRUE;
        invalidate_screen_cell (term,
                                term->priv->cursor_row,
                                term->priv->cursor_col);
    }
}


void        moo_term_pause_cursor_blinking  (MooTerm        *term)
{
    if (term->priv->cursor_blinks)
    {
        stop_cursor_blinking (term);
        start_cursor_blinking (term);
    }
}


void        moo_term_set_cursor_blinks      (MooTerm        *term,
                                             gboolean        blinks)
{
    term->priv->cursor_blinks = blinks;
    if (blinks)
        start_cursor_blinking (term);
    else
        stop_cursor_blinking (term);
    g_object_notify (G_OBJECT (term), "cursor-blinks");
}


void        moo_term_set_cursor_blink_time  (MooTerm        *term,
                                             guint           ms)
{
    if (ms)
    {
        term->priv->cursor_blink_time = ms;
        moo_term_set_cursor_blinks (term, TRUE);
        moo_term_pause_cursor_blinking (term);
    }
    else
    {
        moo_term_set_cursor_blinks (term, FALSE);
    }
}