path: root/e-util/e-table-subset.c

/*
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 *
 * Authors:
 *      Chris Lahey <clahey@ximian.com>
 *      Miguel de Icaza <miguel@ximian.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdlib.h>

#include "e-table-subset.h"

#define E_TABLE_SUBSET_GET_PRIVATE(obj) \
    (G_TYPE_INSTANCE_GET_PRIVATE \
    ((obj), E_TYPE_TABLE_SUBSET, ETableSubsetPrivate))

#define VALID_ROW(table_subset, row) \
    (row >= -1 && row < table_subset->n_map)
#define MAP_ROW(table_subset, row) \
    (row == -1 ? -1 : table_subset->map_table[row])

#define d(x)

struct _ETableSubsetPrivate {
    ETableModel *source_model;
    gulong table_model_pre_change_handler_id;
    gulong table_model_no_change_handler_id;
    gulong table_model_changed_handler_id;
    gulong table_model_row_changed_handler_id;
    gulong table_model_cell_changed_handler_id;
    gulong table_model_rows_inserted_handler_id;
    gulong table_model_rows_deleted_handler_id;

    gint last_access;
};

/* Forward Declarations */
static void e_table_subset_table_model_init
                    (ETableModelInterface *interface);

G_DEFINE_TYPE_WITH_CODE (
    ETableSubset,
    e_table_subset,
    G_TYPE_OBJECT,
    G_IMPLEMENT_INTERFACE (
        E_TYPE_TABLE_MODEL,
        e_table_subset_table_model_init))

static gint
table_subset_get_view_row (ETableSubset *table_subset,
                           gint row)
{
    const gint n = table_subset->n_map;
    const gint * const map_table = table_subset->map_table;
    gint i;

    gint end = MIN (
        table_subset->n_map,
        table_subset->priv->last_access + 10);
    gint start = MAX (0, table_subset->priv->last_access - 10);
    gint initial = MAX (MIN (table_subset->priv->last_access, end), start);

    for (i = initial; i < end; i++) {
        if (map_table[i] == row) {
            table_subset->priv->last_access = i;
            return i;
        }
    }

    for (i = initial - 1; i >= start; i--) {
        if (map_table[i] == row) {
            table_subset->priv->last_access = i;
            return i;
        }
    }

    for (i = 0; i < n; i++) {
        if (map_table[i] == row) {
            table_subset->priv->last_access = i;
            return i;
        }
    }
    return -1;
}

static void
table_subset_dispose (GObject *object)
{
    ETableSubsetPrivate *priv;

    priv = E_TABLE_SUBSET_GET_PRIVATE (object);

    if (priv->table_model_pre_change_handler_id > 0) {
        g_signal_handler_disconnect (
            priv->source_model,
            priv->table_model_pre_change_handler_id);
        priv->table_model_pre_change_handler_id = 0;
    }

    if (priv->table_model_no_change_handler_id > 0) {
        g_signal_handler_disconnect (
            priv->source_model,
            priv->table_model_no_change_handler_id);
        priv->table_model_no_change_handler_id = 0;
    }

    if (priv->table_model_changed_handler_id > 0) {
        g_signal_handler_disconnect (
            priv->source_model,
            priv->table_model_changed_handler_id);
        priv->table_model_changed_handler_id = 0;
    }

    if (priv->table_model_row_changed_handler_id > 0) {
        g_signal_handler_disconnect (
            priv->source_model,
            priv->table_model_row_changed_handler_id);
        priv->table_model_row_changed_handler_id = 0;
    }

    if (priv->table_model_cell_changed_handler_id > 0) {
        g_signal_handler_disconnect (
            priv->source_model,
            priv->table_model_cell_changed_handler_id);
        priv->table_model_cell_changed_handler_id = 0;
    }

    if (priv->table_model_rows_inserted_handler_id > 0) {
        g_signal_handler_disconnect (
            priv->source_model,
            priv->table_model_rows_inserted_handler_id);
        priv->table_model_rows_inserted_handler_id = 0;
    }

    if (priv->table_model_rows_deleted_handler_id > 0) {
        g_signal_handler_disconnect (
            priv->source_model,
            priv->table_model_rows_deleted_handler_id);
        priv->table_model_rows_deleted_handler_id = 0;
    }

    g_clear_object (&priv->source_model);

    /* Chain up to parent's dispose() method. */
    G_OBJECT_CLASS (e_table_subset_parent_class)->dispose (object);
}

static void
table_subset_finalize (GObject *object)
{
    ETableSubset *table_subset;

    table_subset = E_TABLE_SUBSET (object);

    g_free (table_subset->map_table);

    /* Chain up to parent's finalize() method. */
    G_OBJECT_CLASS (e_table_subset_parent_class)->finalize (object);
}

static void
table_subset_proxy_model_pre_change_real (ETableSubset *table_subset,
                                          ETableModel *source_model)
{
    e_table_model_pre_change (E_TABLE_MODEL (table_subset));
}

static void
table_subset_proxy_model_no_change_real (ETableSubset *table_subset,
                                         ETableModel *source_model)
{
    e_table_model_no_change (E_TABLE_MODEL (table_subset));
}

static void
table_subset_proxy_model_changed_real (ETableSubset *table_subset,
                                       ETableModel *source_model)
{
    e_table_model_changed (E_TABLE_MODEL (table_subset));
}

static void
table_subset_proxy_model_row_changed_real (ETableSubset *table_subset,
                                           ETableModel *source_model,
                                           gint row)
{
    gint view_row = table_subset_get_view_row (table_subset, row);

    if (view_row != -1)
        e_table_model_row_changed (
            E_TABLE_MODEL (table_subset), view_row);
    else
        e_table_model_no_change (E_TABLE_MODEL (table_subset));
}

static void
table_subset_proxy_model_cell_changed_real (ETableSubset *table_subset,
                                            ETableModel *source_model,
                                            gint col,
                                            gint row)
{
    gint view_row = table_subset_get_view_row (table_subset, row);

    if (view_row != -1)
        e_table_model_cell_changed (
            E_TABLE_MODEL (table_subset), col, view_row);
    else
        e_table_model_no_change (E_TABLE_MODEL (table_subset));
}

static void
table_subset_proxy_model_rows_inserted_real (ETableSubset *table_subset,
                                             ETableModel *source_model,
                                             gint row,
                                             gint count)
{
    e_table_model_no_change (E_TABLE_MODEL (table_subset));
}

static void
table_subset_proxy_model_rows_deleted_real (ETableSubset *table_subset,
                                            ETableModel *source_model,
                                            gint row,
                                            gint count)
{
    e_table_model_no_change (E_TABLE_MODEL (table_subset));
}

static gint
table_subset_column_count (ETableModel *table_model)
{
    ETableSubset *table_subset = (ETableSubset *) table_model;

    return e_table_model_column_count (table_subset->priv->source_model);
}

static gint
table_subset_row_count (ETableModel *table_model)
{
    ETableSubset *table_subset = (ETableSubset *) table_model;

    return table_subset->n_map;
}

static gpointer
table_subset_value_at (ETableModel *table_model,
                       gint col,
                       gint row)
{
    ETableSubset *table_subset = (ETableSubset *) table_model;

    g_return_val_if_fail (VALID_ROW (table_subset, row), NULL);

    table_subset->priv->last_access = row;

    return e_table_model_value_at (
        table_subset->priv->source_model,
        col, MAP_ROW (table_subset, row));
}

static void
table_subset_set_value_at (ETableModel *table_model,
                           gint col,
                           gint row,
                           gconstpointer val)
{
    ETableSubset *table_subset = (ETableSubset *) table_model;

    g_return_if_fail (VALID_ROW (table_subset, row));

    table_subset->priv->last_access = row;

    e_table_model_set_value_at (
        table_subset->priv->source_model,
        col, MAP_ROW (table_subset, row), val);
}

static gboolean
table_subset_is_cell_editable (ETableModel *table_model,
                               gint col,
                               gint row)
{
    ETableSubset *table_subset = (ETableSubset *) table_model;

    g_return_val_if_fail (VALID_ROW (table_subset, row), FALSE);

    return e_table_model_is_cell_editable (
        table_subset->priv->source_model,
        col, MAP_ROW (table_subset, row));
}

static gboolean
table_subset_has_save_id (ETableModel *table_model)
{
    return TRUE;
}

static gchar *
table_subset_get_save_id (ETableModel *table_model,
                          gint row)
{
    ETableSubset *table_subset = (ETableSubset *) table_model;

    g_return_val_if_fail (VALID_ROW (table_subset, row), NULL);

    if (e_table_model_has_save_id (table_subset->priv->source_model))
        return e_table_model_get_save_id (
            table_subset->priv->source_model,
            MAP_ROW (table_subset, row));
    else
        return g_strdup_printf ("%d", MAP_ROW (table_subset, row));
}

static void
table_subset_append_row (ETableModel *table_model,
                         ETableModel *source,
                         gint row)
{
    ETableSubset *table_subset = (ETableSubset *) table_model;

    e_table_model_append_row (
        table_subset->priv->source_model, source, row);
}

static gpointer
table_subset_duplicate_value (ETableModel *table_model,
                              gint col,
                              gconstpointer value)
{
    ETableSubset *table_subset = (ETableSubset *) table_model;

    return e_table_model_duplicate_value (
        table_subset->priv->source_model, col, value);
}

static void
table_subset_free_value (ETableModel *table_model,
                         gint col,
                         gpointer value)
{
    ETableSubset *table_subset = (ETableSubset *) table_model;

    e_table_model_free_value (
        table_subset->priv->source_model, col, value);
}

static gpointer
table_subset_initialize_value (ETableModel *table_model,
                               gint col)
{
    ETableSubset *table_subset = (ETableSubset *) table_model;

    return e_table_model_initialize_value (
        table_subset->priv->source_model, col);
}

static gboolean
table_subset_value_is_empty (ETableModel *table_model,
                             gint col,
                             gconstpointer value)
{
    ETableSubset *table_subset = (ETableSubset *) table_model;

    return e_table_model_value_is_empty (
        table_subset->priv->source_model, col, value);
}

static gchar *
table_subset_value_to_string (ETableModel *table_model,
                              gint col,
                              gconstpointer value)
{
    ETableSubset *table_subset = (ETableSubset *) table_model;

    return e_table_model_value_to_string (
        table_subset->priv->source_model, col, value);
}

static void
e_table_subset_class_init (ETableSubsetClass *class)
{
    GObjectClass *object_class;

    g_type_class_add_private (class, sizeof (ETableSubsetPrivate));

    object_class = G_OBJECT_CLASS (class);
    object_class->dispose = table_subset_dispose;
    object_class->finalize = table_subset_finalize;

    class->proxy_model_pre_change = table_subset_proxy_model_pre_change_real;
    class->proxy_model_no_change = table_subset_proxy_model_no_change_real;
    class->proxy_model_changed = table_subset_proxy_model_changed_real;
    class->proxy_model_row_changed = table_subset_proxy_model_row_changed_real;
    class->proxy_model_cell_changed = table_subset_proxy_model_cell_changed_real;
    class->proxy_model_rows_inserted = table_subset_proxy_model_rows_inserted_real;
    class->proxy_model_rows_deleted = table_subset_proxy_model_rows_deleted_real;
}

static void
e_table_subset_table_model_init (ETableModelInterface *interface)
{
    interface->column_count = table_subset_column_count;
    interface->row_count = table_subset_row_count;
    interface->append_row = table_subset_append_row;

    interface->value_at = table_subset_value_at;
    interface->set_value_at = table_subset_set_value_at;
    interface->is_cell_editable = table_subset_is_cell_editable;

    interface->has_save_id = table_subset_has_save_id;
    interface->get_save_id = table_subset_get_save_id;

    interface->duplicate_value = table_subset_duplicate_value;
    interface->free_value = table_subset_free_value;
    interface->initialize_value = table_subset_initialize_value;
    interface->value_is_empty = table_subset_value_is_empty;
    interface->value_to_string = table_subset_value_to_string;
}

static void
e_table_subset_init (ETableSubset *table_subset)
{
    table_subset->priv = E_TABLE_SUBSET_GET_PRIVATE (table_subset);
}

static void
table_subset_proxy_model_pre_change (ETableModel *source_model,
                                     ETableSubset *table_subset)
{
    ETableSubsetClass *class;

    class = E_TABLE_SUBSET_GET_CLASS (table_subset);

    if (class->proxy_model_pre_change != NULL)
        class->proxy_model_pre_change (table_subset, source_model);
}

static void
table_subset_proxy_model_no_change (ETableModel *source_model,
                                    ETableSubset *table_subset)
{
    ETableSubsetClass *class;

    class = E_TABLE_SUBSET_GET_CLASS (table_subset);

    if (class->proxy_model_no_change != NULL)
        class->proxy_model_no_change (table_subset, source_model);
}

static void
table_subset_proxy_model_changed (ETableModel *source_model,
                                  ETableSubset *table_subset)
{
    ETableSubsetClass *class;

    class = E_TABLE_SUBSET_GET_CLASS (table_subset);

    if (class->proxy_model_changed != NULL)
        class->proxy_model_changed (table_subset, source_model);
}

static void
table_subset_proxy_model_row_changed (ETableModel *source_model,
                                      gint row,
                                      ETableSubset *table_subset)
{
    ETableSubsetClass *class;

    class = E_TABLE_SUBSET_GET_CLASS (table_subset);

    if (class->proxy_model_row_changed != NULL)
        class->proxy_model_row_changed (
            table_subset, source_model, row);
}

static void
table_subset_proxy_model_cell_changed (ETableModel *source_model,
                                       gint col,
                                       gint row,
                                       ETableSubset *table_subset)
{
    ETableSubsetClass *class;

    class = E_TABLE_SUBSET_GET_CLASS (table_subset);

    if (class->proxy_model_cell_changed != NULL)
        class->proxy_model_cell_changed (
            table_subset, source_model, col, row);
}

static void
table_subset_proxy_model_rows_inserted (ETableModel *source_model,
                                        gint row,
                                        gint col,
                                        ETableSubset *table_subset)
{
    ETableSubsetClass *class;

    class = E_TABLE_SUBSET_GET_CLASS (table_subset);

    if (class->proxy_model_rows_inserted != NULL)
        class->proxy_model_rows_inserted (
            table_subset, source_model, row, col);
}

static void
table_subset_proxy_model_rows_deleted (ETableModel *source_model,
                                       gint row,
                                       gint col,
                                       ETableSubset *table_subset)
{
    ETableSubsetClass *class;

    class = E_TABLE_SUBSET_GET_CLASS (table_subset);

    if (class->proxy_model_rows_deleted != NULL)
        class->proxy_model_rows_deleted (
            table_subset, source_model, row, col);
}

ETableModel *
e_table_subset_construct (ETableSubset *table_subset,
                          ETableModel *source_model,
                          gint nvals)
{
    gulong handler_id;
    guint *buffer = NULL;
    gint i;

    if (nvals > 0)
        buffer = (guint *) g_malloc (sizeof (guint) * nvals);
    table_subset->map_table = (gint *) buffer;
    table_subset->n_map = nvals;
    table_subset->priv->source_model = g_object_ref (source_model);

    /* Init */
    for (i = 0; i < nvals; i++)
        table_subset->map_table[i] = i;

    handler_id = g_signal_connect (
        source_model, "model_pre_change",
        G_CALLBACK (table_subset_proxy_model_pre_change),
        table_subset);
    table_subset->priv->table_model_pre_change_handler_id = handler_id;

    handler_id = g_signal_connect (
        source_model, "model_no_change",
        G_CALLBACK (table_subset_proxy_model_no_change),
        table_subset);
    table_subset->priv->table_model_no_change_handler_id = handler_id;

    handler_id = g_signal_connect (
        source_model, "model_changed",
        G_CALLBACK (table_subset_proxy_model_changed),
        table_subset);
    table_subset->priv->table_model_changed_handler_id = handler_id;

    handler_id = g_signal_connect (
        source_model, "model_row_changed",
        G_CALLBACK (table_subset_proxy_model_row_changed),
        table_subset);
    table_subset->priv->table_model_row_changed_handler_id = handler_id;

    handler_id = g_signal_connect (
        source_model, "model_cell_changed",
        G_CALLBACK (table_subset_proxy_model_cell_changed),
        table_subset);
    table_subset->priv->table_model_cell_changed_handler_id = handler_id;

    handler_id = g_signal_connect (
        source_model, "model_rows_inserted",
        G_CALLBACK (table_subset_proxy_model_rows_inserted),
        table_subset);
    table_subset->priv->table_model_rows_inserted_handler_id = handler_id;

    handler_id = g_signal_connect (
        source_model, "model_rows_deleted",
        G_CALLBACK (table_subset_proxy_model_rows_deleted),
        table_subset);
    table_subset->priv->table_model_rows_deleted_handler_id = handler_id;

    return E_TABLE_MODEL (table_subset);
}

ETableModel *
e_table_subset_new (ETableModel *source_model,
                    const gint nvals)
{
    ETableSubset *table_subset;

    g_return_val_if_fail (E_IS_TABLE_MODEL (source_model), NULL);

    table_subset = g_object_new (E_TYPE_TABLE_SUBSET, NULL);

    if (e_table_subset_construct (table_subset, source_model, nvals) == NULL) {
        g_object_unref (table_subset);
        return NULL;
    }

    return (ETableModel *) table_subset;
}

ETableModel *
e_table_subset_get_source_model (ETableSubset *table_subset)
{
    g_return_val_if_fail (E_IS_TABLE_SUBSET (table_subset), NULL);

    return table_subset->priv->source_model;
}

gint
e_table_subset_model_to_view_row (ETableSubset *table_subset,
                                  gint model_row)
{
    gint i;

    g_return_val_if_fail (E_IS_TABLE_SUBSET (table_subset), -1);

    for (i = 0; i < table_subset->n_map; i++) {
        if (table_subset->map_table[i] == model_row)
            return i;
    }
    return -1;
}

gint
e_table_subset_view_to_model_row (ETableSubset *table_subset,
                                  gint view_row)
{
    g_return_val_if_fail (E_IS_TABLE_SUBSET (table_subset), -1);

    if (view_row >= 0 && view_row < table_subset->n_map)
        return table_subset->map_table[view_row];
    else
        return -1;
}

ETableModel *
e_table_subset_get_toplevel (ETableSubset *table_subset)
{
    g_return_val_if_fail (E_IS_TABLE_SUBSET (table_subset), NULL);

    if (E_IS_TABLE_SUBSET (table_subset->priv->source_model))
        return e_table_subset_get_toplevel (
            E_TABLE_SUBSET (table_subset->priv->source_model));
    else
        return table_subset->priv->source_model;
}

void
e_table_subset_print_debugging (ETableSubset *table_subset)
{
    gint i;

    g_return_if_fail (E_IS_TABLE_SUBSET (table_subset));

    for (i = 0; i < table_subset->n_map; i++) {
        g_print ("%8d\n", table_subset->map_table[i]);
    }
}