table-allgui.c

/********************************************************************\
 * table-allgui.c -- 2D grid table object, embeds cells for i/o     *
 *                                                                  *
 * 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.              *
 *                                                                  *
 * This program is distributed in the hope that it will be useful,  *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of   *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
 * GNU General Public License for more details.                     *
 *                                                                  *
 * You should have received a copy of the GNU General Public License*
 * along with this program; if not, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
 *                                                                  *
\********************************************************************/

/*
 * FILE:
 * table-allgui.c
 *
 * FUNCTION:
 * Implements the gui-independent parts of the table infrastructure.
 *
 * HISTORY:
 * Copyright (c) 1998,1999,2000 Linas Vepstas
 * Copyright (c) 2000 Dave Peticolas
 */

#include <config.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <glib.h>

#include "table-allgui.h"
#include "cellblock.h"
#include "gnc-engine.h"


static TableGUIHandlers default_gui_handlers;

/* This static indicates the debugging module that this .o belongs to. */
static QofLogModule log_module = GNC_MOD_REGISTER;


static void gnc_table_init (Table * table);
static void gnc_table_free_data (Table * table);
static void gnc_virtual_cell_construct (gpointer vcell, gpointer user_data);
static void gnc_virtual_cell_destroy (gpointer vcell, gpointer user_data);
static void gnc_table_resize (Table * table, int virt_rows, int virt_cols);


void
gnc_table_set_default_gui_handlers (TableGUIHandlers *gui_handlers)
{
    if (!gui_handlers)
        memset (&default_gui_handlers, 0, sizeof (default_gui_handlers));
    else
        default_gui_handlers = *gui_handlers;
}

Table *
gnc_table_new (TableLayout *layout, TableModel *model, TableControl *control)
{
    Table *table;

    g_return_val_if_fail (layout != NULL, NULL);
    g_return_val_if_fail (model != NULL, NULL);
    g_return_val_if_fail (control != NULL, NULL);

    table = g_new0 (Table, 1);

    table->layout = layout;
    table->model = model;
    table->control = control;

    table->gui_handlers = default_gui_handlers;

    gnc_table_init (table);

    table->virt_cells = g_table_new (sizeof (VirtualCell),
                                     gnc_virtual_cell_construct,
                                     gnc_virtual_cell_destroy, table);

    return table;
}

static void
gnc_table_init (Table * table)
{
    table->num_virt_rows = -1;
    table->num_virt_cols = -1;

    table->current_cursor = NULL;

    gnc_virtual_location_init (&table->current_cursor_loc);

    /* initialize private data */

    table->virt_cells = NULL;
    table->ui_data = NULL;
}

void
gnc_table_destroy (Table * table)
{
    /* invoke destroy callback */
    if (table->gui_handlers.destroy)
        table->gui_handlers.destroy (table);

    /* free the dynamic structures */
    gnc_table_free_data (table);

    /* free the cell tables */
    g_table_destroy (table->virt_cells);

    gnc_table_layout_destroy (table->layout);
    table->layout = NULL;

    gnc_table_control_destroy (table->control);
    table->control = NULL;

    gnc_table_model_destroy (table->model);
    table->model = NULL;

    /* initialize vars to null value so that any access is voided. */
    gnc_table_init (table);

    g_free (table);
}

int
gnc_table_current_cursor_changed (Table *table,
                                  gboolean include_conditional)
{
    if (!table)
        return FALSE;

    return gnc_cellblock_changed (table->current_cursor, include_conditional);
}

void
gnc_table_clear_current_cursor_changes (Table *table)
{
    if (!table)
        return;

    gnc_cellblock_clear_changes (table->current_cursor);
}

void
gnc_table_save_current_cursor (Table *table, CursorBuffer *buffer)
{
    if (!table || !buffer)
        return;

    gnc_table_layout_save_cursor (table->layout, table->current_cursor, buffer);
}

void
gnc_table_restore_current_cursor (Table *table,
                                  CursorBuffer *buffer)
{
    if (!table || !buffer)
        return;

    gnc_table_layout_restore_cursor (table->layout,
                                     table->current_cursor, buffer);
}

const char *
gnc_table_get_current_cell_name (Table *table)
{
    if (table == NULL)
        return NULL;

    return gnc_table_get_cell_name (table, table->current_cursor_loc);
}

gboolean
gnc_table_get_current_cell_location (Table *table,
                                     const char *cell_name,
                                     VirtualLocation *virt_loc)
{
    if (table == NULL)
        return FALSE;

    return gnc_table_get_cell_location (table, cell_name,
                                        table->current_cursor_loc.vcell_loc,
                                        virt_loc);
}

gboolean
gnc_table_virtual_cell_out_of_bounds (Table *table,
                                      VirtualCellLocation vcell_loc)
{
    if (!table)
        return TRUE;

    return ((vcell_loc.virt_row < 0) ||
            (vcell_loc.virt_row >= table->num_virt_rows) ||
            (vcell_loc.virt_col < 0) ||
            (vcell_loc.virt_col >= table->num_virt_cols));
}

gboolean
gnc_table_virtual_location_in_header (Table *table,
                                      VirtualLocation virt_loc)
{
    return (virt_loc.vcell_loc.virt_row == 0);
}

VirtualCell *
gnc_table_get_virtual_cell (Table *table, VirtualCellLocation vcell_loc)
{
    if (table == NULL)
        return NULL;

    return g_table_index (table->virt_cells,
                          vcell_loc.virt_row, vcell_loc.virt_col);
}

VirtualCell *
gnc_table_get_header_cell (Table *table)
{
    VirtualCellLocation vcell_loc = { 0, 0 };

    return gnc_table_get_virtual_cell (table, vcell_loc);
}

static const char *
table_get_model_entry (Table *table, VirtualLocation virt_loc,
                       gboolean translate, gboolean *conditionally_changed, const char *cell_name)
{
    TableGetEntryHandler entry_handler = gnc_table_model_get_entry_handler (
            table->model, cell_name);

    if (entry_handler)
    {
        const char *entry = entry_handler (virt_loc, translate, conditionally_changed,
                                           table->model->handler_user_data);
        if (entry)
            return entry;
    }

    return "";
}

static const char *
table_get_entry (Table *table, VirtualLocation virt_loc,
                 gboolean *conditionally_changed)
{
    const char *cell_name = gnc_table_get_cell_name (table, virt_loc);

    return table_get_model_entry (table, virt_loc, FALSE, conditionally_changed,
                                  cell_name);
}

const char *
gnc_table_get_entry (Table *table, VirtualLocation virt_loc)
{
    BasicCell *cell = gnc_table_get_cell (table, virt_loc);

    if (!cell || !cell->cell_name)
        return "";

    if (virt_cell_loc_equal (table->current_cursor_loc.vcell_loc,
                             virt_loc.vcell_loc))
    {
        CellIOFlags io_flags = gnc_table_get_io_flags (table, virt_loc);

        if (io_flags & XACC_CELL_ALLOW_INPUT)
            return cell->value;
    }

    return table_get_model_entry (table, virt_loc, TRUE, NULL, cell->cell_name);
}

const char *
gnc_table_get_model_entry (Table *table, const char *cell_name)
{
    return table_get_model_entry (table, table->current_cursor_loc, TRUE, NULL,
                                  cell_name);
}

char *
gnc_table_get_tooltip (Table *table, VirtualLocation virt_loc)
{
    TableGetTooltipHandler tooltip_handler;
    BasicCell *cell;

    cell = gnc_table_get_cell (table, virt_loc);
    if (!cell || !cell->cell_name)
        return NULL;

    tooltip_handler =
        gnc_table_model_get_tooltip_handler (table->model, cell->cell_name);

    if (!tooltip_handler)
        return NULL;

    return  tooltip_handler (virt_loc, table->model->handler_user_data);
}

CellIOFlags
gnc_table_get_io_flags (Table *table, VirtualLocation virt_loc)
{
    TableGetCellIOFlagsHandler io_flags_handler;
    const char *cell_name;
    CellIOFlags flags;

    if (!table || !table->model)
        return XACC_CELL_ALLOW_NONE;

    cell_name = gnc_table_get_cell_name (table, virt_loc);

    io_flags_handler =
        gnc_table_model_get_io_flags_handler (table->model, cell_name);
    if (!io_flags_handler)
        return XACC_CELL_ALLOW_NONE;

    flags = io_flags_handler (virt_loc, table->model->handler_user_data);

    if (gnc_table_model_read_only (table->model))
        flags &= XACC_CELL_ALLOW_SHADOW;

    return flags;
}

const char *
gnc_table_get_label (Table *table, VirtualLocation virt_loc)
{
    TableGetLabelHandler label_handler;
    const char *cell_name;
    const char *label;

    if (!table || !table->model)
        return "";

    cell_name = gnc_table_get_cell_name (table, virt_loc);

    label_handler = gnc_table_model_get_label_handler (table->model, cell_name);
    if (!label_handler)
        return "";

    label = label_handler (virt_loc, table->model->handler_user_data);
    if (!label)
        return "";

    return label;
}

guint32
gnc_table_get_color (Table *table, VirtualLocation virt_loc,
                     gboolean *hatching)
{
    TableGetCellColorHandler color_handler;
    const char *handler_name;

    if (hatching)
        *hatching = FALSE;

    if (!table || !table->model)
        return COLOR_UNDEFINED;

    handler_name = gnc_table_get_cell_name (table, virt_loc);

    color_handler =
        gnc_table_model_get_cell_color_handler (table->model, handler_name);

    if (!color_handler)
        return COLOR_UNDEFINED;

    return color_handler (virt_loc, hatching,
                          table->model->handler_user_data);
}

void
gnc_table_get_borders (Table *table, VirtualLocation virt_loc,
                       PhysicalCellBorders *borders)
{
    TableGetCellBorderHandler cell_border_handler;
    const char *cell_name;

    if (!table || !table->model)
        return;

    cell_name = gnc_table_get_cell_name (table, virt_loc);

    cell_border_handler =
        gnc_table_model_get_cell_border_handler (table->model, cell_name);
    if (!cell_border_handler)
        return;

    cell_border_handler (virt_loc, borders, table->model->handler_user_data);
}

CellAlignment
gnc_table_get_align (Table *table, VirtualLocation virt_loc)
{
    BasicCell *cell;

    cell = gnc_table_get_cell (table, virt_loc);
    if (!cell)
        return CELL_ALIGN_RIGHT;

    return cell->alignment;
}

gboolean
gnc_table_is_popup (Table *table, VirtualLocation virt_loc)
{
    BasicCell *cell;

    cell = gnc_table_get_cell (table, virt_loc);
    if (!cell)
        return FALSE;

    return cell->is_popup;
}

char *
gnc_table_get_help (Table *table)
{
    TableGetHelpHandler help_handler;
    VirtualLocation virt_loc;
    const char * cell_name;

    if (!table)
        return NULL;

    virt_loc = table->current_cursor_loc;

    cell_name = gnc_table_get_cell_name (table, virt_loc);

    help_handler = gnc_table_model_get_help_handler (table->model, cell_name);
    if (!help_handler)
        return NULL;

    return help_handler (virt_loc, table->model->handler_user_data);
}

BasicCell *
gnc_table_get_cell (Table *table, VirtualLocation virt_loc)
{
    VirtualCell *vcell;

    if (!table)
        return NULL;

    vcell = gnc_table_get_virtual_cell (table, virt_loc.vcell_loc);
    if (!vcell)
        return NULL;

    return gnc_cellblock_get_cell (vcell->cellblock,
                                   virt_loc.phys_row_offset,
                                   virt_loc.phys_col_offset);
}

const char *
gnc_table_get_cell_name (Table *table, VirtualLocation virt_loc)
{
    BasicCell *cell;

    cell = gnc_table_get_cell (table, virt_loc);
    if (cell == NULL)
        return NULL;

    return cell->cell_name;
}

const gchar *
gnc_table_get_cell_type_name (Table *table, VirtualLocation virt_loc)
{
    BasicCell *cell;

    cell = gnc_table_get_cell (table, virt_loc);
    if (cell == NULL)
        return NULL;

    return cell->cell_type_name;
}


gboolean
gnc_table_get_cell_location (Table *table,
                             const char *cell_name,
                             VirtualCellLocation vcell_loc,
                             VirtualLocation *virt_loc)
{
    VirtualCell *vcell;
    CellBlock *cellblock;
    int cell_row, cell_col;

    if (table == NULL)
        return FALSE;

    vcell = gnc_table_get_virtual_cell (table, vcell_loc);
    if (vcell == NULL)
        return FALSE;

    cellblock = vcell->cellblock;

    for (cell_row = 0; cell_row < cellblock->num_rows; cell_row++)
        for (cell_col = 0; cell_col < cellblock->num_cols; cell_col++)
        {
            BasicCell *cell;

            cell = gnc_cellblock_get_cell (cellblock, cell_row, cell_col);
            if (!cell)
                continue;

            if (gnc_basic_cell_has_name (cell, cell_name))
            {
                if (virt_loc != NULL)
                {
                    virt_loc->vcell_loc = vcell_loc;

                    virt_loc->phys_row_offset = cell_row;
                    virt_loc->phys_col_offset = cell_col;
                }

                return TRUE;
            }
        }

    return FALSE;
}

void
gnc_table_save_cells (Table *table, gpointer save_data)
{
    TableSaveHandler save_handler;
    GList * cells;
    GList * node;

    g_return_if_fail (table);

    /* ignore any changes to read-only tables */
    if (gnc_table_model_read_only (table->model))
        return;

    // gnc_table_leave_update (table, table->current_cursor_loc);

    save_handler = gnc_table_model_get_pre_save_handler (table->model);
    if (save_handler)
        save_handler (save_data, table->model->handler_user_data);

    cells = gnc_table_layout_get_cells (table->layout);
    for (node = cells; node; node = node->next)
    {
        BasicCell * cell = node->data;
        TableSaveCellHandler save_cell_handler;

        if (!cell) continue;

        if (!gnc_table_layout_get_cell_changed (table->layout,
                                                cell->cell_name, TRUE))
            continue;

        save_cell_handler = gnc_table_model_get_save_handler (table->model,
                            cell->cell_name);
        if (save_cell_handler)
            save_cell_handler (cell, save_data, table->model->handler_user_data);
    }

    save_handler = gnc_table_model_get_post_save_handler (table->model);
    if (save_handler)
        save_handler (save_data, table->model->handler_user_data);
}

void
gnc_table_set_size (Table * table, int virt_rows, int virt_cols)
{
    /* Invalidate the current cursor position, if the array is
     * shrinking. This must be done since the table is probably
     * shrinking because some rows were deleted, and the cursor
     * could be on the deleted rows. */
    if ((virt_rows < table->num_virt_rows) ||
            (virt_cols < table->num_virt_cols))
    {
        gnc_virtual_location_init (&table->current_cursor_loc);
        table->current_cursor = NULL;
    }

    gnc_table_resize (table, virt_rows, virt_cols);
}

static void
gnc_table_free_data (Table * table)
{
    if (table == NULL)
        return;

    g_table_resize (table->virt_cells, 0, 0);
}

void
gnc_virtual_location_init (VirtualLocation *vloc)
{
    if (vloc == NULL)
        return;

    vloc->phys_row_offset = -1;
    vloc->phys_col_offset = -1;
    vloc->vcell_loc.virt_row = -1;
    vloc->vcell_loc.virt_col = -1;
}

static void
gnc_virtual_cell_construct (gpointer _vcell, gpointer user_data)
{
    VirtualCell *vcell = _vcell;
    Table *table = user_data;

    vcell->cellblock = NULL;

    if (table && table->model->cell_data_allocator)
        vcell->vcell_data = table->model->cell_data_allocator ();
    else
        vcell->vcell_data = NULL;

    vcell->visible = 1;
}

static void
gnc_virtual_cell_destroy (gpointer _vcell, gpointer user_data)
{
    VirtualCell *vcell = _vcell;
    Table *table = user_data;

    if (vcell->vcell_data && table && table->model->cell_data_deallocator)
        table->model->cell_data_deallocator (vcell->vcell_data);

    vcell->vcell_data = NULL;
}

static void
gnc_table_resize (Table * table, int new_virt_rows, int new_virt_cols)
{
    if (!table) return;

    g_table_resize (table->virt_cells, new_virt_rows, new_virt_cols);

    table->num_virt_rows = new_virt_rows;
    table->num_virt_cols = new_virt_cols;
}

void
gnc_table_set_vcell (Table *table,
                     CellBlock *cursor,
                     gconstpointer vcell_data,
                     gboolean visible,
                     gboolean start_primary_color,
                     VirtualCellLocation vcell_loc)
{
    VirtualCell *vcell;

    if ((table == NULL) || (cursor == NULL))
        return;

    if ((vcell_loc.virt_row >= table->num_virt_rows) ||
            (vcell_loc.virt_col >= table->num_virt_cols))
        gnc_table_resize (table,
                          MAX (table->num_virt_rows, vcell_loc.virt_row + 1),
                          MAX (table->num_virt_cols, vcell_loc.virt_col + 1));

    vcell = gnc_table_get_virtual_cell (table, vcell_loc);
    if (vcell == NULL)
        return;

    /* this cursor is the handler for this block */
    vcell->cellblock = cursor;

    /* copy the vcell user data */
    if (table->model->cell_data_copy)
        table->model->cell_data_copy (vcell->vcell_data, vcell_data);
    else
        vcell->vcell_data = (gpointer) vcell_data;

    vcell->visible = visible ? 1 : 0;
    vcell->start_primary_color = start_primary_color ? 1 : 0;
}

void
gnc_table_set_virt_cell_data (Table *table,
                              VirtualCellLocation vcell_loc,
                              gconstpointer vcell_data)
{
    VirtualCell *vcell;

    if (table == NULL)
        return;

    vcell = gnc_table_get_virtual_cell (table, vcell_loc);
    if (vcell == NULL)
        return;

    if (table->model->cell_data_copy)
        table->model->cell_data_copy (vcell->vcell_data, vcell_data);
    else
        vcell->vcell_data = (gpointer) vcell_data;
}

void
gnc_table_set_virt_cell_visible (Table *table,
                                 VirtualCellLocation vcell_loc,
                                 gboolean visible)
{
    VirtualCell *vcell;

    if (table == NULL)
        return;

    vcell = gnc_table_get_virtual_cell (table, vcell_loc);
    if (vcell == NULL)
        return;

    vcell->visible = visible ? 1 : 0;
}

void
gnc_table_set_virt_cell_cursor (Table *table,
                                VirtualCellLocation vcell_loc,
                                CellBlock *cursor)
{
    VirtualCell *vcell;

    if (table == NULL)
        return;

    vcell = gnc_table_get_virtual_cell (table, vcell_loc);
    if (vcell == NULL)
        return;

    vcell->cellblock = cursor;
}

static void
gnc_table_move_cursor_internal (Table *table,
                                VirtualLocation new_virt_loc,
                                gboolean do_move_gui)
{
    int cell_row, cell_col;
    VirtualLocation virt_loc;
    VirtualCell *vcell;
    CellBlock *curs;

    ENTER("new_virt=(%d %d) do_move_gui=%d\n",
          new_virt_loc.vcell_loc.virt_row,
          new_virt_loc.vcell_loc.virt_col, do_move_gui);

    /* call the callback, allowing the app to commit any changes
     * associated with the current location of the cursor. Note that
     * this callback may recursively call this routine. */
    if (table->control->move_cursor && table->control->allow_move)
    {
        table->control->move_cursor (&new_virt_loc, table->control->user_data);

        /* The above callback can cause this routine to be called
         * recursively. As a result of this recursion, the cursor may
         * have gotten repositioned. We need to make sure we make
         * passive again. */
        if (do_move_gui)
            gnc_table_refresh_current_cursor_gui (table, FALSE);
    }

    /* invalidate the cursor for now; we'll fix it back up below */
    gnc_virtual_location_init (&table->current_cursor_loc);

    curs = table->current_cursor;
    table->current_cursor = NULL;

    /* check for out-of-bounds conditions (which may be deliberate) */
    if ((new_virt_loc.vcell_loc.virt_row < 0) ||
            (new_virt_loc.vcell_loc.virt_col < 0))
    {
        /* if the location is invalid, then we should take this
         * as a command to unmap the cursor gui. */
        if (do_move_gui && curs)
        {
            for (cell_row = 0; cell_row < curs->num_rows; cell_row++)
                for (cell_col = 0; cell_col < curs->num_cols; cell_col++)
                {
                    BasicCell *cell;

                    cell = gnc_cellblock_get_cell (curs, cell_row, cell_col);
                    if (cell)
                    {
                        cell->changed = FALSE;
                        cell->conditionally_changed = FALSE;

                        if (cell->gui_move)
                            cell->gui_move (cell);
                    }
                }
        }

        LEAVE("out of bounds\n");
        return;
    }

    if (!gnc_table_virtual_loc_valid (table, new_virt_loc, TRUE))
    {
        PWARN("bad table location");
        LEAVE("");
        return;
    }

    /* ok, we now have a valid position. Find the new cursor to use,
     * and initialize its cells */
    vcell = gnc_table_get_virtual_cell (table, new_virt_loc.vcell_loc);
    curs = vcell->cellblock;
    table->current_cursor = curs;

    /* record the new position */
    table->current_cursor_loc = new_virt_loc;

    virt_loc.vcell_loc = new_virt_loc.vcell_loc;

    /* update the cell values to reflect the new position */
    for (cell_row = 0; cell_row < curs->num_rows; cell_row++)
        for (cell_col = 0; cell_col < curs->num_cols; cell_col++)
        {
            BasicCell *cell;
            CellIOFlags io_flags;

            virt_loc.phys_row_offset = cell_row;
            virt_loc.phys_col_offset = cell_col;

            cell = gnc_cellblock_get_cell(curs, cell_row, cell_col);
            if (cell)
            {
                /* if a cell has a GUI, move that first, before setting
                 * the cell value.  Otherwise, we'll end up putting the
                 * new values in the old cell locations, and that would
                 * lead to confusion of all sorts. */
                if (do_move_gui && cell->gui_move)
                    cell->gui_move (cell);

                /* OK, now copy the string value from the table at large
                 * into the cell handler. */
                io_flags = gnc_table_get_io_flags (table, virt_loc);
                if (io_flags & XACC_CELL_ALLOW_SHADOW)
                {
                    const char *entry;
                    gboolean conditionally_changed = FALSE;

                    entry = table_get_entry (table, virt_loc,
                                             &conditionally_changed);

                    gnc_basic_cell_set_value (cell, entry);

                    cell->changed = FALSE;
                    cell->conditionally_changed = conditionally_changed;
                }
            }
        }

    LEAVE("did move\n");
}

void
gnc_table_move_cursor (Table *table, VirtualLocation new_virt_loc)
{
    if (!table) return;

    gnc_table_move_cursor_internal (table, new_virt_loc, FALSE);
}

/* same as above, but be sure to deal with GUI elements as well */
void
gnc_table_move_cursor_gui (Table *table, VirtualLocation new_virt_loc)
{
    if (!table) return;

    gnc_table_move_cursor_internal (table, new_virt_loc, TRUE);
}

/* gnc_table_verify_cursor_position checks the location of the cursor
 * with respect to a virtual location, and repositions the cursor
 * if necessary. Returns true if the cell cursor was repositioned. */
gboolean
gnc_table_verify_cursor_position (Table *table, VirtualLocation virt_loc)
{
    gboolean do_move = FALSE;
    gboolean moved_cursor = FALSE;

    if (!table) return FALSE;

    /* Someone may be trying to intentionally invalidate the cursor, in
     * which case the physical addresses could be out of bounds. For
     * example, in order to unmap it in preparation for a reconfig.
     * So, if the specified location is out of bounds, then the cursor
     * MUST be moved. */
    if (gnc_table_virtual_cell_out_of_bounds (table, virt_loc.vcell_loc))
        do_move = TRUE;

    if (!virt_cell_loc_equal (virt_loc.vcell_loc,
                              table->current_cursor_loc.vcell_loc))
        do_move = TRUE;

    if (do_move)
    {
        gnc_table_move_cursor_gui (table, virt_loc);
        moved_cursor = TRUE;
    }
    else if (!virt_loc_equal (virt_loc, table->current_cursor_loc))
    {
        table->current_cursor_loc = virt_loc;
        moved_cursor = TRUE;
    }

    return moved_cursor;
}

gpointer
gnc_table_get_vcell_data (Table *table, VirtualCellLocation vcell_loc)
{
    VirtualCell *vcell;

    if (!table) return NULL;

    vcell = gnc_table_get_virtual_cell (table, vcell_loc);
    if (vcell == NULL)
        return NULL;

    return vcell->vcell_data;
}

/* If any of the cells have GUI specific components that need
 * initialization, initialize them now. The realize() callback
 * on the cursor cell is how we inform the cell handler that
 * now is the time to initialize its GUI.  */
void
gnc_table_realize_gui (Table * table)
{
    GList *cells;
    GList *node;

    if (!table) return;
    if (!table->ui_data) return;

    cells = gnc_table_layout_get_cells (table->layout);

    for (node = cells; node; node = node->next)
    {
        BasicCell *cell = node->data;

        if (cell->gui_realize)
            cell->gui_realize (cell, table->ui_data);
    }
}

void
gnc_table_wrap_verify_cursor_position (Table *table, VirtualLocation virt_loc)
{
    VirtualLocation save_loc;
    gboolean moved_cursor;

    if (!table) return;

    ENTER("(%d %d)", virt_loc.vcell_loc.virt_row, virt_loc.vcell_loc.virt_col);

    save_loc = table->current_cursor_loc;

    /* VerifyCursor will do all sorts of gui-independent machinations */
    moved_cursor = gnc_table_verify_cursor_position (table, virt_loc);

    if (moved_cursor)
    {
        /* make sure *both* the old and the new cursor rows get redrawn */
        gnc_table_refresh_current_cursor_gui (table, TRUE);
        gnc_table_refresh_cursor_gui (table, save_loc.vcell_loc, FALSE);
    }

    LEAVE ("");
}

void
gnc_table_refresh_current_cursor_gui (Table * table, gboolean do_scroll)
{
    if (!table) return;

    gnc_table_refresh_cursor_gui (table, table->current_cursor_loc.vcell_loc,
                                  do_scroll);
}

gboolean
gnc_table_virtual_loc_valid(Table *table,
                            VirtualLocation virt_loc,
                            gboolean exact_pointer)
{
    VirtualCell *vcell;
    CellIOFlags io_flags;

    if (!table) return FALSE;

    /* header rows cannot be modified */
    if (virt_loc.vcell_loc.virt_row == 0)
        return FALSE;

    vcell = gnc_table_get_virtual_cell(table, virt_loc.vcell_loc);
    if (vcell == NULL)
        return FALSE;

    if (!vcell->visible)
        return FALSE;

    /* verify that offsets are valid. This may occur if the app that is
     * using the table has a partially initialized cursor. (probably due
     * to a programming error, but maybe they meant to do this). */
    if ((0 > virt_loc.phys_row_offset) || (0 > virt_loc.phys_col_offset))
        return FALSE;

    /* check for a cell handler, but only if cell address is valid */
    if (vcell->cellblock == NULL) return FALSE;

    /* if table is read-only, any cell is ok :) */
    if (gnc_table_model_read_only (table->model)) return TRUE;

    io_flags = gnc_table_get_io_flags (table, virt_loc);

    /* if the cell allows ENTER, then it is ok */
    if (io_flags & XACC_CELL_ALLOW_ENTER) return TRUE;

    /* if cell is marked as output-only, you can't enter */
    if (0 == (XACC_CELL_ALLOW_INPUT & io_flags)) return FALSE;

    /* if cell is pointer only and this is not an exact pointer test,
     * it cannot be entered. */
    if (!exact_pointer && ((XACC_CELL_ALLOW_EXACT_ONLY & io_flags) != 0))
        return FALSE;

    return TRUE;
}

/* Handle the non gui-specific parts of a cell enter callback */
gboolean
gnc_table_enter_update (Table *table,
                        VirtualLocation virt_loc,
                        int *cursor_position,
                        int *start_selection,
                        int *end_selection)
{
    gboolean can_edit = TRUE;
    CellEnterFunc enter;
    BasicCell *cell;
    CellBlock *cb;
    int cell_row;
    int cell_col;
    CellIOFlags io_flags;

    if (table == NULL)
        return FALSE;

    cb = table->current_cursor;

    cell_row = virt_loc.phys_row_offset;
    cell_col = virt_loc.phys_col_offset;

    ENTER("enter %d %d (relrow=%d relcol=%d)",
          virt_loc.vcell_loc.virt_row,
          virt_loc.vcell_loc.virt_col,
          cell_row, cell_col);

    /* OK, if there is a callback for this cell, call it */
    cell = gnc_cellblock_get_cell (cb, cell_row, cell_col);
    if (!cell)
    {
        LEAVE("no cell");
        return FALSE;
    }

    io_flags = gnc_table_get_io_flags (table, virt_loc);
    if (io_flags == XACC_CELL_ALLOW_READ_ONLY)
    {
        if (table->gui_handlers.redraw_help)
            table->gui_handlers.redraw_help (table);
        LEAVE("read only cell");
        return FALSE;
    }

    enter = cell->enter_cell;

    if (enter)
    {
        char * old_value;

        DEBUG("gnc_table_enter_update(): %d %d has enter handler\n",
              cell_row, cell_col);

        old_value = g_strdup (cell->value);

        can_edit = enter (cell, cursor_position, start_selection, end_selection);

        if (g_strcmp0 (old_value, cell->value) != 0)
        {
            if (gnc_table_model_read_only (table->model))
            {
                PWARN ("enter update changed read-only table");
            }

            cell->changed = TRUE;
        }

        g_free (old_value);
    }

    if (table->gui_handlers.redraw_help)
        table->gui_handlers.redraw_help (table);

    LEAVE("return %d\n", can_edit);
    return can_edit;
}

void
gnc_table_leave_update (Table *table, VirtualLocation virt_loc)
{
    CellLeaveFunc leave;
    BasicCell *cell;
    CellBlock *cb;
    int cell_row;
    int cell_col;

    if (table == NULL)
        return;

    cb = table->current_cursor;

    cell_row = virt_loc.phys_row_offset;
    cell_col = virt_loc.phys_col_offset;

    ENTER("proposed (%d %d) rel(%d %d)\n",
          virt_loc.vcell_loc.virt_row,
          virt_loc.vcell_loc.virt_col,
          cell_row, cell_col);

    /* OK, if there is a callback for this cell, call it */
    cell = gnc_cellblock_get_cell (cb, cell_row, cell_col);
    if (!cell)
    {
        LEAVE("no cell");
        return;
    }

    leave = cell->leave_cell;

    if (leave)
    {
        char * old_value;

        old_value = g_strdup (cell->value);

        leave (cell);

        if (g_strcmp0 (old_value, cell->value) != 0)
        {
            if (gnc_table_model_read_only (table->model))
            {
                PWARN ("leave update changed read-only table");
            }

            cell->changed = TRUE;
        }

        g_free (old_value);
    }
    LEAVE("");
}

gboolean
gnc_table_confirm_change (Table *table, VirtualLocation virt_loc)
{
    TableConfirmHandler confirm_handler;
    const char *cell_name;

    if (!table || !table->model)
        return TRUE;

    cell_name = gnc_table_get_cell_name (table, virt_loc);

    confirm_handler = gnc_table_model_get_confirm_handler (table->model,
                      cell_name);
    if (!confirm_handler)
        return TRUE;

    return confirm_handler (virt_loc, table->model->handler_user_data);
}

/* Returned result should not be touched by the caller.
 * NULL return value means the edit was rejected. */
const char *
gnc_table_modify_update (Table *table,
                         VirtualLocation virt_loc,
                         const char *change,
                         int change_len,
                         const char *newval,
                         int newval_len,
                         int *cursor_position,
                         int *start_selection,
                         int *end_selection,
                         gboolean *cancelled)
{
    gboolean changed = FALSE;
    CellModifyVerifyFunc mv;
    BasicCell *cell;
    CellBlock *cb;
    int cell_row;
    int cell_col;
    char * old_value;

    g_return_val_if_fail (table, NULL);
    g_return_val_if_fail (table->model, NULL);

    if (gnc_table_model_read_only (table->model))
    {
        PWARN ("change to read-only table");
        return NULL;
    }

    cb = table->current_cursor;

    cell_row = virt_loc.phys_row_offset;
    cell_col = virt_loc.phys_col_offset;

    ENTER ("");

    if (!gnc_table_confirm_change (table, virt_loc))
    {
        if (cancelled)
            *cancelled = TRUE;

        LEAVE("change cancelled");
        return NULL;
    }

    if (cancelled)
        *cancelled = FALSE;

    /* OK, if there is a callback for this cell, call it */
    cell = gnc_cellblock_get_cell (cb, cell_row, cell_col);
    if (!cell)
    {
        LEAVE("no cell");
        return NULL;
    }

    mv = cell->modify_verify;

    old_value = g_strdup (cell->value);

    if (mv)
    {
        mv (cell, change, change_len, newval, newval_len,
            cursor_position, start_selection, end_selection);
    }
    else
    {
        gnc_basic_cell_set_value (cell, newval);
    }

    if (g_strcmp0 (old_value, cell->value) != 0)
    {
        changed = TRUE;
        cell->changed = TRUE;
    }

    g_free (old_value);

    if (table->gui_handlers.redraw_help)
        table->gui_handlers.redraw_help (table);

    LEAVE ("change %d %d (relrow=%d relcol=%d) val=%s\n",
           virt_loc.vcell_loc.virt_row,
           virt_loc.vcell_loc.virt_col,
           cell_row, cell_col,
           cell->value ? cell->value : "(null)");

    if (changed)
        return cell->value;
    else
        return NULL;
}

gboolean
gnc_table_direct_update (Table *table,
                         VirtualLocation virt_loc,
                         char **newval_ptr,
                         int *cursor_position,
                         int *start_selection,
                         int *end_selection,
                         gpointer gui_data)
{
    gboolean result;
    BasicCell *cell;
    CellBlock *cb;
    int cell_row;
    int cell_col;
    char * old_value;

    g_return_val_if_fail (table, FALSE);
    g_return_val_if_fail (table->model, FALSE);

    if (gnc_table_model_read_only (table->model))
    {
        PWARN ("input to read-only table");
        return FALSE;
    }

    cb = table->current_cursor;

    cell_row = virt_loc.phys_row_offset;
    cell_col = virt_loc.phys_col_offset;

    cell = gnc_cellblock_get_cell (cb, cell_row, cell_col);
    if (!cell)
        return FALSE;

    ENTER ("");

    gboolean changed = cell->changed;
    old_value = g_strdup (cell->value);

    CellDirectUpdateFunc du = cell->direct_update;

    if (du == NULL)
        du = table->gui_handlers.default_direct_update;

    if (du == NULL)
    {
        LEAVE("no direct update");
        return FALSE;
    }

    result = du (cell, cursor_position, start_selection, end_selection, gui_data);

    if (g_strcmp0 (old_value, cell->value) != 0)
    {
        if (!gnc_table_confirm_change (table, virt_loc))
        {
            gnc_basic_cell_set_value (cell, old_value);
            *newval_ptr = NULL;
            result = TRUE;
        }
        else
        {
            if (!changed)
                cell->changed = TRUE;
            *newval_ptr = cell->value;
        }
    }
    else
        *newval_ptr = NULL;

    g_free (old_value);

    if (table->gui_handlers.redraw_help)
        table->gui_handlers.redraw_help (table);

    LEAVE("");
    return result;
}

static gboolean gnc_table_find_valid_cell_horiz (Table *table,
        VirtualLocation *virt_loc,
        gboolean exact_cell);

static gboolean
gnc_table_find_valid_row_vert (Table *table, VirtualLocation *virt_loc)
{
    VirtualLocation vloc;
    VirtualCell *vcell = NULL;
    int top;
    int bottom;

    if (table == NULL)
        return FALSE;

    if (virt_loc == NULL)
        return FALSE;

    vloc = *virt_loc;

    if (vloc.vcell_loc.virt_row < 1)
        vloc.vcell_loc.virt_row = 1;
    if (vloc.vcell_loc.virt_row >= table->num_virt_rows)
        vloc.vcell_loc.virt_row = table->num_virt_rows - 1;

    top  = vloc.vcell_loc.virt_row;
    bottom = vloc.vcell_loc.virt_row + 1;

    while (top >= 1 || bottom < table->num_virt_rows)
    {
        vloc.vcell_loc.virt_row = top;
        vcell = gnc_table_get_virtual_cell (table, vloc.vcell_loc);
        if (vcell && vcell->cellblock && vcell->visible)
        {
            vloc.phys_row_offset = 0;
            vloc.phys_col_offset = 0;

            if (gnc_table_find_valid_cell_horiz (table, &vloc, FALSE))
                break;
        }

        vloc.vcell_loc.virt_row = bottom;
        vcell = gnc_table_get_virtual_cell (table, vloc.vcell_loc);
        if (vcell && vcell->cellblock && vcell->visible)
        {
            vloc.phys_row_offset = 0;
            vloc.phys_col_offset = 0;

            if (gnc_table_find_valid_cell_horiz (table, &vloc, FALSE))
                break;
        }

        top--;
        bottom++;
    }

    if (!vcell || !vcell->cellblock || !vcell->visible)
        return FALSE;

    if (vloc.phys_row_offset < 0)
        vloc.phys_row_offset = 0;
    if (vloc.phys_row_offset >= vcell->cellblock->num_rows)
        vloc.phys_row_offset = vcell->cellblock->num_rows - 1;

    virt_loc->vcell_loc = vloc.vcell_loc;

    return TRUE;
}

static gboolean
gnc_table_find_valid_cell_horiz (Table *table,
                                 VirtualLocation *virt_loc,
                                 gboolean exact_cell)
{
    VirtualLocation vloc;
    VirtualCell *vcell;
    int left;
    int right;

    if (table == NULL)
        return FALSE;

    if (virt_loc == NULL)
        return FALSE;

    if (gnc_table_virtual_cell_out_of_bounds (table, virt_loc->vcell_loc))
        return FALSE;

    if (gnc_table_virtual_loc_valid (table, *virt_loc, exact_cell))
        return TRUE;

    vloc = *virt_loc;

    vcell = gnc_table_get_virtual_cell (table, vloc.vcell_loc);
    if (vcell == NULL)
        return FALSE;
    if (vcell->cellblock == NULL)
        return FALSE;

    if (vloc.phys_col_offset < 0)
        vloc.phys_col_offset = 0;
    if (vloc.phys_col_offset >= vcell->cellblock->num_cols)
        vloc.phys_col_offset = vcell->cellblock->num_cols - 1;

    left  = vloc.phys_col_offset - 1;
    right = vloc.phys_col_offset + 1;

    while (left >= 0 || right < vcell->cellblock->num_cols)
    {
        vloc.phys_col_offset = right;
        if (gnc_table_virtual_loc_valid(table, vloc, FALSE))
        {
            *virt_loc = vloc;
            return TRUE;
        }

        vloc.phys_col_offset = left;
        if (gnc_table_virtual_loc_valid(table, vloc, FALSE))
        {
            *virt_loc = vloc;
            return TRUE;
        }

        left--;
        right++;
    }

    return FALSE;
}

gboolean
gnc_table_find_close_valid_cell (Table *table, VirtualLocation *virt_loc,
                                 gboolean exact_pointer)
{
    if (!gnc_table_find_valid_row_vert (table, virt_loc))
        return FALSE;

    return gnc_table_find_valid_cell_horiz (table, virt_loc, exact_pointer);
}

void
gnc_table_refresh_cursor_gui (Table * table,
                              VirtualCellLocation vcell_loc,
                              gboolean do_scroll)
{
    g_return_if_fail (table != NULL);
    g_return_if_fail (table->gui_handlers.cursor_refresh != NULL);

    table->gui_handlers.cursor_refresh (table, vcell_loc, do_scroll);
}

gboolean
gnc_table_move_tab (Table *table,
                    VirtualLocation *virt_loc,
                    gboolean move_right)
{
    VirtualCell *vcell;
    VirtualLocation vloc;
    BasicCell *cell;

    if ((table == NULL) || (virt_loc == NULL))
        return FALSE;

    vloc = *virt_loc;

    vcell = gnc_table_get_virtual_cell (table, vloc.vcell_loc);
    if ((vcell == NULL) || (vcell->cellblock == NULL) || !vcell->visible)
        return FALSE;

    while (1)
    {
        CellIOFlags io_flags;

        if (move_right)
        {
            vloc.phys_col_offset++;

            if (vloc.phys_col_offset >= vcell->cellblock->num_cols)
            {
                if (!gnc_table_move_vertical_position (table, &vloc, 1))
                    return FALSE;

                vloc.phys_col_offset = 0;
            }
        }
        else
        {
            vloc.phys_col_offset--;

            if (vloc.phys_col_offset < 0)
            {
                if (!gnc_table_move_vertical_position (table, &vloc, -1))
                    return FALSE;

                vloc.phys_col_offset = vcell->cellblock->num_cols - 1;
            }
        }

        vcell = gnc_table_get_virtual_cell (table, vloc.vcell_loc);
        if ((vcell == NULL) || (vcell->cellblock == NULL) || !vcell->visible)
            return FALSE;

        cell = gnc_cellblock_get_cell (vcell->cellblock,
                                       vloc.phys_row_offset,
                                       vloc.phys_col_offset);
        if (!cell)
            continue;

        io_flags = gnc_table_get_io_flags (table, vloc);

        if (!(io_flags & XACC_CELL_ALLOW_INPUT))
            continue;

        if (io_flags & XACC_CELL_ALLOW_EXACT_ONLY)
            continue;

        break;
    }

    {
        gboolean changed = !virt_loc_equal (vloc, *virt_loc);

        *virt_loc = vloc;

        return changed;
    }
}

gboolean
gnc_table_move_vertical_position (Table *table,
                                  VirtualLocation *virt_loc,
                                  int phys_row_offset)
{
    VirtualLocation vloc;
    VirtualCell *vcell;
    gint last_visible_row;

    if ((table == NULL) || (virt_loc == NULL))
        return FALSE;

    vloc = *virt_loc;
    last_visible_row = vloc.vcell_loc.virt_row;

    vcell = gnc_table_get_virtual_cell (table, vloc.vcell_loc);
    if ((vcell == NULL) || (vcell->cellblock == NULL))
        return FALSE;

    while (phys_row_offset != 0)
    {
        /* going up */
        if (phys_row_offset < 0)
        {
            phys_row_offset++;

            /* room left in the current cursor */
            if (vloc.phys_row_offset > 0)
            {
                vloc.phys_row_offset--;
                continue;
            }

            /* end of the line */
            if (vloc.vcell_loc.virt_row == 1)
                break;

            do
            {
                vloc.vcell_loc.virt_row--;

                vcell = gnc_table_get_virtual_cell (table, vloc.vcell_loc);
            }
            while (vcell && vcell->cellblock && !vcell->visible);

            if (!vcell || !vcell->cellblock)
                break;

            last_visible_row = vloc.vcell_loc.virt_row;
            vloc.phys_row_offset = vcell->cellblock->num_rows - 1;
        }
        /* going down */
        else
        {
            phys_row_offset--;

            /* room left in the current cursor */
            if (vloc.phys_row_offset < (vcell->cellblock->num_rows - 1))
            {
                vloc.phys_row_offset++;
                continue;
            }

            /* end of the line */
            if (vloc.vcell_loc.virt_row == (table->num_virt_rows - 1))
                break;

            do
            {
                vloc.vcell_loc.virt_row++;

                vcell = gnc_table_get_virtual_cell (table, vloc.vcell_loc);
            }
            while (vcell && vcell->cellblock && !vcell->visible);

            if (!vcell || !vcell->cellblock)
                break;

            last_visible_row = vloc.vcell_loc.virt_row;
            vloc.phys_row_offset = 0;
        }
    }

    vloc.vcell_loc.virt_row = last_visible_row;

    {
        gboolean changed = !virt_loc_equal (vloc, *virt_loc);

        *virt_loc = vloc;

        return changed;
    }
}

gboolean
gnc_table_traverse_update(Table *table,
                          VirtualLocation virt_loc,
                          gncTableTraversalDir dir,
                          VirtualLocation *dest_loc)
{
    gboolean abort_move;

    if ((table == NULL) || (dest_loc == NULL))
        return FALSE;

    ENTER("proposed (%d %d) -> (%d %d)\n",
          virt_loc.vcell_loc.virt_row, virt_loc.vcell_loc.virt_row,
          dest_loc->vcell_loc.virt_row, dest_loc->vcell_loc.virt_col);

    /* first, make sure our destination cell is valid. If it is out
     * of bounds report an error. I don't think this ever happens. */
    if (gnc_table_virtual_cell_out_of_bounds (table, dest_loc->vcell_loc))
    {
        PERR("destination (%d, %d) out of bounds (%d, %d)\n",
             dest_loc->vcell_loc.virt_row, dest_loc->vcell_loc.virt_col,
             table->num_virt_rows, table->num_virt_cols);
        LEAVE("");
        return TRUE;
    }

    /* next, check the current row and column.  If they are out of bounds
     * we can recover by treating the traversal as a mouse point. This can
     * occur whenever the register widget is resized smaller, maybe?. */
    if (!gnc_table_virtual_loc_valid (table, virt_loc, TRUE))
    {
        PINFO("source (%d, %d) out of bounds (%d, %d)\n",
              virt_loc.vcell_loc.virt_row, virt_loc.vcell_loc.virt_col,
              table->num_virt_rows, table->num_virt_cols);

        dir = GNC_TABLE_TRAVERSE_POINTER;
    }

    /* process forward-moving traversals */
    switch (dir)
    {
    case GNC_TABLE_TRAVERSE_RIGHT:
    case GNC_TABLE_TRAVERSE_LEFT:
        gnc_table_find_valid_cell_horiz(table, dest_loc, FALSE);

        break;

    case GNC_TABLE_TRAVERSE_UP:
    case GNC_TABLE_TRAVERSE_DOWN:
    {
        VirtualLocation new_loc = *dest_loc;
        int increment;
        int col_offset = 0;
        gboolean second_traversal = FALSE;

        /* Keep going in the specified direction until we find a valid
         * row to land on, or we hit the end of the table. At the end,
         * turn around and go back until we find a valid row or we get
         * to where we started. If we still can't find anything, try
         * going left and right. */
        increment = (dir == GNC_TABLE_TRAVERSE_DOWN) ? 1 : -1;

        while (!gnc_table_virtual_loc_valid(table, new_loc, FALSE))
        {
            if (virt_loc_equal (new_loc, virt_loc))
            {
                new_loc = *dest_loc;
                gnc_table_find_valid_cell_horiz(table, &new_loc, FALSE);
                break;
            }

            if (!gnc_table_move_vertical_position (table, &new_loc, increment))
            {
                /* Special case: if there is no valid cell at all in the column
                 * we are scanning, (both up and down directions didn't work)
                 * attempt to do the same in the next column.
                 * Hack alert: there is no check to see if there really is a
                 * valid next column. However this situation so far only happens
                 * after a pagedown/pageup key event in the SX transaction editor
                 * which always tests the first column to start (which has no
                 * editable cells) and in that situation there is a valid next column.
                 */
                if (!second_traversal)
                    second_traversal = TRUE;
                else
                {
                    second_traversal = FALSE;
                    col_offset++;
                }
                increment *= -1;
                new_loc = *dest_loc;
                new_loc.phys_col_offset = new_loc.phys_col_offset + col_offset;
            }
        }

        *dest_loc = new_loc;
    }

    if (!gnc_table_virtual_loc_valid(table, *dest_loc, FALSE))
    {
        LEAVE("");
        return TRUE;
    }

    break;

    case GNC_TABLE_TRAVERSE_POINTER:
        if (!gnc_table_find_valid_cell_horiz(table, dest_loc, TRUE))
        {
            LEAVE("");
            return TRUE;
        }

        break;

    default:
        g_return_val_if_fail (FALSE, TRUE);
        break;
    }

    /* Call the table traverse callback for any modifications. */
    if (table->control->traverse)
        abort_move = table->control->traverse (dest_loc, dir,
                                               table->control->user_data);
    else
        abort_move = FALSE;

    LEAVE("dest_row = %d, dest_col = %d\n",
          dest_loc->vcell_loc.virt_row, dest_loc->vcell_loc.virt_col);

    return abort_move;
}