medit/moo/mooterm/mooterm-text.c

/*
 *   mooterm/mootermselection.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-text-private.h"
#include "mooterm/mooterm-private.h"
#include "mooterm/mootermbuffer-private.h"
#include "mooterm/mooterm-selection.h"
#include "mooterm/mootermline-private.h"


typedef struct {
    MooTermIter start;
    MooTermIter end;
} Segment;

#define GET_SELECTION(term__) ((Segment*)(term__)->priv->selection)

#define ITER_TOTAL_HEIGHT(iter__) ((int)((iter__)->term->priv->height + buf_scrollback ((iter__)->buffer)))
#define ITER_TERM(iter__)   ((iter__)->term)
#define ITER_ROW(iter__)    ((iter__)->row)
#define ITER_COL(iter__)    ((iter__)->col)
#define ITER_WIDTH(iter__)  ((iter__)->width)

#define FILL_ITER(iter__,term__,row__,col__)                \
    (iter__)->term = term__;                                \
    (iter__)->buffer = term__->priv->buffer;                \
    (iter__)->line = buf_line ((iter__)->buffer, row__);    \
    (iter__)->row = row__;                                  \
    (iter__)->col = col__;                                  \
    (iter__)->width = term__->priv->width;                  \
    CHECK_ITER(iter__)


#ifdef DEBUG
static void CHECK_ITER (const MooTermIter *iter)
{
    g_assert (iter->term != NULL);
    g_assert ((int)iter->term->priv->width == iter->width);
    g_assert (iter->row >= 0);
    g_assert (iter->row < ITER_TOTAL_HEIGHT(iter));
    g_assert (iter->col >= 0);
    g_assert (iter->col <= iter->width);
}

static void CHECK_SEGMENT (const Segment *segment)
{
    CHECK_ITER (&segment->start);
    CHECK_ITER (&segment->end);
}
#else
#define CHECK_ITER(iter__)
#define CHECK_SEGMENT(segment__)
#endif


static void     get_start_iter      (MooTerm            *term,
                                     MooTermIter        *iter);
static void     get_end_iter        (MooTerm            *term,
                                     MooTermIter        *iter);
static int      iter_cmp            (const MooTermIter  *first,
                                     const MooTermIter  *second);
static void     iter_set_start      (MooTermIter        *iter);

static char    *segment_get_text    (Segment            *segment);
static void     invalidate_segment  (Segment            *segments,
                                     guint               num);

static void     middle_button_click (MooTerm            *term);
static void     right_button_click  (MooTerm            *term,
                                     GdkEventButton     *event);
#define MOUSE_STUFF(term__) (&(term__)->priv->mouse_stuff)


gpointer
_moo_term_selection_new  (MooTerm    *term)
{
    Segment *sel = g_new0 (Segment, 1);

    FILL_ITER (&sel->start, term, 0, 0);
    FILL_ITER (&sel->end, term, 0, 0);

    return sel;
}


void
_moo_term_selection_invalidate (MooTerm    *term)
{
    Segment *sel = term->priv->selection;

    invalidate_segment (sel, 1);
    FILL_ITER (&sel->start, term, 0, 0);
    FILL_ITER (&sel->end, term, 0, 0);

    _moo_term_release_selection (term);
}


static gboolean segment_empty (Segment *s)
{
    CHECK_SEGMENT (s);
    return !iter_cmp (&s->start, &s->end);
}


static int segment_sym_diff (Segment *s1, Segment *s2,
                             Segment *result)
{
    Segment *left = result;
    Segment *right = &result[1];

    CHECK_SEGMENT (s1);
    CHECK_SEGMENT (s2);

    if (segment_empty (s1))
    {
        if (segment_empty (s2))
        {
            return 0;
        }
        else
        {
            *left = *s2;
            CHECK_SEGMENT (left);
            return 1;
        }
    }
    else if (segment_empty (s2))
    {
        *left = *s1;
        CHECK_SEGMENT (left);
        return 1;
    }
    else
    {
        Segment tmp;
        MooTermIter itmp;

        *left = *s1;
        *right = *s2;
        _moo_term_iter_order (&left->start, &left->end);
        _moo_term_iter_order  (&right->start, &right->end);

        switch (iter_cmp (&left->start, &right->start))
        {
            case 0:
                switch (iter_cmp (&left->end, &right->end))
                {
                    case 0:
                        return 0;

                    case 1:
                        left->start = right->end;
                        CHECK_SEGMENT (left);
                        return 1;

                    case -1:
                        left->start = left->end;
                        left->end = right->end;
                        CHECK_SEGMENT (left);
                        return 1;
                }

            case 1:
                tmp = *left;
                *left = *right;
                *right = tmp;
                break;
        }

        switch (iter_cmp (&left->end, &right->start))
        {
            case 0:
                left->end = right->end;
                CHECK_SEGMENT (left);
                return 1;

            case -1:
                CHECK_SEGMENT (left);
                CHECK_SEGMENT (right);
                return 2;

            case 1:
                itmp = left->end;
                left->end = right->start;
                right->start = itmp;
                CHECK_SEGMENT (left);
                CHECK_SEGMENT (right);
                return 2;
        }
    }

    g_return_val_if_reached (0);
}


static void invalidate_segment (Segment *segm, guint num)
{
    MooTerm *term;
    int top_line;
    guint i;

    if (!num)
        return;

    term = ITER_TERM (&segm->start);
    top_line = term_top_line (term);

    for (i = 0; i < num; ++i)
    {
        MooTermIter start = segm[i].start;
        MooTermIter end = segm[i].end;
        GdkRectangle rect;

        _moo_term_iter_order  (&start, &end);

        if (ITER_ROW (&start) < ITER_ROW (&end))
        {
            if (ITER_COL (&start) < (int)term->priv->width)
            {
                rect.x = ITER_COL (&start);
                rect.width = term->priv->width - rect.x;
                rect.y = ITER_ROW (&start) - top_line;
                rect.height = 1;
                _moo_term_invalidate_rect (term, &rect);
            }

            if (ITER_ROW (&start) + 1 < ITER_ROW (&end))
            {
                rect.x = 0;
                rect.width = term->priv->width;
                rect.y = ITER_ROW (&start) + 1 - top_line;
                rect.height = ITER_ROW (&end) - ITER_ROW (&start) - 1;
                _moo_term_invalidate_rect (term, &rect);
            }

            if (ITER_COL (&end) > 0)
            {
                rect.x = 0;
                rect.width = ITER_COL (&end);
                rect.y = ITER_ROW (&end) - top_line;
                rect.height = 1;
                _moo_term_invalidate_rect (term, &rect);
            }
        }
        else
        {
            if (ITER_COL (&start) < ITER_COL (&end))
            {
                rect.x = ITER_COL (&start);
                rect.width = ITER_COL (&end) - ITER_COL (&start);
                rect.y = ITER_ROW (&start) - top_line;
                rect.height = 1;
                _moo_term_invalidate_rect (term, &rect);
            }
        }
    }
}


void
_moo_term_select_range (MooTerm            *term,
                        const MooTermIter  *start,
                        const MooTermIter  *end)
{
    Segment diff[2];
    Segment new_sel;
    Segment old_selection;
    gboolean inv = FALSE;

    CHECK_ITER (start);
    CHECK_ITER (end);

    old_selection = *GET_SELECTION (ITER_TERM (start));
    CHECK_SEGMENT (&old_selection);

    new_sel.start = *start;
    new_sel.end = *end;

    switch (iter_cmp (start, end))
    {
        case 0:
            iter_set_start (&new_sel.start);
            iter_set_start (&new_sel.end);
            break;

        case 1:
            inv = TRUE;
            break;
    }

    _moo_term_iter_order  (&new_sel.start, &new_sel.end);

    if (ITER_COL(&new_sel.start) == ITER_WIDTH(&new_sel.start))
    {
        g_assert (ITER_ROW(&new_sel.start) < ITER_TOTAL_HEIGHT(&new_sel.start));
        if (ITER_ROW(&new_sel.start) + 1 < ITER_TOTAL_HEIGHT(&new_sel.start))
        {
            ITER_ROW(&new_sel.start)++;
            ITER_COL(&new_sel.start) = 0;
        }
    }

    if (ITER_COL(&new_sel.end) == 0 && ITER_ROW(&new_sel.end) != 0)
    {
        ITER_ROW(&new_sel.end)--;
        ITER_COL(&new_sel.end) = ITER_WIDTH(&new_sel.start);
    }

    if (inv)
        _moo_term_iter_order  (&new_sel.end, &new_sel.start);

    CHECK_SEGMENT (&new_sel);

    *GET_SELECTION (ITER_TERM (start)) = new_sel;

    invalidate_segment (diff,
                        segment_sym_diff (&new_sel,
                                           &old_selection,
                                           diff));

    if (_moo_term_selection_empty (term))
        _moo_term_release_selection (term);
    else
        _moo_term_grab_selection (term);
}


static void     get_start_iter      (MooTerm            *term,
                                     MooTermIter        *iter)
{
    FILL_ITER (iter, term, 0, 0);
}


static void     get_end_iter        (MooTerm            *term,
                                     MooTermIter        *iter)
{
    int width = term->priv->width;
    int total_height = term->priv->height + buf_scrollback (term->priv->buffer);
    FILL_ITER (iter, term, total_height - 1, width);
}


/**************************************************************************/
/* mouse functionality
 */

static void     start_drag_scroll               (MooTerm    *term);
static void     stop_drag_scroll                (MooTerm    *term);
static gboolean drag_scroll_timeout_func        (MooTerm    *term);
static void     scroll_selection_end_onscreen   (MooTerm    *term);
static void     start_selection_dnd             (MooTerm    *term,
                                                 const MooTermIter *iter,
                                                 GdkEventMotion *event);

#define SCROLL_TIMEOUT 100


gboolean
_moo_term_button_press (GtkWidget      *widget,
                        GdkEventButton *event)
{
    MooTermIter iter;
    int x, y;
    MooTerm *term = MOO_TERM (widget);

    moo_term_set_pointer_visible (term, TRUE);

    if (!GTK_WIDGET_HAS_FOCUS (widget))
        gtk_widget_grab_focus (widget);

    moo_term_window_to_buffer_coords (term, event->x, event->y, &x, &y);
    moo_term_get_iter_at_location (term, &iter, x, y);

    if (event->type == GDK_BUTTON_PRESS)
    {
        if (event->button == 1)
        {
#if 0
            MooTermIter sel_start, sel_end;
#endif

            MOUSE_STUFF(term)->drag_button = GDK_BUTTON_PRESS;
            MOUSE_STUFF(term)->drag_start_x = x;
            MOUSE_STUFF(term)->drag_start_y = y;

#if 0
            /* TODO: implement drag'n'drop */
            /* if clicked in selected, start drag */
            if (_moo_term_get_selection_bounds (term, &sel_start, &sel_end))
            {
                moo_term_iter_order (&sel_start, &sel_end);
                if (_moo_term_iter_in_range (&iter, &sel_start, &sel_end)
                    && FALSE)
                {
                    /* clicked inside of selection,
                    * set up drag and return */
                    MOUSE_STUFF(term)->drag_type = DRAG_DRAG;
                    return TRUE;
                }
            }
#endif

            /* otherwise, clear selection, and position cursor at clicked point */
            if (event->state & GDK_SHIFT_MASK)
                _moo_term_place_selection_end (term, &iter);
            else
                _moo_term_select_range (term, &iter, &iter);

            MOUSE_STUFF(term)->drag_type = DRAG_SELECT;
        }
        else if (event->button == 2)
        {
            middle_button_click (term);
        }
        else if (event->button == 3)
        {
            right_button_click (term, event);
        }
        else
        {
            g_warning ("got button %d in button_press callback", event->button);
        }
    }
    else if (event->type == GDK_2BUTTON_PRESS && event->button == 1)
    {
        MooTermIter bound;

        if (_moo_term_get_selection_bounds (term, NULL, NULL))
        {
            /* it may happen sometimes, if you click fast enough */
            _moo_term_select_range (term, &iter, &iter);
        }

        MOUSE_STUFF(term)->drag_button = GDK_2BUTTON_PRESS;
        MOUSE_STUFF(term)->drag_start_x = x;
        MOUSE_STUFF(term)->drag_start_y = y;
        MOUSE_STUFF(term)->drag_type = DRAG_SELECT;

        bound = iter;

        if (_moo_term_extend_selection (term, MOO_TEXT_SELECT_WORDS, &iter, &bound))
            _moo_term_select_range (term, &bound, &iter);
    }
    else if (event->type == GDK_3BUTTON_PRESS && event->button == 1)
    {
        MooTermIter bound;

        MOUSE_STUFF(term)->drag_button = GDK_3BUTTON_PRESS;
        MOUSE_STUFF(term)->drag_start_x = x;
        MOUSE_STUFF(term)->drag_start_y = y;
        MOUSE_STUFF(term)->drag_type = DRAG_SELECT;

        bound = iter;

        if (_moo_term_extend_selection (term, MOO_TEXT_SELECT_LINES, &iter, &bound))
            _moo_term_select_range (term, &bound, &iter);
    }

    return TRUE;
}


gboolean
_moo_term_button_release (GtkWidget      *widget,
                          G_GNUC_UNUSED GdkEventButton *event)
{
    MooTerm *term = MOO_TERM (widget);
    MooTermIter iter;

    moo_term_set_pointer_visible (term, TRUE);

    switch (MOUSE_STUFF(term)->drag_type)
    {
        case DRAG_NONE:
            /* it may happen after right-click, or clicking outside
            * of widget or something like that
            * everything has been taken care of, so do nothing */
            break;

        case DRAG_SELECT:
            /* everything should be done already in button_press and
            * motion_notify handlers */
            stop_drag_scroll (term);
            break;

        case DRAG_DRAG:
            /* if we were really dragging, drop it
            * otherwise, it was just a single click in selected text */
            g_assert (!MOUSE_STUFF(term)->drag_moved); /* parent should handle drag */ /* TODO ??? */

            moo_term_get_iter_at_location (term, &iter,
                                           MOUSE_STUFF(term)->drag_start_x,
                                           MOUSE_STUFF(term)->drag_start_y);
            _moo_term_select_range (term, &iter, &iter);
            break;

        default:
            g_assert_not_reached ();
    }

    MOUSE_STUFF(term)->drag_moved = FALSE;
    MOUSE_STUFF(term)->drag_type = DRAG_NONE;
    MOUSE_STUFF(term)->drag_start_x = -1;
    MOUSE_STUFF(term)->drag_start_y = -1;
    MOUSE_STUFF(term)->drag_button = GDK_BUTTON_RELEASE;

    return TRUE;
}


#define OUTSIDE(x,y,rect)               \
    ((x) < (rect).x ||                  \
     (y) < (rect).y ||                  \
     (x) >= (rect).x + (rect).width ||  \
     (y) >= (rect).y + (rect).height)


gboolean
_moo_term_motion_notify (GtkWidget      *widget,
                         GdkEventMotion *event)
{
    MooTerm *term = MOO_TERM (widget);
    int x, y, event_x, event_y;
    MooTermIter iter;

    moo_term_set_pointer_visible (MOO_TERM (widget), TRUE);

    if (!MOUSE_STUFF(term)->drag_type)
        return FALSE;

    if (event->is_hint)
    {
        gdk_window_get_pointer (event->window, &event_x, &event_y, NULL);
    }
    else {
        event_x = (int)event->x;
        event_y = (int)event->y;
    }

    moo_term_window_to_buffer_coords (term, event_x, event_y, &x, &y);
    moo_term_get_iter_at_location (term, &iter, x, y);

    if (MOUSE_STUFF(term)->drag_type == DRAG_SELECT)
    {
        GdkRectangle rect;
        MooTermIter start;
        MooTextSelectionType t;

        MOUSE_STUFF(term)->drag_moved = TRUE;
        _moo_term_get_visible_rect (term, &rect);

        if (OUTSIDE (x, y, rect))
        {
            start_drag_scroll (term);
            return TRUE;
        }
        else
        {
            stop_drag_scroll (term);
        }

        moo_term_get_iter_at_location (term, &start,
                                       MOUSE_STUFF(term)->drag_start_x,
                                       MOUSE_STUFF(term)->drag_start_y);

        switch (MOUSE_STUFF(term)->drag_button)
        {
            case GDK_BUTTON_PRESS:
                t = MOO_TEXT_SELECT_CHARS;
                break;
            case GDK_2BUTTON_PRESS:
                t = MOO_TEXT_SELECT_WORDS;
                break;
            default:
                t = MOO_TEXT_SELECT_LINES;
        }

        if (_moo_term_extend_selection (term, t, &iter, &start))
            _moo_term_select_range (term, &start, &iter);
        else
            _moo_term_select_range (term, &iter, &iter);
    }
    else
    {
        /* this piece is from gtktextview.c */
        int x, y;

        gdk_window_get_pointer (widget->window, &x, &y, NULL);

        if (gtk_drag_check_threshold (widget, MOUSE_STUFF(term)->drag_start_x,
                                      MOUSE_STUFF(term)->drag_start_y, x, y))
        {
            MooTermIter iter;
            int buffer_x, buffer_y;

            moo_term_window_to_buffer_coords (term,
                                              MOUSE_STUFF(term)->drag_start_x,
                                              MOUSE_STUFF(term)->drag_start_y,
                                              &buffer_x, &buffer_y);

            moo_term_get_iter_at_location (term, &iter, buffer_x, buffer_y);

            MOUSE_STUFF(term)->drag_type = DRAG_NONE;
            start_selection_dnd (term, &iter, event);
        }
    }

    return TRUE;
}


static void
start_drag_scroll (MooTerm *term)
{
    if (!MOUSE_STUFF(term)->drag_scroll_timeout)
        MOUSE_STUFF(term)->drag_scroll_timeout =
                g_timeout_add (SCROLL_TIMEOUT,
                               (GSourceFunc) drag_scroll_timeout_func,
                               term);

    drag_scroll_timeout_func (term);
}


static void
stop_drag_scroll (MooTerm *term)
{
    if (MOUSE_STUFF(term)->drag_scroll_timeout)
        g_source_remove (MOUSE_STUFF(term)->drag_scroll_timeout);
    MOUSE_STUFF(term)->drag_scroll_timeout = 0;
}


static gboolean
drag_scroll_timeout_func (MooTerm *term)
{
    int x, y, px, py;
    MooTermIter iter;
    MooTermIter start;
    MooTextSelectionType t;

    g_assert (MOUSE_STUFF(term)->drag_type == DRAG_SELECT);

    gdk_window_get_pointer (GTK_WIDGET(term)->window, &px, &py, NULL);
    moo_term_window_to_buffer_coords (term, px, py, &x, &y);
    moo_term_get_iter_at_location (term, &iter, x, y);

    moo_term_get_iter_at_location (term, &start,
                                   MOUSE_STUFF(term)->drag_start_x,
                                   MOUSE_STUFF(term)->drag_start_y);

    switch (MOUSE_STUFF(term)->drag_button)
    {
        case GDK_BUTTON_PRESS:
            t = MOO_TEXT_SELECT_CHARS;
            break;
        case GDK_2BUTTON_PRESS:
            t = MOO_TEXT_SELECT_WORDS;
            break;
        default:
            t = MOO_TEXT_SELECT_LINES;
    }

    if (_moo_term_extend_selection (term, t, &iter, &start))
        _moo_term_select_range (term, &start, &iter);
    else
        _moo_term_select_range (term, &iter, &iter);

    scroll_selection_end_onscreen (term);

    return TRUE;
}


static void
scroll_selection_end_onscreen (MooTerm *term)
{
    MooTermIter iter = GET_SELECTION(term)->end;
    guint top_line = term_top_line (term);

    if (ITER_ROW(&iter) < (int)top_line)
        moo_term_scroll_lines (term, ITER_ROW(&iter) - (int)top_line);
    else if (ITER_ROW(&iter) >= (int)top_line + (int)term->priv->height)
        moo_term_scroll_lines (term, ITER_ROW(&iter) + 1 - (int)top_line -
                (int)term->priv->height);
}


static void
start_selection_dnd (G_GNUC_UNUSED MooTerm    *term,
                     G_GNUC_UNUSED const MooTermIter *iter,
                     G_GNUC_UNUSED GdkEventMotion *event)
{
    g_return_if_reached ();
}













gboolean
_moo_term_selection_empty (MooTerm    *term)
{
    return segment_empty (GET_SELECTION (term));
}


gboolean
_moo_term_get_selected_cells (MooTerm    *term,
                              guint      *left_row,
                              guint      *left_col,
                              guint      *right_row,
                              guint      *right_col)
{
    Segment *selection = GET_SELECTION (term);

    if (segment_empty (selection))
    {
        return FALSE;
    }
    else
    {
        MooTermIter start = selection->start;
        MooTermIter end = selection->end;

        _moo_term_iter_order  (&start, &end);

        if (left_row)
            *left_row = ITER_ROW (&start);
        if (left_col)
            *left_col = ITER_COL (&start);
        if (right_row)
            *right_row = ITER_ROW (&end);
        if (right_col)
            *right_col = ITER_COL (&end);

        return TRUE;
    }
}


void
_moo_term_selection_clear (MooTerm    *term)
{
    MooTermIter i;
    FILL_ITER (&i, term, 0, 0);
    _moo_term_select_range (term, &i, &i);
}


static void
middle_button_click (MooTerm *term)
{
    moo_term_paste_clipboard (term, GDK_SELECTION_PRIMARY);
}


static void
right_button_click (MooTerm        *term,
                    GdkEventButton *event)
{
    _moo_term_do_popup_menu (term, event);
}


void
moo_term_window_to_buffer_coords (MooTerm            *term,
                                  int                 window_x,
                                  int                 window_y,
                                  int                *buffer_x,
                                  int                *buffer_y)
{
    g_return_if_fail (MOO_IS_TERM (term));
    g_return_if_fail (buffer_x != NULL && buffer_y != NULL);
    *buffer_x = window_x;
    *buffer_y = window_y + (term_top_line (term) * term_char_height (term));
}


void
moo_term_get_iter_at_location (MooTerm            *term,
                               MooTermIter        *iter,
                               int                 x,
                               int                 y)
{
    int char_width = term_char_width (term);
    int char_height = term_char_height (term);
    int scrollback = buf_scrollback (term->priv->buffer);

    g_return_if_fail (iter != NULL);

    y /= char_height;

    x = CLAMP (x, 0, (int)term->priv->width * char_width - 1);
    x = (x % char_width > char_width / 2) ?
                            x / char_width + 1 :
                            x / char_width;

    if (y < 0)
    {
        y = 0;
        x = 0;
    }
    else if (y > scrollback + (int)term->priv->height - 1)
    {
        y = scrollback + (int)term->priv->height - 1;
        x = term->priv->width;
    }

    FILL_ITER (iter, term, y, x);
}


void
moo_term_get_iter_at_pos (MooTerm            *term,
                          MooTermIter        *iter,
                          int                 x,
                          int                 y)
{
    int char_width = term_char_width (term);
    int char_height = term_char_height (term);
    int scrollback = buf_scrollback (term->priv->buffer);

    g_return_if_fail (iter != NULL);

    y /= char_height;
    x /= char_width;
    x = CLAMP (x, 0, (int)term->priv->width);

    if (y < 0)
    {
        y = 0;
        x = 0;
    }
    else if (y > scrollback + (int)term->priv->height - 1)
    {
        y = scrollback + (int)term->priv->height - 1;
        x = term->priv->width;
    }

    FILL_ITER (iter, term, y, x);
}


gboolean
_moo_term_get_selection_bounds (MooTerm            *term,
                                MooTermIter        *sel_start,
                                MooTermIter        *sel_end)
{
    Segment *selection = term->priv->selection;

    if (sel_start)
        *sel_start = selection->start;

    if (sel_end)
        *sel_end = selection->end;

    return !_moo_term_selection_empty (term);
}


static int      iter_cmp                (const MooTermIter  *first,
                                         const MooTermIter  *second)
{
    g_assert (ITER_TERM (first) == ITER_TERM (second));

    if (ITER_ROW (first) < ITER_ROW (second))
        return -1;
    else if (ITER_ROW (first) > ITER_ROW (second))
        return 1;
    else if (ITER_COL (first) < ITER_COL (second))
        return -1;
    else if (ITER_COL (first) > ITER_COL (second))
        return 1;
    else
        return 0;
}


static void iter_set_start  (MooTermIter        *iter)
{
    ITER_ROW (iter) = ITER_COL (iter) = 0;
    CHECK_ITER (iter);
}


void
_moo_term_iter_order (MooTermIter    *first,
                      MooTermIter    *second)
{
    if (iter_cmp (first, second) > 0)
    {
        MooTermIter tmp = *first;
        *first = *second;
        *second = tmp;
    }
}


gboolean
_moo_term_iter_in_range (const MooTermIter  *iter,
                         const MooTermIter  *start,
                         const MooTermIter  *end)
{
    CHECK_ITER (iter);
    CHECK_ITER (start);
    CHECK_ITER (end);
    return iter_cmp (start, iter) <= 0 && iter_cmp (iter, end) <= 0;
}


void
_moo_term_place_selection_end (MooTerm            *term,
                               const MooTermIter  *where)
{
    CHECK_ITER (where);
    _moo_term_select_range (term, &GET_SELECTION(term)->start, where);
}


void
_moo_term_get_visible_rect (MooTerm            *term,
                           GdkRectangle       *rect)
{
    int char_height = term_char_height (term);
    rect->x = 0;
    rect->width = term->priv->width * term_char_width (term);
    rect->y = term_top_line (term) * char_height;
    rect->height = term->priv->height * char_height;
}


gboolean
_moo_term_cell_selected (MooTerm    *term,
                         guint       row,
                         guint       col)
{
    MooTermIter start, end, iter;

    if (_moo_term_get_selection_bounds (term, &start, &end))
    {
        _moo_term_iter_order  (&start, &end);
        FILL_ITER (&iter, term, row, col);
        return iter_cmp (&start, &iter) <= 0 && iter_cmp (&iter, &end) < 0;
    }
    else
    {
        return FALSE;
    }
}


int
_moo_term_row_selected (MooTerm    *term,
                        guint       row)
{
    guint l_row, l_col, r_row, r_col;

    if (_moo_term_get_selected_cells (term, &l_row, &l_col, &r_row, &r_col))
    {
        if (row < l_row || row > r_row)
            return NOT_SELECTED;
        else if (l_row < row && row < r_row)
            return FULL_SELECTED;
        else
            return PART_SELECTED;
    }
    else
    {
        return NOT_SELECTED;
    }
}


char       *moo_term_get_selection (MooTerm    *term)
{
    return segment_get_text (term->priv->selection);
}


static int      char_class              (MooTerm            *term,
                                         const MooTermIter  *iter);
static gboolean iter_ends_line          (const MooTermIter  *iter);
static gboolean iter_starts_line        (const MooTermIter  *iter);
static void     iter_forward_char       (MooTermIter        *iter);
static void     iter_backward_char      (MooTermIter        *iter);
static void     iter_set_line_offset    (MooTermIter        *iter,
                                         guint               offset);
static gboolean iter_forward_line       (MooTermIter        *iter);
static gboolean is_space                (const MooTermIter  *iter);
static gboolean is_word_char            (const MooTermIter  *iter);
static gunichar iter_get_char           (const MooTermIter  *iter);


gboolean
_moo_term_extend_selection (MooTerm            *term,
                            MooTextSelectionType type,
                            MooTermIter        *end,
                            MooTermIter        *start)
{
    int order = iter_cmp (start, end);

    CHECK_ITER (start);
    CHECK_ITER (end);

    if (type == MOO_TEXT_SELECT_CHARS)
    {
        return order;
    }

    if (order > 0)
    {
        MooTermIter *tmp = start;
        start = end; end = tmp;
    }

    if (type == MOO_TEXT_SELECT_WORDS)
    {
        int ch_class;

        ch_class = char_class (term, end);

        while (!iter_ends_line (end) &&
                char_class (term, end) == ch_class)
        {
            iter_forward_char (end);
        }

        ch_class = char_class (term, start);

        while (!iter_starts_line (start) &&
                char_class (term, start) == ch_class)
        {
            iter_backward_char (start);
        }

        if (char_class (term, start) != ch_class)
            iter_forward_char (start);

        return iter_cmp (start, end);
    }

    if (type == MOO_TEXT_SELECT_LINES)
    {
        iter_set_line_offset (start, 0);
        iter_forward_line (end);
        return iter_cmp (start, end);
    }

    g_return_val_if_reached (FALSE);
}


/* TODO */
static int
char_class (MooTerm            *term,
            const MooTermIter  *iter)
{
    if (iter_ends_line (iter))
        return -1;
    else if (is_space (iter))
        return 0;
    else if (is_word_char (iter))
        return 1;
    else
        return 2;
}


static gboolean
iter_ends_line (const MooTermIter *iter)
{
    CHECK_ITER (iter);
    return iter->col == (int)iter->term->priv->width;
}


static gboolean
iter_starts_line (const MooTermIter *iter)
{
    CHECK_ITER (iter);
    return iter->col == 0;
}


static void     iter_forward_char       (MooTermIter        *iter)
{
    MooTerm *term = iter->term;
    int width = term->priv->width;
    int total_height = term->priv->height + buf_scrollback (term->priv->buffer);

    g_return_if_fail (iter->row < total_height || iter->col < width);

    if (iter->col < width)
    {
        iter->col++;
    }
    else
    {
        iter->col = 0;
        iter->row++;
    }

    CHECK_ITER (iter);
}


static void     iter_backward_char      (MooTermIter        *iter)
{
    MooTerm *term = iter->term;
    int width = term->priv->width;

    g_return_if_fail (iter->row > 0 || iter->col > 0);

    if (iter->col > 0)
    {
        iter->col--;
    }
    else
    {
        iter->row--;
        iter->col = width;
    }

    CHECK_ITER (iter);
}


static void     iter_set_line_offset    (MooTermIter        *iter,
                                         guint               offset)
{
    g_return_if_fail (offset <= iter->term->priv->width);
    iter->col = offset;
    CHECK_ITER (iter);
}


static gboolean iter_forward_line       (MooTermIter        *iter)
{
    MooTerm *term = iter->term;
    int width = term->priv->width;
    int total_height = term->priv->height + buf_scrollback (term->priv->buffer);

    if (iter->row == total_height - 1)
    {
        iter->col = width;
        CHECK_ITER (iter);
        return FALSE;
    }
    else
    {
        iter->col = 0;
        iter->row++;
        CHECK_ITER (iter);
        return TRUE;
    }
}


static gboolean is_space                (const MooTermIter  *iter)
{
    gunichar c = iter_get_char (iter);
    g_return_val_if_fail (c != 0, FALSE);
    return g_unichar_isspace (c);
}


static gboolean is_word_char            (const MooTermIter  *iter)
{
    gunichar c = iter_get_char (iter);
    g_return_val_if_fail (c != 0, FALSE);
    return g_unichar_isalnum (c) || c == '_';
}


static gunichar
iter_get_char (const MooTermIter *iter)
{
    MooTermLine *line = buf_line (iter->term->priv->buffer, iter->row);
    return _moo_term_line_get_char (line, iter->col);
}


static char*
segment_get_text (Segment *segment)
{
    MooTerm *term = ITER_TERM (&segment->start);
    MooTermBuffer *buf = term->priv->buffer;
    MooTermIter start = segment->start;
    MooTermIter end = segment->end;
    GString *text;
    MooTermLine *line;
    int width = term->priv->width;
    int i, j;

    _moo_term_iter_order (&start, &end);

    if (!iter_cmp (&start, &end))
        return NULL;

    text = g_string_new ("");

    if (ITER_ROW(&start) == ITER_ROW(&end))
    {
        line = buf_line (buf, ITER_ROW(&start));

        for (j = ITER_COL(&start);
             j < ITER_COL(&end) && j < (int) _moo_term_line_len (line); ++j)
                g_string_append_unichar (text, _moo_term_line_get_char (line, j));
    }
    else
    {
        if (ITER_COL(&start) < width)
        {
            line = buf_line (buf, ITER_ROW(&start));

            for (j = ITER_COL(&start); j < (int) _moo_term_line_len (line); ++j)
                g_string_append_unichar (text, _moo_term_line_get_char (line, j));

            if (!_moo_term_line_wrapped (line))
                g_string_append_c (text, '\n');
        }

        for (i = ITER_ROW(&start) + 1; i < ITER_ROW(&end); ++i)
        {
            line = buf_line (buf, i);

            for (j = 0; j < (int) _moo_term_line_len (line); ++j)
                g_string_append_unichar (text, _moo_term_line_get_char (line, j));

            if (!_moo_term_line_wrapped (line))
                g_string_append_c (text, '\n');
        }

        if (ITER_COL(&end) > 0)
        {
            line = buf_line (buf, ITER_ROW(&end));

            for (j = 0; j < ITER_COL(&end) && j < (int) _moo_term_line_len (line); ++j)
                g_string_append_unichar (text, _moo_term_line_get_char (line, j));

            if (iter_ends_line (&end) && !_moo_term_line_wrapped (line))
                g_string_append_c (text, '\n');
        }
    }

    return g_string_free (text, FALSE);
}


void
moo_term_select_all (MooTerm        *term)
{
    MooTermIter start, end;

    get_start_iter (term, &start);
    get_end_iter (term, &end);

    _moo_term_select_range (term, &start, &end);
}


char       *moo_term_get_content            (MooTerm        *term)
{
    Segment segm;

    get_start_iter (term, &segm.start);
    get_end_iter (term, &segm.end);

    return segment_get_text (&segm);
}


char*
moo_term_get_text (MooTermIter    *start,
                   MooTermIter    *end)
{
    /* XXX check iters */
    Segment segm = {*start, *end};
    return segment_get_text (&segm);
}


guint
moo_term_get_line_count (MooTerm *term)
{
    g_return_val_if_fail (MOO_IS_TERM (term), 0);
    return term->priv->height + buf_scrollback (term->priv->primary_buffer);
}


MooTermLine*
moo_term_get_line (MooTerm            *term,
                   guint               line_no)
{
    g_return_val_if_fail (MOO_IS_TERM (term), NULL);
    g_return_val_if_fail (line_no < moo_term_get_line_count (term), NULL);
    return buf_line (term->priv->primary_buffer, line_no);
}


gboolean
moo_term_get_iter_at_line (MooTerm            *term,
                           MooTermIter        *iter,
                           guint               line)
{
    g_return_val_if_fail (iter != NULL, FALSE);
    g_return_val_if_fail (MOO_IS_TERM (term), FALSE);

    if (line >= moo_term_get_line_count (term))
        return FALSE;

    FILL_ITER (iter, term, line, 0);
    return TRUE;
}


gboolean
moo_term_get_iter_at_line_offset (MooTerm            *term,
                                  MooTermIter        *iter,
                                  guint               line_no,
                                  guint               offset)
{
    MooTermLine *line;

    g_return_val_if_fail (iter != NULL, FALSE);
    g_return_val_if_fail (MOO_IS_TERM (term), FALSE);

    if (line_no >= moo_term_get_line_count (term))
        return FALSE;

    line = buf_line (term->priv->buffer, line_no);

    if (offset > _moo_term_line_width (line))
        return FALSE;

    FILL_ITER (iter, term, line_no, offset);
    return TRUE;
}


void
moo_term_get_iter_at_cursor (MooTerm            *term,
                             MooTermIter        *iter)
{
    g_return_if_fail (MOO_IS_TERM (term));
    g_return_if_fail (iter != NULL);

    FILL_ITER (iter, term, buf_cursor_row_abs (term->priv->buffer),
               buf_cursor_col_display (term->priv->buffer));
}


void
moo_term_iter_forward_to_line_end (MooTermIter *iter)
{
    MooTerm *term;

    g_return_if_fail (iter != NULL);

    term = ITER_TERM (iter);
    g_return_if_fail (MOO_IS_TERM (term));

    ITER_COL (iter) = term->priv->width;
}


void
moo_term_apply_tag (MooTerm            *term,
                    MooTermTag         *tag,
                    MooTermIter        *start,
                    MooTermIter        *end)
{
    MooTermBuffer *buf;
    MooTermLine *line;
    int i;
    Segment inv;

    g_return_if_fail (MOO_IS_TERM (term));
    g_return_if_fail (MOO_IS_TERM_TAG (tag));
    g_return_if_fail (start != NULL && end != NULL);
    g_return_if_fail (ITER_TERM(start) == term && ITER_TERM(end) == term);

    _moo_term_iter_order (start, end);
    buf = term->priv->primary_buffer;

    if (ITER_ROW (start) == ITER_ROW (end))
    {
        line = buf_line (buf, ITER_ROW (start));
        _moo_term_line_apply_tag (line, tag, ITER_COL (start),
                                  ITER_COL (end) - ITER_COL (start));
    }
    else
    {
        line = buf_line (buf, ITER_ROW (start));
        _moo_term_line_apply_tag (line, tag, ITER_COL (start),
                                  _moo_term_line_width (line) - ITER_COL (start));
        line = buf_line (buf, ITER_ROW (end));
        _moo_term_line_apply_tag (line, tag, 0, ITER_COL (end));
        if (ITER_ROW (start) + 1 < ITER_ROW (end))
        {
            for (i = ITER_ROW (start) + 1; i < ITER_ROW (end); ++i)
            {
                line = buf_line (buf, i);
                _moo_term_line_apply_tag (line, tag, 0,
                                          _moo_term_line_width (line));
            }
        }
    }

    inv.start = *start;
    inv.end = *end;
    invalidate_segment (&inv, 1);
}


void
moo_term_remove_tag (MooTerm            *term,
                     MooTermTag         *tag,
                     MooTermIter        *start,
                     MooTermIter        *end)
{
    MooTermBuffer *buf;
    MooTermLine *line;
    Segment inv;
    int i;

    g_return_if_fail (MOO_IS_TERM (term));
    g_return_if_fail (MOO_IS_TERM_TAG (tag));
    g_return_if_fail (start != NULL && end != NULL);
    g_return_if_fail (ITER_TERM(start) == term && ITER_TERM(end) == term);

    _moo_term_iter_order (start, end);
    buf = term->priv->primary_buffer;

    if (ITER_ROW (start) == ITER_ROW (end))
    {
        line = buf_line (buf, ITER_ROW (start));
        _moo_term_line_remove_tag (line, tag, ITER_COL (start),
                                   ITER_COL (end) - ITER_COL (start));
    }
    else
    {
        line = buf_line (buf, ITER_ROW (start));
        _moo_term_line_remove_tag (line, tag, ITER_COL (start),
                                   _moo_term_line_width (line) - ITER_COL (start));
        line = buf_line (buf, ITER_ROW (end));
        _moo_term_line_remove_tag (line, tag, 0, ITER_COL (end));
        if (ITER_ROW (start) + 1 < ITER_ROW (end))
        {
            for (i = ITER_ROW (start) + 1; i < ITER_ROW (end); ++i)
            {
                line = buf_line (buf, i);
                _moo_term_line_remove_tag (line, tag, 0,
                                           _moo_term_line_width (line));
            }
        }
    }

    inv.start = *start;
    inv.end = *end;
    invalidate_segment (&inv, 1);
}


gboolean
moo_term_iter_has_tag (MooTermIter        *iter,
                       MooTermTag         *tag)
{
    MooTermBuffer *buf;
    MooTerm *term;

    g_return_val_if_fail (iter != NULL, FALSE);
    g_return_val_if_fail (MOO_IS_TERM (ITER_TERM (iter)), FALSE);
    g_return_val_if_fail (MOO_IS_TERM_TAG (tag), FALSE);

    term = ITER_TERM (iter);
    buf = term->priv->primary_buffer;

    return _moo_term_line_has_tag (buf_line (buf, ITER_ROW (iter)),
                                   tag, ITER_COL (iter));
}


gboolean
moo_term_iter_get_tag_start (MooTermIter        *iter,
                             MooTermTag         *tag)
{
    MooTermBuffer *buf;
    MooTermLine *line;
    MooTerm *term;
    guint col;

    g_return_val_if_fail (iter != NULL, FALSE);
    g_return_val_if_fail (MOO_IS_TERM (ITER_TERM (iter)), FALSE);
    g_return_val_if_fail (MOO_IS_TERM_TAG (tag), FALSE);

    term = ITER_TERM (iter);
    buf = term->priv->primary_buffer;
    line = buf_line (buf, ITER_ROW (iter));

    col = ITER_COL (iter);

    if (_moo_term_line_get_tag_start (line, tag, &col))
    {
        ITER_COL (iter) = col;
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}


gboolean
moo_term_iter_get_tag_end (MooTermIter        *iter,
                           MooTermTag         *tag)
{
    MooTermBuffer *buf;
    MooTermLine *line;
    MooTerm *term;
    guint col;

    g_return_val_if_fail (iter != NULL, FALSE);
    g_return_val_if_fail (MOO_IS_TERM (ITER_TERM (iter)), FALSE);
    g_return_val_if_fail (MOO_IS_TERM_TAG (tag), FALSE);

    term = ITER_TERM (iter);
    buf = term->priv->primary_buffer;
    line = buf_line (buf, ITER_ROW (iter));

    col = ITER_COL (iter);

    if (_moo_term_line_get_tag_end (line, tag, &col))
    {
        ITER_COL (iter) = col;
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}


void
moo_term_set_line_data (MooTerm            *term,
                        MooTermLine        *line,
                        const char         *key,
                        gpointer            data)
{
    moo_term_set_line_data_full (term, line, key, data, NULL);
}


void
moo_term_set_line_data_full (MooTerm            *term,
                             MooTermLine        *line,
                             const char         *key,
                             gpointer            data,
                             GDestroyNotify      destroy)
{
    g_return_if_fail (MOO_IS_TERM (term));
    g_return_if_fail (key != NULL);
    g_return_if_fail (line != NULL);

    _moo_term_buffer_set_line_data (term->priv->primary_buffer,
                                    line, key, data, destroy);
}


gpointer
moo_term_get_line_data (MooTerm            *term,
                        MooTermLine        *line,
                        const char         *key)
{
    g_return_val_if_fail (MOO_IS_TERM (term), NULL);
    g_return_val_if_fail (key != NULL, NULL);
    g_return_val_if_fail (line != NULL, NULL);

    return _moo_term_buffer_get_line_data (term->priv->primary_buffer, line, key);
}


MooTermIter*
moo_term_iter_copy (const MooTermIter *iter)
{
    g_return_val_if_fail (iter != NULL, NULL);
    return g_memdup (iter, sizeof (MooTermIter));
}

void
moo_term_iter_free (MooTermIter *iter)
{
    g_free (iter);
}


GType
moo_term_iter_get_type (void)
{
    static GType type = 0;

    if (!type)
        type = g_boxed_type_register_static ("MooTermIter",
                                             (GBoxedCopyFunc) moo_term_iter_copy,
                                             (GBoxedFreeFunc) moo_term_iter_free);
    return type;
}