callisto-debian/evolution
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
af5fc4f982fb82bbcee445d7368ebd714bebdae3
evolution/widgets/table/e-table-model.c
Not Zed 58eba683f8 Changed to take into account the sort group, if the table has one.x 
2000-10-04  Not Zed  <NotZed@HelixCode.com>

        * e-table-sorted-variable.c (etsv_add): Changed to take into
        account the sort group, if the table has one.x
        (etsv_insert_idle): Clear the insert count if we hit an idle loop.
        (etsv_sort_idle): Reset the insert count if we perform a sort.
        (etsv_add): If we are adding a lot (>ETSV_INSERT_MAX) items,
        without hitting an idle loop, assume we're better off performing a
        sort instead.  Use another idle handler to reset the count.

2000-10-03  Not Zed  <NotZed@HelixCode.com>

        * e-table-sorted-variable.c (etsv_sort_by_group): Sort based on
        the sort_group stuff.

        * e-tree-model.c (e_tree_init): Setup the group sort info string.
        (etree_destroy): And free it.
        (build_sort_group): Build a string for this node.

2000-09-29  Not Zed  <NotZed@HelixCode.com>

        * e-cell-tree.c (e_cell_tree_get_node): Changed to take the source
        model, not the tree model.  The source model may be a subset, and
        it needs to remap the rows for us.
        (ect_draw):
        (ect_event):
        (ect_max_width):
        (ect_print): Changed callers.

        * e-table-sorted-variable.c (etsv_sort_subset):
        (etsv_sort_build_subset):
        (etsv_sort_free_subset): Functions to perfom grouping of sorts for
        sorts that have row_sort_group returning useful info.
        (etsv_sort): Use the complex sort routines if we need to.

        * e-table-model.c (e_table_model_row_sort_group): Return a sort-id
        for a given row.
        (e_table_model_has_sort_group): Return if the sort-id provides any
        useful information.

svn path=/trunk/; revision=5705
2000-10-04 15:51:35 +00:00

382 lines
10 KiB
C
Raw Blame History

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* e-table-model.c: a Table Model
*
* Author:
* Miguel de Icaza (miguel@gnu.org)
*
* (C) 1999 Helix Code, Inc.
*/
#include <config.h>
#include <gtk/gtksignal.h>
#include "e-table-model.h"
#define ETM_CLASS(e) ((ETableModelClass *)((GtkObject *)e)->klass)
#define PARENT_TYPE gtk_object_get_type ()
#define d(x)
d(static gint depth = 0);
static GtkObjectClass *e_table_model_parent_class;
enum {
MODEL_CHANGED,
MODEL_PRE_CHANGE,
MODEL_ROW_CHANGED,
MODEL_CELL_CHANGED,
MODEL_ROW_INSERTED,
MODEL_ROW_DELETED,
ROW_SELECTION,
LAST_SIGNAL
};
static guint e_table_model_signals [LAST_SIGNAL] = { 0, };
int
e_table_model_column_count (ETableModel *e_table_model)
{
g_return_val_if_fail (e_table_model != NULL, 0);
g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), 0);
return ETM_CLASS (e_table_model)->column_count (e_table_model);
}
int
e_table_model_row_count (ETableModel *e_table_model)
{
g_return_val_if_fail (e_table_model != NULL, 0);
g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), 0);
return ETM_CLASS (e_table_model)->row_count (e_table_model);
}
void *
e_table_model_value_at (ETableModel *e_table_model, int col, int row)
{
g_return_val_if_fail (e_table_model != NULL, NULL);
g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), NULL);
return ETM_CLASS (e_table_model)->value_at (e_table_model, col, row);
}
void
e_table_model_set_value_at (ETableModel *e_table_model, int col, int row, const void *data)
{
g_return_if_fail (e_table_model != NULL);
g_return_if_fail (E_IS_TABLE_MODEL (e_table_model));
ETM_CLASS (e_table_model)->set_value_at (e_table_model, col, row, data);
}
gboolean
e_table_model_is_cell_editable (ETableModel *e_table_model, int col, int row)
{
g_return_val_if_fail (e_table_model != NULL, FALSE);
g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), FALSE);
return ETM_CLASS (e_table_model)->is_cell_editable (e_table_model, col, row);
}
void
e_table_model_append_row (ETableModel *e_table_model, ETableModel *source, int row)
{
g_return_if_fail (e_table_model != NULL);
g_return_if_fail (E_IS_TABLE_MODEL (e_table_model));
if (ETM_CLASS (e_table_model)->append_row)
ETM_CLASS (e_table_model)->append_row (e_table_model, source, row);
}
const char *
e_table_model_row_sort_group(ETableModel *e_table_model, int row)
{
g_return_val_if_fail (e_table_model != NULL, "/");
g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), "/");
if (ETM_CLASS (e_table_model)->row_sort_group)
return ETM_CLASS (e_table_model)->row_sort_group (e_table_model, row);
else
return "/";
}
gboolean
e_table_model_has_sort_group(ETableModel *e_table_model)
{
g_return_val_if_fail (e_table_model != NULL, FALSE);
g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), FALSE);
if (ETM_CLASS (e_table_model)->has_sort_group)
return ETM_CLASS (e_table_model)->has_sort_group (e_table_model);
else
return FALSE;
}
void *
e_table_model_duplicate_value (ETableModel *e_table_model, int col, const void *value)
{
g_return_val_if_fail (e_table_model != NULL, NULL);
g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), NULL);
if (ETM_CLASS (e_table_model)->duplicate_value)
return ETM_CLASS (e_table_model)->duplicate_value (e_table_model, col, value);
else
return NULL;
}
void
e_table_model_free_value (ETableModel *e_table_model, int col, void *value)
{
g_return_if_fail (e_table_model != NULL);
g_return_if_fail (E_IS_TABLE_MODEL (e_table_model));
if (ETM_CLASS (e_table_model)->free_value)
ETM_CLASS (e_table_model)->free_value (e_table_model, col, value);
}
void *
e_table_model_initialize_value (ETableModel *e_table_model, int col)
{
g_return_val_if_fail (e_table_model != NULL, NULL);
g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), NULL);
if (ETM_CLASS (e_table_model)->initialize_value)
return ETM_CLASS (e_table_model)->initialize_value (e_table_model, col);
else
return NULL;
}
gboolean
e_table_model_value_is_empty (ETableModel *e_table_model, int col, const void *value)
{
g_return_val_if_fail (e_table_model != NULL, FALSE);
g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), FALSE);
if (ETM_CLASS (e_table_model)->value_is_empty)
return ETM_CLASS (e_table_model)->value_is_empty (e_table_model, col, value);
else
return FALSE;
}
char *
e_table_model_value_to_string (ETableModel *e_table_model, int col, const void *value)
{
g_return_val_if_fail (e_table_model != NULL, NULL);
g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), NULL);
if (ETM_CLASS (e_table_model)->value_to_string)
return ETM_CLASS (e_table_model)->value_to_string (e_table_model, col, value);
else
return g_strdup("");
}
static void
e_table_model_destroy (GtkObject *object)
{
if (e_table_model_parent_class->destroy)
(*e_table_model_parent_class->destroy)(object);
}
static void
e_table_model_class_init (GtkObjectClass *object_class)
{
ETableModelClass *klass = E_TABLE_MODEL_CLASS(object_class);
e_table_model_parent_class = gtk_type_class (PARENT_TYPE);
object_class->destroy = e_table_model_destroy;
e_table_model_signals [MODEL_CHANGED] =
gtk_signal_new ("model_changed",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (ETableModelClass, model_changed),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
e_table_model_signals [MODEL_PRE_CHANGE] =
gtk_signal_new ("model_pre_change",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (ETableModelClass, model_pre_change),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
e_table_model_signals [MODEL_ROW_CHANGED] =
gtk_signal_new ("model_row_changed",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (ETableModelClass, model_row_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1, GTK_TYPE_INT);
e_table_model_signals [MODEL_CELL_CHANGED] =
gtk_signal_new ("model_cell_changed",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (ETableModelClass, model_cell_changed),
gtk_marshal_NONE__INT_INT,
GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);
e_table_model_signals [MODEL_ROW_INSERTED] =
gtk_signal_new ("model_row_inserted",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (ETableModelClass, model_row_inserted),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1, GTK_TYPE_INT);
e_table_model_signals [MODEL_ROW_DELETED] =
gtk_signal_new ("model_row_deleted",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (ETableModelClass, model_row_deleted),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1, GTK_TYPE_INT);
gtk_object_class_add_signals (object_class, e_table_model_signals, LAST_SIGNAL);
klass->column_count = NULL;
klass->row_count = NULL;
klass->value_at = NULL;
klass->set_value_at = NULL;
klass->is_cell_editable = NULL;
klass->append_row = NULL;
klass->row_sort_group = NULL;
klass->has_sort_group = NULL;
klass->duplicate_value = NULL;
klass->free_value = NULL;
klass->initialize_value = NULL;
klass->value_is_empty = NULL;
klass->value_to_string = NULL;
klass->model_changed = NULL;
klass->model_row_changed = NULL;
klass->model_cell_changed = NULL;
klass->model_row_inserted = NULL;
klass->model_row_deleted = NULL;
}
guint
e_table_model_get_type (void)
{
static guint type = 0;
if (!type)
{
GtkTypeInfo info =
{
"ETableModel",
sizeof (ETableModel),
sizeof (ETableModelClass),
(GtkClassInitFunc) e_table_model_class_init,
NULL,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
type = gtk_type_unique (PARENT_TYPE, &info);
}
return type;
}
#if d(!)0
static void
print_tabs (void)
{
int i;
for (i = 0; i < depth; i++)
g_print("\t");
}
#endif
void
e_table_model_pre_change (ETableModel *e_table_model)
{
g_return_if_fail (e_table_model != NULL);
g_return_if_fail (E_IS_TABLE_MODEL (e_table_model));
d(print_tabs());
d(g_print("Emitting pre_change on model 0x%p.\n", e_table_model));
d(depth++);
gtk_signal_emit (GTK_OBJECT (e_table_model),
e_table_model_signals [MODEL_PRE_CHANGE]);
d(depth--);
}
void
e_table_model_changed (ETableModel *e_table_model)
{
g_return_if_fail (e_table_model != NULL);
g_return_if_fail (E_IS_TABLE_MODEL (e_table_model));
d(print_tabs());
d(g_print("Emitting model_changed on model 0x%p.\n", e_table_model));
d(depth++);
gtk_signal_emit (GTK_OBJECT (e_table_model),
e_table_model_signals [MODEL_CHANGED]);
d(depth--);
}
void
e_table_model_row_changed (ETableModel *e_table_model, int row)
{
g_return_if_fail (e_table_model != NULL);
g_return_if_fail (E_IS_TABLE_MODEL (e_table_model));
d(print_tabs());
d(g_print("Emitting row_changed on model 0x%p, row %d.\n", e_table_model, row));
d(depth++);
gtk_signal_emit (GTK_OBJECT (e_table_model),
e_table_model_signals [MODEL_ROW_CHANGED], row);
d(depth--);
}
void
e_table_model_cell_changed (ETableModel *e_table_model, int col, int row)
{
g_return_if_fail (e_table_model != NULL);
g_return_if_fail (E_IS_TABLE_MODEL (e_table_model));
d(print_tabs());
d(g_print("Emitting cell_changed on model 0x%p, row %d, col %d.\n", e_table_model, row, col));
d(depth++);
gtk_signal_emit (GTK_OBJECT (e_table_model),
e_table_model_signals [MODEL_CELL_CHANGED], col, row);
d(depth--);
}
void
e_table_model_row_inserted (ETableModel *e_table_model, int row)
{
g_return_if_fail (e_table_model != NULL);
g_return_if_fail (E_IS_TABLE_MODEL (e_table_model));
d(print_tabs());
d(g_print("Emitting row_inserted on model 0x%p, row %d.\n", e_table_model, row));
d(depth++);
gtk_signal_emit (GTK_OBJECT (e_table_model),
e_table_model_signals [MODEL_ROW_INSERTED], row);
d(depth--);
}
void
e_table_model_row_deleted (ETableModel *e_table_model, int row)
{
g_return_if_fail (e_table_model != NULL);
g_return_if_fail (E_IS_TABLE_MODEL (e_table_model));
d(print_tabs());
d(g_print("Emitting row_deleted on model 0x%p, row %d.\n", e_table_model, row));
d(depth++);
gtk_signal_emit (GTK_OBJECT (e_table_model),
e_table_model_signals [MODEL_ROW_DELETED], row);
d(depth--);
}
Reference in New Issue View Git Blame Copy Permalink