From 1190e292f4e32be10c45ffd92e36eb62e8592a53 Mon Sep 17 00:00:00 2001 From: Christopher James Lahey Date: Sun, 25 Mar 2001 08:17:15 +0000 Subject: Added e-selection-model-array.lo. 2001-03-25 Christopher James Lahey * gal/Makefile.am (libgal_la_LIBADD): Added e-selection-model-array.lo. * gal/widgets/Makefile.am: Added e-selection-model-array.c and e-selection-model-array.h. * gal/widgets/e-selection-model-array.c, gal/widgets/e-selection-model-array.h: New class that implements the details of ESelectionModel. ESelectionModel has been refactored to just be a this virtual class. ESelectionModelArray is the original implementation of ESelectionModel. This is what most people will want to use or derive from. * gal/widgets/e-selection-model-simple.c, gal/widgets/e-selection-model-simple.h: Made the parent class of this be ESelectionModelArray instead of ESelectionModel. Changed some function names to match this change. * gal/widgets/e-selection-model.c, gal/widgets/e-selection-model.h: Refactored most of the implementation of this class into ESelectionModelArray. Now just a thin virtual class. From gal/e-table/ChangeLog: 2001-03-25 Christopher James Lahey * e-table-selection-model.c, e-table-selection-model.h: Made the parent object of this be ESelectionModelArray instead of ESelectionModel due to their refactoring. Changed the commented out code for saving the selection a bit. svn path=/trunk/; revision=8924 --- widgets/misc/e-selection-model-array.c | 599 +++++++++++++++++++++++++++++ widgets/misc/e-selection-model-array.h | 66 ++++ widgets/misc/e-selection-model-simple.c | 31 +- widgets/misc/e-selection-model-simple.h | 6 +- widgets/misc/e-selection-model.c | 652 +++++++++----------------------- widgets/misc/e-selection-model.h | 99 ++--- 6 files changed, 924 insertions(+), 529 deletions(-) create mode 100644 widgets/misc/e-selection-model-array.c create mode 100644 widgets/misc/e-selection-model-array.h (limited to 'widgets/misc') diff --git a/widgets/misc/e-selection-model-array.c b/widgets/misc/e-selection-model-array.c new file mode 100644 index 0000000000..ecdbe35e5f --- /dev/null +++ b/widgets/misc/e-selection-model-array.c @@ -0,0 +1,599 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* + * e-selection-model-array.c: a Selection Model + * + * Author: + * Christopher James Lahey + * + * (C) 2000, 2001 Ximian, Inc. + */ +#include +#include +#include "e-selection-model-array.h" +#include "gal/util/e-util.h" +#include + +#define ESMA_CLASS(e) ((ESelectionModelArrayClass *)((GtkObject *)e)->klass) + +#define PARENT_TYPE e_selection_model_get_type () + +#define ONES ((guint32) 0xffffffff) + +#define BOX(n) ((n) / 32) +#define OFFSET(n) (31 - ((n) % 32)) +#define BITMASK(n) ((guint32)(((guint32) 0x1) << OFFSET((n)))) +#define BITMASK_LEFT(n) ((((n) % 32) == 0) ? 0 : (ONES << (32 - ((n) % 32)))) +#define BITMASK_RIGHT(n) ((guint32)(((guint32) ONES) >> ((n) % 32))) + +static ESelectionModelClass *parent_class; + +enum { + ARG_0, + ARG_CURSOR_ROW, + ARG_CURSOR_COL, +}; + +void +e_selection_model_array_confirm_row_count(ESelectionModelArray *esma) +{ + if (esma->row_count < 0) { + esma->row_count = e_selection_model_array_get_row_count(esma); + g_free(esma->selection); + esma->selection = g_new0(gint, (esma->row_count + 31) / 32); + } +} + +static void +e_selection_model_array_insert_row_real(ESelectionModelArray *esma, int row) +{ + int box; + int i; + if(esma->row_count >= 0) { + /* Add another word if needed. */ + if ((esma->row_count & 0x1f) == 0) { + esma->selection = g_renew(gint, esma->selection, (esma->row_count >> 5) + 1); + esma->selection[esma->row_count >> 5] = 0; + } + + /* The box is the word that our row is in. */ + box = BOX(row); + /* Shift all words to the right of our box right one bit. */ + for (i = esma->row_count >> 5; i > box; i--) { + esma->selection[i] = (esma->selection[i] >> 1) | (esma->selection[i - 1] << 31); + } + + /* Shift right half of box one bit to the right. */ + esma->selection[box] = (esma->selection[box] & BITMASK_LEFT(row)) | ((esma->selection[box] & BITMASK_RIGHT(row)) >> 1); + esma->row_count ++; + } + if (esma->cursor_row >= row) + esma->cursor_row ++; +} + +static void +e_selection_model_array_delete_row_real(ESelectionModelArray *esma, int row) +{ + int box; + int i; + int last; + int selected = FALSE; + if(esma->row_count >= 0) { + guint32 bitmask; + box = row >> 5; + last = esma->row_count >> 5; + + /* Build bitmasks for the left and right half of the box */ + bitmask = BITMASK_RIGHT(row) >> 1; + selected = e_selection_model_is_row_selected(E_SELECTION_MODEL(esma), row); + /* Shift right half of box one bit to the left. */ + esma->selection[box] = (esma->selection[box] & BITMASK_LEFT(row))| ((esma->selection[box] & bitmask) << 1); + + /* Shift all words to the right of our box left one bit. */ + if (box < last) { + esma->selection[box] &= esma->selection[box + 1] >> 31; + + for (i = box + 1; i < last; i++) { + esma->selection[i] = (esma->selection[i] << 1) | (esma->selection[i + 1] >> 31); + } + /* this over-runs our memory! */ + /*esma->selection[i] = esma->selection[i] << 1; */ + } + esma->row_count --; + /* Remove the last word if not needed. */ + if ((esma->row_count & 0x1f) == 0) { + esma->selection = g_renew(gint, esma->selection, esma->row_count >> 5); + } + if (selected && E_SELECTION_MODEL(esma)->mode == GTK_SELECTION_SINGLE) { + e_selection_model_select_single_row (E_SELECTION_MODEL(esma), row > 0 ? row - 1 : 0); + } + } + if (esma->cursor_row >= row && esma->cursor_row > 0) + esma->cursor_row --; +} + +/* FIXME : Improve efficiency here. */ +void +e_selection_model_array_delete_rows(ESelectionModelArray *esma, int row, int count) +{ + int i; + for (i = 0; i < count; i++) + e_selection_model_array_delete_row_real(esma, row); + e_selection_model_selection_changed(E_SELECTION_MODEL(esma)); + e_selection_model_cursor_changed(E_SELECTION_MODEL(esma), esma->cursor_row, esma->cursor_col); +} + +/* FIXME : Improve efficiency here. */ +void +e_selection_model_array_insert_rows(ESelectionModelArray *esma, int row, int count) +{ + int i; + for (i = 0; i < count; i++) + e_selection_model_array_insert_row_real(esma, row); + e_selection_model_selection_changed(E_SELECTION_MODEL(esma)); + e_selection_model_cursor_changed(E_SELECTION_MODEL(esma), esma->cursor_row, esma->cursor_col); +} + +/* FIXME: Implement this more efficiently. */ +void +e_selection_model_array_move_row(ESelectionModelArray *esma, int old_row, int new_row) +{ + ESelectionModel *esm = E_SELECTION_MODEL(esma); + gint selected = e_selection_model_is_row_selected(esm, old_row); + gint cursor = esma->cursor_row == old_row; + + e_selection_model_array_delete_row_real(esma, old_row); + e_selection_model_array_insert_row_real(esma, new_row); + + if (selected) { + if (esm->mode == GTK_SELECTION_SINGLE) + e_selection_model_select_single_row (esm, new_row); + else + e_selection_model_change_one_row(esm, new_row, TRUE); + } + if (cursor) { + esma->cursor_row = new_row; + } + e_selection_model_selection_changed(esm); + e_selection_model_cursor_changed(esm, esma->cursor_row, esma->cursor_col); +} + +static void +esma_destroy (GtkObject *object) +{ + ESelectionModelArray *esma; + + esma = E_SELECTION_MODEL_ARRAY (object); + + g_free(esma->selection); +} + +static void +esma_get_arg (GtkObject *o, GtkArg *arg, guint arg_id) +{ + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY (o); + + switch (arg_id){ + case ARG_CURSOR_ROW: + GTK_VALUE_INT(*arg) = esma->cursor_row; + break; + + case ARG_CURSOR_COL: + GTK_VALUE_INT(*arg) = esma->cursor_col; + break; + } +} + +static void +esma_set_arg (GtkObject *o, GtkArg *arg, guint arg_id) +{ + ESelectionModel *esm = E_SELECTION_MODEL (o); + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY (o); + + switch (arg_id){ + case ARG_CURSOR_ROW: + e_selection_model_do_something(esm, GTK_VALUE_INT(*arg), esma->cursor_col, 0); + break; + + case ARG_CURSOR_COL: + e_selection_model_do_something(esm, esma->cursor_row, GTK_VALUE_INT(*arg), 0); + break; + } +} + +/** + * e_selection_model_is_row_selected + * @selection: #ESelectionModel to check + * @n: The row to check + * + * This routine calculates whether the given row is selected. + * + * Returns: %TRUE if the given row is selected + */ +static gboolean +esma_is_row_selected (ESelectionModel *selection, + gint n) +{ + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + if (esma->row_count < n || esma->row_count == 0) + return 0; + else + return (esma->selection[BOX(n)] >> OFFSET(n)) & 0x1; +} + +/** + * e_selection_model_foreach + * @selection: #ESelectionModel to traverse + * @callback: The callback function to call back. + * @closure: The closure + * + * This routine calls the given callback function once for each + * selected row, passing closure as the closure. + */ +static void +esma_foreach (ESelectionModel *selection, + EForeachFunc callback, + gpointer closure) +{ + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + int i; + int last = (esma->row_count + 31) / 32; + for (i = 0; i < last; i++) { + if (esma->selection[i]) { + int j; + guint32 value = esma->selection[i]; + for (j = 0; j < 32; j++) { + if (value & 0x80000000) { + callback(i * 32 + j, closure); + } + value <<= 1; + } + } + } +} + +/** + * e_selection_model_clear + * @selection: #ESelectionModel to clear + * + * This routine clears the selection to no rows selected. + */ +static void +esma_clear(ESelectionModel *selection) +{ + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + g_free(esma->selection); + esma->selection = NULL; + esma->row_count = -1; + esma->cursor_row = -1; + esma->cursor_col = -1; + e_selection_model_selection_changed(E_SELECTION_MODEL(esma)); + e_selection_model_cursor_changed(E_SELECTION_MODEL(esma), -1, -1); +} + +#define PART(x,n) (((x) & (0x01010101 << n)) >> n) +#define SECTION(x, n) (((x) >> (n * 8)) & 0xff) + +/** + * e_selection_model_selected_count + * @selection: #ESelectionModel to count + * + * This routine calculates the number of rows selected. + * + * Returns: The number of rows selected in the given model. + */ +static gint +esma_selected_count (ESelectionModel *selection) +{ + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + gint count; + int i; + int last; + + if (!esma->selection) + return 0; + + count = 0; + + last = BOX(esma->row_count - 1); + + for (i = 0; i <= last; i++) { + int j; + guint32 thiscount = 0; + for (j = 0; j < 8; j++) + thiscount += PART(esma->selection[i], j); + for (j = 0; j < 4; j++) + count += SECTION(thiscount, j); + } + + return count; +} + +/** + * e_selection_model_select_all + * @selection: #ESelectionModel to select all + * + * This routine selects all the rows in the given + * #ESelectionModel. + */ +static void +esma_select_all (ESelectionModel *selection) +{ + int i; + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + + e_selection_model_array_confirm_row_count(esma); + + if (!esma->selection) + esma->selection = g_new0 (gint, (esma->row_count + 31) / 32); + + for (i = 0; i < (esma->row_count + 31) / 32; i ++) { + esma->selection[i] = ONES; + } + + /* need to zero out the bits corresponding to the rows not + selected in the last full 32 bit mask */ + if (esma->row_count % 32) { + int unselected_mask = 0; + int num_unselected_in_last_byte = 32 - esma->row_count % 32; + + for (i = 0; i < num_unselected_in_last_byte; i ++) + unselected_mask |= 1 << i; + + esma->selection[(esma->row_count + 31) / 32 - 1] &= ~unselected_mask; + } + + esma->cursor_col = 0; + esma->cursor_row = 0; + esma->selection_start_row = 0; + e_selection_model_selection_changed(E_SELECTION_MODEL(esma)); + e_selection_model_cursor_changed(E_SELECTION_MODEL(esma), 0, 0); +} + +/** + * e_selection_model_invert_selection + * @selection: #ESelectionModel to invert + * + * This routine inverts all the rows in the given + * #ESelectionModel. + */ +static void +esma_invert_selection (ESelectionModel *selection) +{ + int i; + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + + e_selection_model_array_confirm_row_count(esma); + + if (!esma->selection) + esma->selection = g_new0 (gint, (esma->row_count + 31) / 32); + + for (i = 0; i < (esma->row_count + 31) / 32; i ++) { + esma->selection[i] = ~esma->selection[i]; + } + + esma->cursor_col = -1; + esma->cursor_row = -1; + esma->selection_start_row = 0; + e_selection_model_selection_changed(E_SELECTION_MODEL(esma)); + e_selection_model_cursor_changed(E_SELECTION_MODEL(esma), -1, -1); +} + +static int +esma_row_count (ESelectionModel *selection) +{ + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + e_selection_model_array_confirm_row_count(esma); + return esma->row_count; +} + +#define OPERATE(object, i,mask,grow) ((grow) ? (((object)->selection[(i)]) |= ((guint32) ~(mask))) : (((object)->selection[(i)]) &= (mask))) + +static void +esma_change_one_row(ESelectionModel *selection, int row, gboolean grow) +{ + int i; + i = BOX(row); + + OPERATE(E_SELECTION_MODEL_ARRAY(selection), i, ~BITMASK(row), grow); +} + +static void +esma_change_cursor (ESelectionModel *selection, int row, int col) +{ + ESelectionModelArray *esma; + + g_return_if_fail(selection != NULL); + g_return_if_fail(E_IS_SELECTION_MODEL(selection)); + + esma = E_SELECTION_MODEL_ARRAY(selection); + + esma->cursor_row = row; + esma->cursor_col = col; +} + +static void +esma_change_range(ESelectionModel *selection, int start, int end, gboolean grow) +{ + int i, last; + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + if (start != end) { + if (selection->sorter && e_sorter_needs_sorting(selection->sorter)) { + for ( i = start; i < end; i++) { + e_selection_model_change_one_row(selection, e_sorter_sorted_to_model(selection->sorter, i), grow); + } + } else { + i = BOX(start); + last = BOX(end); + + if (i == last) { + OPERATE(esma, i, BITMASK_LEFT(start) | BITMASK_RIGHT(end), grow); + } else { + OPERATE(esma, i, BITMASK_LEFT(start), grow); + if (grow) + for (i ++; i < last; i++) + esma->selection[i] = ONES; + else + for (i ++; i < last; i++) + esma->selection[i] = 0; + OPERATE(esma, i, BITMASK_RIGHT(end), grow); + } + } + } +} + +static int +esma_cursor_row (ESelectionModel *selection) +{ + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + return esma->cursor_row; +} + +static int +esma_cursor_col (ESelectionModel *selection) +{ + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + return esma->cursor_col; +} + +static void +esma_select_single_row (ESelectionModel *selection, int row) +{ + int i; + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + for (i = 0; i < ((esma->row_count + 31) / 32); i++) { + if (!((i == BOX(row) && esma->selection[i] == BITMASK(row)) || + (i != BOX(row) && esma->selection[i] == 0))) { + g_free(esma->selection); + esma->selection = g_new0(gint, (esma->row_count + 31) / 32); + esma->selection[BOX(row)] = BITMASK(row); + + e_selection_model_selection_changed(E_SELECTION_MODEL(esma)); + break; + } + } + + esma->selection_start_row = row; +} + +static void +esma_toggle_single_row (ESelectionModel *selection, int row) +{ + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + if (esma->selection[BOX(row)] & BITMASK(row)) + esma->selection[BOX(row)] &= ~BITMASK(row); + else + esma->selection[BOX(row)] |= BITMASK(row); + esma->selection_start_row = row; + e_selection_model_selection_changed(E_SELECTION_MODEL(esma)); +} + +static void +esma_move_selection_end (ESelectionModel *selection, int row) +{ + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + int old_start; + int old_end; + int new_start; + int new_end; + if (selection->sorter && e_sorter_needs_sorting(selection->sorter)) { + old_start = MIN (e_sorter_model_to_sorted(selection->sorter, esma->selection_start_row), + e_sorter_model_to_sorted(selection->sorter, esma->cursor_row)); + old_end = MAX (e_sorter_model_to_sorted(selection->sorter, esma->selection_start_row), + e_sorter_model_to_sorted(selection->sorter, esma->cursor_row)) + 1; + new_start = MIN (e_sorter_model_to_sorted(selection->sorter, esma->selection_start_row), + e_sorter_model_to_sorted(selection->sorter, row)); + new_end = MAX (e_sorter_model_to_sorted(selection->sorter, esma->selection_start_row), + e_sorter_model_to_sorted(selection->sorter, row)) + 1; + } else { + old_start = MIN (esma->selection_start_row, esma->cursor_row); + old_end = MAX (esma->selection_start_row, esma->cursor_row) + 1; + new_start = MIN (esma->selection_start_row, row); + new_end = MAX (esma->selection_start_row, row) + 1; + } + /* This wouldn't work nearly so smoothly if one end of the selection weren't held in place. */ + if (old_start < new_start) + esma_change_range(selection, old_start, new_start, FALSE); + if (new_start < old_start) + esma_change_range(selection, new_start, old_start, TRUE); + if (old_end < new_end) + esma_change_range(selection, old_end, new_end, TRUE); + if (new_end < old_end) + esma_change_range(selection, new_end, old_end, FALSE); + e_selection_model_selection_changed(E_SELECTION_MODEL(esma)); +} + +static void +esma_set_selection_end (ESelectionModel *selection, int row) +{ + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(selection); + esma_select_single_row(selection, esma->selection_start_row); + esma->cursor_row = esma->selection_start_row; + e_selection_model_move_selection_end(selection, row); +} + +int +e_selection_model_array_get_row_count (ESelectionModelArray *esma) +{ + g_return_val_if_fail(esma != NULL, 0); + g_return_val_if_fail(E_IS_SELECTION_MODEL_ARRAY(esma), 0); + + if (ESMA_CLASS(esma)->get_row_count) + return ESMA_CLASS(esma)->get_row_count (esma); + else + return 0; +} + + +static void +e_selection_model_array_init (ESelectionModelArray *esma) +{ + esma->selection = NULL; + esma->row_count = -1; + esma->selection_start_row = 0; + esma->cursor_row = -1; + esma->cursor_col = -1; +} + +static void +e_selection_model_array_class_init (ESelectionModelArrayClass *klass) +{ + GtkObjectClass *object_class; + ESelectionModelClass *esm_class; + + parent_class = gtk_type_class (e_selection_model_get_type ()); + + object_class = GTK_OBJECT_CLASS(klass); + esm_class = E_SELECTION_MODEL_CLASS(klass); + + object_class->destroy = esma_destroy; + object_class->get_arg = esma_get_arg; + object_class->set_arg = esma_set_arg; + + esm_class->is_row_selected = esma_is_row_selected ; + esm_class->foreach = esma_foreach ; + esm_class->clear = esma_clear ; + esm_class->selected_count = esma_selected_count ; + esm_class->select_all = esma_select_all ; + esm_class->invert_selection = esma_invert_selection ; + esm_class->row_count = esma_row_count ; + + esm_class->change_one_row = esma_change_one_row ; + esm_class->change_cursor = esma_change_cursor ; + esm_class->cursor_row = esma_cursor_row ; + esm_class->cursor_col = esma_cursor_col ; + + esm_class->select_single_row = esma_select_single_row ; + esm_class->toggle_single_row = esma_toggle_single_row ; + esm_class->move_selection_end = esma_move_selection_end ; + esm_class->set_selection_end = esma_set_selection_end ; + + klass->get_row_count = NULL ; + + gtk_object_add_arg_type ("ESelectionModelArray::cursor_row", GTK_TYPE_INT, + GTK_ARG_READWRITE, ARG_CURSOR_ROW); + gtk_object_add_arg_type ("ESelectionModelArray::cursor_col", GTK_TYPE_INT, + GTK_ARG_READWRITE, ARG_CURSOR_COL); +} + +E_MAKE_TYPE(e_selection_model_array, "ESelectionModelArray", ESelectionModelArray, + e_selection_model_array_class_init, e_selection_model_array_init, PARENT_TYPE); diff --git a/widgets/misc/e-selection-model-array.h b/widgets/misc/e-selection-model-array.h new file mode 100644 index 0000000000..33250e347f --- /dev/null +++ b/widgets/misc/e-selection-model-array.h @@ -0,0 +1,66 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +#ifndef _E_SELECTION_MODEL_ARRAY_H_ +#define _E_SELECTION_MODEL_ARRAY_H_ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#define E_SELECTION_MODEL_ARRAY_TYPE (e_selection_model_array_get_type ()) +#define E_SELECTION_MODEL_ARRAY(o) (GTK_CHECK_CAST ((o), E_SELECTION_MODEL_ARRAY_TYPE, ESelectionModelArray)) +#define E_SELECTION_MODEL_ARRAY_CLASS(k) (GTK_CHECK_CLASS_CAST((k), E_SELECTION_MODEL_ARRAY_TYPE, ESelectionModelArrayClass)) +#define E_IS_SELECTION_MODEL_ARRAY(o) (GTK_CHECK_TYPE ((o), E_SELECTION_MODEL_ARRAY_TYPE)) +#define E_IS_SELECTION_MODEL_ARRAY_CLASS(k) (GTK_CHECK_CLASS_TYPE ((k), E_SELECTION_MODEL_ARRAY_TYPE)) + +typedef struct { + ESelectionModel base; + + gint row_count; + guint32 *selection; + + gint cursor_row; + gint cursor_col; + gint selection_start_row; + + guint model_changed_id; + guint model_row_inserted_id, model_row_deleted_id; + + guint frozen : 1; + guint selection_model_changed : 1; + guint group_info_changed : 1; +} ESelectionModelArray; + +typedef struct { + ESelectionModelClass parent_class; + + gint (*get_row_count) (ESelectionModelArray *selection); +} ESelectionModelArrayClass; + +GtkType e_selection_model_array_get_type (void); + +/* Protected Functions */ +void e_selection_model_array_insert_rows (ESelectionModelArray *esm, + int row, + int count); +void e_selection_model_array_delete_rows (ESelectionModelArray *esm, + int row, + int count); +void e_selection_model_array_move_row (ESelectionModelArray *esm, + int old_row, + int new_row); +void e_selection_model_array_confirm_row_count (ESelectionModelArray *esm); + +/* Protected Virtual Function */ +gint e_selection_model_array_get_row_count (ESelectionModelArray *esm); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +#endif /* _E_SELECTION_MODEL_ARRAY_H_ */ diff --git a/widgets/misc/e-selection-model-simple.c b/widgets/misc/e-selection-model-simple.c index 8b8329b7bb..bb20aafaf6 100644 --- a/widgets/misc/e-selection-model-simple.c +++ b/widgets/misc/e-selection-model-simple.c @@ -9,15 +9,16 @@ */ #include #include +#include "e-selection-model-array.h" #include "e-selection-model-simple.h" #define ESMS_CLASS(e) ((ESelectionModelSimpleClass *)((GtkObject *)e)->klass) -#define PARENT_TYPE e_selection_model_get_type () +#define PARENT_TYPE e_selection_model_array_get_type () -static ESelectionModel *parent_class; +static ESelectionModelArray *parent_class; -static gint esms_get_row_count (ESelectionModel *esm); +static gint esms_get_row_count (ESelectionModelArray *esma); static void e_selection_model_simple_init (ESelectionModelSimple *selection) @@ -28,13 +29,13 @@ e_selection_model_simple_init (ESelectionModelSimple *selection) static void e_selection_model_simple_class_init (ESelectionModelSimpleClass *klass) { - ESelectionModelClass *esm_class; + ESelectionModelArrayClass *esma_class; parent_class = gtk_type_class (PARENT_TYPE); - esm_class = E_SELECTION_MODEL_CLASS(klass); + esma_class = E_SELECTION_MODEL_ARRAY_CLASS(klass); - esm_class->get_row_count = esms_get_row_count; + esma_class->get_row_count = esms_get_row_count; } E_MAKE_TYPE(e_selection_model_simple, "ESelectionModelSimple", ESelectionModelSimple, @@ -58,18 +59,18 @@ e_selection_model_simple_set_row_count (ESelectionModelSimple *esms, int row_count) { if (esms->row_count != row_count) { - ESelectionModel *esm = E_SELECTION_MODEL(esms); - g_free(esm->selection); - esm->selection = NULL; - esm->row_count = -1; + ESelectionModelArray *esma = E_SELECTION_MODEL_ARRAY(esms); + g_free(esma->selection); + esma->selection = NULL; + esma->row_count = -1; } esms->row_count = row_count; } static gint -esms_get_row_count (ESelectionModel *esm) +esms_get_row_count (ESelectionModelArray *esma) { - ESelectionModelSimple *esms = E_SELECTION_MODEL_SIMPLE(esm); + ESelectionModelSimple *esms = E_SELECTION_MODEL_SIMPLE(esma); return esms->row_count; } @@ -79,7 +80,7 @@ void e_selection_model_simple_insert_rows (ESelectionModelSimple *e int count) { esms->row_count += count; - e_selection_model_insert_rows (E_SELECTION_MODEL(esms), row, count); + e_selection_model_array_insert_rows (E_SELECTION_MODEL_ARRAY(esms), row, count); } void @@ -88,7 +89,7 @@ e_selection_model_simple_delete_rows (ESelectionModelSimple *esms, int count) { esms->row_count -= count; - e_selection_model_delete_rows (E_SELECTION_MODEL(esms), row, count); + e_selection_model_array_delete_rows (E_SELECTION_MODEL_ARRAY(esms), row, count); } void @@ -96,5 +97,5 @@ e_selection_model_simple_move_row (ESelectionModelSimple *esms, int old_row, int new_row) { - e_selection_model_move_row (E_SELECTION_MODEL(esms), old_row, new_row); + e_selection_model_array_move_row (E_SELECTION_MODEL_ARRAY(esms), old_row, new_row); } diff --git a/widgets/misc/e-selection-model-simple.h b/widgets/misc/e-selection-model-simple.h index 65d69d0143..1fe312e4b4 100644 --- a/widgets/misc/e-selection-model-simple.h +++ b/widgets/misc/e-selection-model-simple.h @@ -2,7 +2,7 @@ #ifndef _E_SELECTION_MODEL_SIMPLE_H_ #define _E_SELECTION_MODEL_SIMPLE_H_ -#include +#include #ifdef __cplusplus extern "C" { @@ -15,13 +15,13 @@ extern "C" { #define E_IS_SELECTION_MODEL_SIMPLE_CLASS(k) (GTK_CHECK_CLASS_TYPE ((k), E_SELECTION_MODEL_SIMPLE_TYPE)) typedef struct { - ESelectionModel parent; + ESelectionModelArray parent; int row_count; } ESelectionModelSimple; typedef struct { - ESelectionModelClass parent_class; + ESelectionModelArrayClass parent_class; } ESelectionModelSimpleClass; GtkType e_selection_model_simple_get_type (void); diff --git a/widgets/misc/e-selection-model.c b/widgets/misc/e-selection-model.c index c52397ca37..49b42f1b19 100644 --- a/widgets/misc/e-selection-model.c +++ b/widgets/misc/e-selection-model.c @@ -17,18 +17,8 @@ #define PARENT_TYPE gtk_object_get_type () -#define ONES ((guint32) 0xffffffff) - -#define BOX(n) ((n) / 32) -#define OFFSET(n) (31 - ((n) % 32)) -#define BITMASK(n) ((guint32)(((guint32) 0x1) << OFFSET((n)))) -#define BITMASK_LEFT(n) ((((n) % 32) == 0) ? 0 : (ONES << (32 - ((n) % 32)))) -#define BITMASK_RIGHT(n) ((guint32)(((guint32) ONES) >> ((n) % 32))) - static GtkObjectClass *e_selection_model_parent_class; -static void esm_select_single_row (ESelectionModel *selection, int row); - enum { CURSOR_CHANGED, CURSOR_ACTIVATED, @@ -41,144 +31,10 @@ static guint e_selection_model_signals [LAST_SIGNAL] = { 0, }; enum { ARG_0, ARG_SORTER, - ARG_CURSOR_ROW, - ARG_CURSOR_COL, ARG_SELECTION_MODE, ARG_CURSOR_MODE, }; -gboolean -e_selection_model_confirm_row_count(ESelectionModel *esm) -{ - if (esm->row_count < 0) { - esm->row_count = e_selection_model_get_row_count(esm); - if (esm->row_count < 0) - return FALSE; - g_free(esm->selection); - esm->selection = g_new0(gint, (esm->row_count + 31) / 32); - } - return TRUE; -} - -static void -e_selection_model_insert_row_real(ESelectionModel *esm, int row) -{ - int box; - int i; - if(esm->row_count >= 0) { - /* Add another word if needed. */ - if ((esm->row_count & 0x1f) == 0) { - esm->selection = g_renew(gint, esm->selection, (esm->row_count >> 5) + 1); - esm->selection[esm->row_count >> 5] = 0; - } - - /* The box is the word that our row is in. */ - box = BOX(row); - /* Shift all words to the right of our box right one bit. */ - for (i = esm->row_count >> 5; i > box; i--) { - esm->selection[i] = (esm->selection[i] >> 1) | (esm->selection[i - 1] << 31); - } - - /* Shift right half of box one bit to the right. */ - esm->selection[box] = (esm->selection[box] & BITMASK_LEFT(row)) | ((esm->selection[box] & BITMASK_RIGHT(row)) >> 1); - esm->row_count ++; - } - if (esm->cursor_row >= row) - esm->cursor_row ++; -} - -static void -e_selection_model_delete_row_real(ESelectionModel *esm, int row) -{ - int box; - int i; - int last; - int selected = FALSE; - if(esm->row_count >= 0) { - guint32 bitmask; - box = row >> 5; - last = esm->row_count >> 5; - - /* Build bitmasks for the left and right half of the box */ - bitmask = BITMASK_RIGHT(row) >> 1; - selected = e_selection_model_is_row_selected(esm, row); - /* Shift right half of box one bit to the left. */ - esm->selection[box] = (esm->selection[box] & BITMASK_LEFT(row))| ((esm->selection[box] & bitmask) << 1); - - /* Shift all words to the right of our box left one bit. */ - if (box < last) { - esm->selection[box] &= esm->selection[box + 1] >> 31; - - for (i = box + 1; i < last; i++) { - esm->selection[i] = (esm->selection[i] << 1) | (esm->selection[i + 1] >> 31); - } - /* this over-runs our memory! */ - /*esm->selection[i] = esm->selection[i] << 1; */ - } - esm->row_count --; - /* Remove the last word if not needed. */ - if ((esm->row_count & 0x1f) == 0) { - esm->selection = g_renew(gint, esm->selection, esm->row_count >> 5); - } - if (selected && esm->mode == GTK_SELECTION_SINGLE) { - esm_select_single_row (esm, row > 0 ? row - 1 : 0); - } - } - if (esm->cursor_row >= row && esm->cursor_row > 0) - esm->cursor_row --; -} - -/* FIXME : Improve efficiency here. */ -void -e_selection_model_delete_rows(ESelectionModel *esm, int row, int count) -{ - int i; - for (i = 0; i < count; i++) - e_selection_model_delete_row_real(esm, row); - gtk_signal_emit(GTK_OBJECT(esm), - e_selection_model_signals [SELECTION_CHANGED]); - gtk_signal_emit(GTK_OBJECT(esm), - e_selection_model_signals [CURSOR_CHANGED], esm->cursor_row, esm->cursor_col); -} - -/* FIXME : Improve efficiency here. */ -void -e_selection_model_insert_rows(ESelectionModel *esm, int row, int count) -{ - int i; - for (i = 0; i < count; i++) - e_selection_model_insert_row_real(esm, row); - gtk_signal_emit(GTK_OBJECT(esm), - e_selection_model_signals [SELECTION_CHANGED]); - gtk_signal_emit(GTK_OBJECT(esm), - e_selection_model_signals [CURSOR_CHANGED], esm->cursor_row, esm->cursor_col); -} - -/* FIXME: Implement this more efficiently. */ -void -e_selection_model_move_row(ESelectionModel *esm, int old_row, int new_row) -{ - gint selected = e_selection_model_is_row_selected(esm, old_row); - gint cursor = esm->cursor_row == old_row; - - e_selection_model_delete_row_real(esm, old_row); - e_selection_model_insert_row_real(esm, new_row); - - if (selected) { - if (esm->mode == GTK_SELECTION_SINGLE) - esm_select_single_row (esm, new_row); - else - e_selection_model_change_one_row(esm, new_row, TRUE); - } - if (cursor) { - esm->cursor_row = new_row; - } - gtk_signal_emit(GTK_OBJECT(esm), - e_selection_model_signals [SELECTION_CHANGED]); - gtk_signal_emit(GTK_OBJECT(esm), - e_selection_model_signals [CURSOR_CHANGED], esm->cursor_row, esm->cursor_col); -} - inline static void add_sorter(ESelectionModel *esm, ESorter *sorter) { @@ -205,8 +61,6 @@ esm_destroy (GtkObject *object) esm = E_SELECTION_MODEL (object); drop_sorter(esm); - - g_free(esm->selection); } static void @@ -219,14 +73,6 @@ esm_get_arg (GtkObject *o, GtkArg *arg, guint arg_id) GTK_VALUE_OBJECT (*arg) = GTK_OBJECT(esm->sorter); break; - case ARG_CURSOR_ROW: - GTK_VALUE_INT(*arg) = esm->cursor_row; - break; - - case ARG_CURSOR_COL: - GTK_VALUE_INT(*arg) = esm->cursor_col; - break; - case ARG_SELECTION_MODE: GTK_VALUE_ENUM(*arg) = esm->mode; break; @@ -248,18 +94,12 @@ esm_set_arg (GtkObject *o, GtkArg *arg, guint arg_id) add_sorter(esm, GTK_VALUE_OBJECT (*arg) ? E_SORTER(GTK_VALUE_OBJECT (*arg)) : NULL); break; - case ARG_CURSOR_ROW: - e_selection_model_do_something(esm, GTK_VALUE_INT(*arg), esm->cursor_col, 0); - break; - - case ARG_CURSOR_COL: - e_selection_model_do_something(esm, esm->cursor_row, GTK_VALUE_INT(*arg), 0); - break; - case ARG_SELECTION_MODE: esm->mode = GTK_VALUE_ENUM(*arg); if (esm->mode == GTK_SELECTION_SINGLE) { - e_selection_model_do_something(esm, esm->cursor_row, esm->cursor_col, 0); + int cursor_row = e_selection_model_cursor_row(esm); + int cursor_col = e_selection_model_cursor_col(esm); + e_selection_model_do_something(esm, cursor_row, cursor_col, 0); } break; @@ -272,11 +112,6 @@ esm_set_arg (GtkObject *o, GtkArg *arg, guint arg_id) static void e_selection_model_init (ESelectionModel *selection) { - selection->selection = NULL; - selection->row_count = -1; - selection->selection_start_row = 0; - selection->cursor_row = -1; - selection->cursor_col = -1; selection->mode = GTK_SELECTION_MULTIPLE; selection->cursor_mode = E_CURSOR_SIMPLE; } @@ -318,18 +153,33 @@ e_selection_model_class_init (ESelectionModelClass *klass) gtk_marshal_NONE__NONE, GTK_TYPE_NONE, 0); - klass->cursor_changed = NULL; - klass->cursor_activated = NULL; - klass->selection_changed = NULL; + klass->cursor_changed = NULL; + klass->cursor_activated = NULL; + klass->selection_changed = NULL; + + klass->is_row_selected = NULL; + klass->foreach = NULL; + klass->clear = NULL; + klass->selected_count = NULL; + klass->select_all = NULL; + klass->invert_selection = NULL; + klass->row_count = NULL; + + klass->change_one_row = NULL; + klass->change_cursor = NULL; + klass->cursor_row = NULL; + klass->cursor_col = NULL; + + klass->select_single_row = NULL; + klass->toggle_single_row = NULL; + klass->move_selection_end = NULL; + klass->set_selection_end = NULL; + gtk_object_class_add_signals (object_class, e_selection_model_signals, LAST_SIGNAL); gtk_object_add_arg_type ("ESelectionModel::sorter", GTK_TYPE_OBJECT, GTK_ARG_READWRITE, ARG_SORTER); - gtk_object_add_arg_type ("ESelectionModel::cursor_row", GTK_TYPE_INT, - GTK_ARG_READWRITE, ARG_CURSOR_ROW); - gtk_object_add_arg_type ("ESelectionModel::cursor_col", GTK_TYPE_INT, - GTK_ARG_READWRITE, ARG_CURSOR_COL); gtk_object_add_arg_type ("ESelectionModel::selection_mode", GTK_TYPE_ENUM, GTK_ARG_READWRITE, ARG_SELECTION_MODE); gtk_object_add_arg_type ("ESelectionModel::cursor_mode", GTK_TYPE_ENUM, @@ -352,10 +202,10 @@ gboolean e_selection_model_is_row_selected (ESelectionModel *selection, gint n) { - if (selection->row_count < n || selection->row_count == 0) - return 0; + if (ESM_CLASS(selection)->is_row_selected) + return ESM_CLASS(selection)->is_row_selected (selection, n); else - return (selection->selection[BOX(n)] >> OFFSET(n)) & 0x1; + return FALSE; } /** @@ -372,135 +222,135 @@ e_selection_model_foreach (ESelectionModel *selection, EForeachFunc callback, gpointer closure) { - int i; - int last = (selection->row_count + 31) / 32; - for (i = 0; i < last; i++) { - if (selection->selection[i]) { - int j; - guint32 value = selection->selection[i]; - for (j = 0; j < 32; j++) { - if (value & 0x80000000) { - callback(i * 32 + j, closure); - } - value <<= 1; - } - } - } + if (ESM_CLASS(selection)->foreach) + ESM_CLASS(selection)->foreach (selection, callback, closure); } -#define OPERATE(object, i,mask,grow) ((grow) ? (((object)->selection[(i)]) |= ((guint32) ~(mask))) : (((object)->selection[(i)]) &= (mask))) - +/** + * e_selection_model_clear + * @selection: #ESelectionModel to clear + * + * This routine clears the selection to no rows selected. + */ void -e_selection_model_change_one_row(ESelectionModel *selection, int row, gboolean grow) +e_selection_model_clear(ESelectionModel *selection) { - int i; - i = BOX(row); + if (ESM_CLASS(selection)->clear) + ESM_CLASS(selection)->clear (selection); +} - OPERATE(selection, i, ~BITMASK(row), grow); +/** + * e_selection_model_selected_count + * @selection: #ESelectionModel to count + * + * This routine calculates the number of rows selected. + * + * Returns: The number of rows selected in the given model. + */ +gint +e_selection_model_selected_count (ESelectionModel *selection) +{ + if (ESM_CLASS(selection)->selected_count) + return ESM_CLASS(selection)->selected_count (selection); + else + return 0; } -static void -change_selection(ESelectionModel *selection, int start, int end, gboolean grow) +/** + * e_selection_model_select_all + * @selection: #ESelectionModel to select all + * + * This routine selects all the rows in the given + * #ESelectionModel. + */ +void +e_selection_model_select_all (ESelectionModel *selection) { - int i, last; - if (start != end) { - if (selection->sorter && e_sorter_needs_sorting(selection->sorter)) { - for ( i = start; i < end; i++) { - e_selection_model_change_one_row(selection, e_sorter_sorted_to_model(selection->sorter, i), grow); - } - } else { - i = BOX(start); - last = BOX(end); + if (ESM_CLASS(selection)->select_all) + ESM_CLASS(selection)->select_all (selection); +} - if (i == last) { - OPERATE(selection, i, BITMASK_LEFT(start) | BITMASK_RIGHT(end), grow); - } else { - OPERATE(selection, i, BITMASK_LEFT(start), grow); - if (grow) - for (i ++; i < last; i++) - selection->selection[i] = ONES; - else - for (i ++; i < last; i++) - selection->selection[i] = 0; - OPERATE(selection, i, BITMASK_RIGHT(end), grow); - } - } - } +/** + * e_selection_model_invert_selection + * @selection: #ESelectionModel to invert + * + * This routine inverts all the rows in the given + * #ESelectionModel. + */ +void +e_selection_model_invert_selection (ESelectionModel *selection) +{ + if (ESM_CLASS(selection)->invert_selection) + ESM_CLASS(selection)->invert_selection (selection); } -static void -esm_select_single_row (ESelectionModel *selection, int row) +int +e_selection_model_row_count (ESelectionModel *selection) +{ + if (ESM_CLASS(selection)->row_count) + return ESM_CLASS(selection)->row_count (selection); + else + return 0; +} + +void +e_selection_model_change_one_row(ESelectionModel *selection, int row, gboolean grow) { - int i; - for (i = 0; i < ((selection->row_count + 31) / 32); i++) { - if (!((i == BOX(row) && selection->selection[i] == BITMASK(row)) || - (i != BOX(row) && selection->selection[i] == 0))) { - g_free(selection->selection); - selection->selection = g_new0(gint, (selection->row_count + 31) / 32); - selection->selection[BOX(row)] = BITMASK(row); + if (ESM_CLASS(selection)->change_one_row) + ESM_CLASS(selection)->change_one_row (selection, row, grow); +} - gtk_signal_emit(GTK_OBJECT(selection), - e_selection_model_signals [SELECTION_CHANGED]); - break; - } - } +void +e_selection_model_change_cursor (ESelectionModel *selection, int row, int col) +{ + if (ESM_CLASS(selection)->change_cursor) + ESM_CLASS(selection)->change_cursor (selection, row, col); +} - selection->selection_start_row = row; +int +e_selection_model_cursor_row (ESelectionModel *selection) +{ + if (ESM_CLASS(selection)->cursor_row) + return ESM_CLASS(selection)->cursor_row (selection); + else + return -1; } -static void -esm_toggle_single_row (ESelectionModel *selection, int row) +int +e_selection_model_cursor_col (ESelectionModel *selection) { - if (selection->selection[BOX(row)] & BITMASK(row)) - selection->selection[BOX(row)] &= ~BITMASK(row); + if (ESM_CLASS(selection)->cursor_col) + return ESM_CLASS(selection)->cursor_col (selection); else - selection->selection[BOX(row)] |= BITMASK(row); - selection->selection_start_row = row; - gtk_signal_emit(GTK_OBJECT(selection), - e_selection_model_signals [SELECTION_CHANGED]); + return -1; } -static void -esm_move_selection_end (ESelectionModel *selection, int row) +void +e_selection_model_select_single_row (ESelectionModel *selection, int row) { - int old_start; - int old_end; - int new_start; - int new_end; - if (selection->sorter && e_sorter_needs_sorting(selection->sorter)) { - old_start = MIN (e_sorter_model_to_sorted(selection->sorter, selection->selection_start_row), - e_sorter_model_to_sorted(selection->sorter, selection->cursor_row)); - old_end = MAX (e_sorter_model_to_sorted(selection->sorter, selection->selection_start_row), - e_sorter_model_to_sorted(selection->sorter, selection->cursor_row)) + 1; - new_start = MIN (e_sorter_model_to_sorted(selection->sorter, selection->selection_start_row), - e_sorter_model_to_sorted(selection->sorter, row)); - new_end = MAX (e_sorter_model_to_sorted(selection->sorter, selection->selection_start_row), - e_sorter_model_to_sorted(selection->sorter, row)) + 1; - } else { - old_start = MIN (selection->selection_start_row, selection->cursor_row); - old_end = MAX (selection->selection_start_row, selection->cursor_row) + 1; - new_start = MIN (selection->selection_start_row, row); - new_end = MAX (selection->selection_start_row, row) + 1; - } - /* This wouldn't work nearly so smoothly if one end of the selection weren't held in place. */ - if (old_start < new_start) - change_selection(selection, old_start, new_start, FALSE); - if (new_start < old_start) - change_selection(selection, new_start, old_start, TRUE); - if (old_end < new_end) - change_selection(selection, old_end, new_end, TRUE); - if (new_end < old_end) - change_selection(selection, new_end, old_end, FALSE); - gtk_signal_emit(GTK_OBJECT(selection), - e_selection_model_signals [SELECTION_CHANGED]); + if (ESM_CLASS(selection)->select_single_row) + ESM_CLASS(selection)->select_single_row (selection, row); } -static void -esm_set_selection_end (ESelectionModel *selection, int row) +void +e_selection_model_toggle_single_row (ESelectionModel *selection, int row) { - esm_select_single_row(selection, selection->selection_start_row); - selection->cursor_row = selection->selection_start_row; - esm_move_selection_end(selection, row); + if (ESM_CLASS(selection)->toggle_single_row) + ESM_CLASS(selection)->toggle_single_row (selection, row); +} + +void +e_selection_model_move_selection_end (ESelectionModel *selection, int row) +{ + if (ESM_CLASS(selection)->move_selection_end) + ESM_CLASS(selection)->move_selection_end (selection, row); +} + +void +e_selection_model_set_selection_end (ESelectionModel *selection, int row) +{ + if (ESM_CLASS(selection)->set_selection_end) + ESM_CLASS(selection)->set_selection_end (selection, row); } /** @@ -521,37 +371,36 @@ e_selection_model_do_something (ESelectionModel *selection, { gint shift_p = state & GDK_SHIFT_MASK; gint ctrl_p = state & GDK_CONTROL_MASK; + int row_count; if (row == -1 && col != -1) row = 0; if (col == -1 && row != -1) col = 0; - if (!e_selection_model_confirm_row_count(selection)) - return; - if (selection->row_count >= 0 && row < selection->row_count) { + row_count = e_selection_model_row_count(selection); + if (row_count >= 0 && row < row_count) { switch (selection->mode) { case GTK_SELECTION_SINGLE: - esm_select_single_row (selection, row); + e_selection_model_select_single_row (selection, row); break; case GTK_SELECTION_BROWSE: case GTK_SELECTION_MULTIPLE: case GTK_SELECTION_EXTENDED: if (shift_p) { - esm_set_selection_end (selection, row); + e_selection_model_set_selection_end (selection, row); } else { if (ctrl_p) { - esm_toggle_single_row (selection, row); + e_selection_model_toggle_single_row (selection, row); } else { - esm_select_single_row (selection, row); + e_selection_model_select_single_row (selection, row); } } break; } - if (selection->cursor_row != row || - selection->cursor_col != col) { - selection->cursor_row = row; - selection->cursor_col = col; + if (e_selection_model_cursor_row(selection) != row || + e_selection_model_cursor_col(selection) != col) { + e_selection_model_change_cursor(selection, row, col); gtk_signal_emit(GTK_OBJECT(selection), e_selection_model_signals[CURSOR_CHANGED], row, col); gtk_signal_emit(GTK_OBJECT(selection), @@ -575,13 +424,14 @@ e_selection_model_do_something (ESelectionModel *selection, */ void e_selection_model_maybe_do_something (ESelectionModel *selection, - guint row, - guint col, - GdkModifierType state) + guint row, + guint col, + GdkModifierType state) { if (e_selection_model_is_row_selected(selection, row)) { - selection->cursor_row = row; - selection->cursor_col = col; + e_selection_model_change_cursor(selection, row, col); + gtk_signal_emit(GTK_OBJECT(selection), + e_selection_model_signals[CURSOR_CHANGED], row, col); } else { e_selection_model_do_something(selection, row, col, state); } @@ -592,9 +442,10 @@ move_selection (ESelectionModel *selection, gboolean up, GdkModifierType state) { - int row = selection->cursor_row; - int col = selection->cursor_col; + int row = e_selection_model_cursor_row(selection); + int col = e_selection_model_cursor_col(selection); int cursor_activated = TRUE; + int row_count; gint shift_p = state & GDK_SHIFT_MASK; gint ctrl_p = state & GDK_CONTROL_MASK; @@ -606,27 +457,28 @@ move_selection (ESelectionModel *selection, row++; if (row < 0) row = 0; - if (row >= selection->row_count) - row = selection->row_count - 1; + row_count = e_selection_model_row_count(selection); + if (row >= row_count) + row = row_count - 1; row = e_sorter_sorted_to_model(selection->sorter, row); switch (selection->mode) { case GTK_SELECTION_BROWSE: if (shift_p) { - esm_set_selection_end (selection, row); + e_selection_model_set_selection_end (selection, row); } else if (!ctrl_p) { - esm_select_single_row (selection, row); + e_selection_model_select_single_row (selection, row); } else cursor_activated = FALSE; break; case GTK_SELECTION_SINGLE: case GTK_SELECTION_MULTIPLE: case GTK_SELECTION_EXTENDED: - esm_select_single_row (selection, row); + e_selection_model_select_single_row (selection, row); break; } if (row != -1) { - selection->cursor_row = row; + e_selection_model_change_cursor(selection, row, col); gtk_signal_emit(GTK_OBJECT(selection), e_selection_model_signals[CURSOR_CHANGED], row, col); if (cursor_activated) @@ -660,18 +512,22 @@ e_selection_model_key_press (ESelectionModel *selection, case GDK_space: case GDK_KP_Space: if (selection->mode != GTK_SELECTION_SINGLE) { - esm_toggle_single_row (selection, selection->cursor_row); + int row = e_selection_model_cursor_row(selection); + int col = e_selection_model_cursor_col(selection); + e_selection_model_toggle_single_row (selection, row); gtk_signal_emit(GTK_OBJECT(selection), - e_selection_model_signals[CURSOR_ACTIVATED], selection->cursor_row, selection->cursor_col); + e_selection_model_signals[CURSOR_ACTIVATED], row, col); return TRUE; } break; case GDK_Return: case GDK_KP_Enter: if (selection->mode != GTK_SELECTION_SINGLE) { - esm_select_single_row (selection, selection->cursor_row); + int row = e_selection_model_cursor_row(selection); + int col = e_selection_model_cursor_col(selection); + e_selection_model_select_single_row (selection, row); gtk_signal_emit(GTK_OBJECT(selection), - e_selection_model_signals[CURSOR_ACTIVATED], selection->cursor_row, selection->cursor_col); + e_selection_model_signals[CURSOR_ACTIVATED], row, col); return TRUE; } break; @@ -679,31 +535,33 @@ e_selection_model_key_press (ESelectionModel *selection, case GDK_KP_Home: if (selection->cursor_mode == E_CURSOR_LINE) { int row = 0; + int cursor_col = e_selection_model_cursor_col(selection); row = e_sorter_sorted_to_model(selection->sorter, row); - selection->cursor_row = row; + e_selection_model_change_cursor(selection, row, cursor_col); - esm_select_single_row (selection, selection->cursor_row); + e_selection_model_select_single_row (selection, row); gtk_signal_emit(GTK_OBJECT(selection), - e_selection_model_signals[CURSOR_CHANGED], selection->cursor_row, selection->cursor_col); + e_selection_model_signals[CURSOR_CHANGED], row, cursor_col); gtk_signal_emit(GTK_OBJECT(selection), - e_selection_model_signals[CURSOR_ACTIVATED], selection->cursor_row, selection->cursor_col); + e_selection_model_signals[CURSOR_ACTIVATED], row, cursor_col); return TRUE; } break; case GDK_End: case GDK_KP_End: if (selection->cursor_mode == E_CURSOR_LINE) { - int row = selection->row_count - 1; + int row = e_selection_model_row_count(selection) - 1; + int cursor_col = e_selection_model_cursor_col(selection); row = e_sorter_sorted_to_model(selection->sorter, row); - selection->cursor_row = row; + e_selection_model_change_cursor(selection, row, cursor_col); - esm_select_single_row (selection, selection->cursor_row); + e_selection_model_select_single_row (selection, row); gtk_signal_emit(GTK_OBJECT(selection), - e_selection_model_signals[CURSOR_CHANGED], selection->cursor_row, selection->cursor_col); + e_selection_model_signals[CURSOR_CHANGED], row, cursor_col); gtk_signal_emit(GTK_OBJECT(selection), - e_selection_model_signals[CURSOR_ACTIVATED], selection->cursor_row, selection->cursor_col); + e_selection_model_signals[CURSOR_ACTIVATED], row, cursor_col); return TRUE; } break; @@ -711,160 +569,18 @@ e_selection_model_key_press (ESelectionModel *selection, return FALSE; } -/** - * e_selection_model_clear - * @selection: #ESelectionModel to clear - * - * This routine clears the selection to no rows selected. - */ void -e_selection_model_clear(ESelectionModel *selection) +e_selection_model_cursor_changed (ESelectionModel *selection, + int row, + int col) { - g_free(selection->selection); - selection->selection = NULL; - selection->row_count = -1; - selection->cursor_row = -1; - selection->cursor_col = -1; - gtk_signal_emit(GTK_OBJECT(selection), - e_selection_model_signals [CURSOR_CHANGED], -1, -1); gtk_signal_emit(GTK_OBJECT(selection), - e_selection_model_signals [SELECTION_CHANGED]); -} - -#define PART(x,n) (((x) & (0x01010101 << n)) >> n) -#define SECTION(x, n) (((x) >> (n * 8)) & 0xff) - -/** - * e_selection_model_selected_count - * @selection: #ESelectionModel to count - * - * This routine calculates the number of rows selected. - * - * Returns: The number of rows selected in the given model. - */ -gint -e_selection_model_selected_count (ESelectionModel *selection) -{ - gint count; - int i; - int last; - - if (!selection->selection) - return 0; - - count = 0; - - last = BOX(selection->row_count - 1); - - for (i = 0; i <= last; i++) { - int j; - guint32 thiscount = 0; - for (j = 0; j < 8; j++) - thiscount += PART(selection->selection[i], j); - for (j = 0; j < 4; j++) - count += SECTION(thiscount, j); - } - - return count; -} - -/** - * e_selection_model_select_all - * @selection: #ESelectionModel to select all - * - * This routine selects all the rows in the given - * #ESelectionModel. - */ -void -e_selection_model_select_all (ESelectionModel *selection) -{ - int i; - - if (!e_selection_model_confirm_row_count(selection)) - return; - - if (!selection->selection) - selection->selection = g_new0 (gint, (selection->row_count + 31) / 32); - - for (i = 0; i < (selection->row_count + 31) / 32; i ++) { - selection->selection[i] = ONES; - } - - /* need to zero out the bits corresponding to the rows not - selected in the last full 32 bit mask */ - if (selection->row_count % 32) { - int unselected_mask = 0; - int num_unselected_in_last_byte = 32 - selection->row_count % 32; - - for (i = 0; i < num_unselected_in_last_byte; i ++) - unselected_mask |= 1 << i; - - selection->selection[(selection->row_count + 31) / 32 - 1] &= ~unselected_mask; - } - - selection->cursor_col = 0; - selection->cursor_row = 0; - selection->selection_start_row = 0; - gtk_signal_emit (GTK_OBJECT (selection), - e_selection_model_signals [CURSOR_CHANGED], 0, 0); - gtk_signal_emit (GTK_OBJECT (selection), - e_selection_model_signals [SELECTION_CHANGED]); -} - -/** - * e_selection_model_invert_selection - * @selection: #ESelectionModel to invert - * - * This routine inverts all the rows in the given - * #ESelectionModel. - */ -void -e_selection_model_invert_selection (ESelectionModel *selection) -{ - int i; - - if (!e_selection_model_confirm_row_count(selection)) - return; - - if (!selection->selection) - selection->selection = g_new0 (gint, (selection->row_count + 31) / 32); - - for (i = 0; i < (selection->row_count + 31) / 32; i ++) { - selection->selection[i] = ~selection->selection[i]; - } - - selection->cursor_col = -1; - selection->cursor_row = -1; - selection->selection_start_row = 0; - gtk_signal_emit (GTK_OBJECT (selection), - e_selection_model_signals [CURSOR_CHANGED], -1, -1); - gtk_signal_emit (GTK_OBJECT (selection), - e_selection_model_signals [SELECTION_CHANGED]); -} - -int -e_selection_model_get_row_count (ESelectionModel *selection) -{ - g_return_val_if_fail(selection != NULL, 0); - g_return_val_if_fail(E_IS_SELECTION_MODEL(selection), 0); - - if (ESM_CLASS(selection)->get_row_count) - return ESM_CLASS(selection)->get_row_count (selection); - else - return 0; + e_selection_model_signals[CURSOR_CHANGED], row, col); } void -e_selection_model_change_cursor (ESelectionModel *selection, int row) +e_selection_model_selection_changed (ESelectionModel *selection) { - g_return_if_fail(selection != NULL); - g_return_if_fail(E_IS_SELECTION_MODEL(selection)); - - selection->cursor_row = row; - if (row == -1) - selection->cursor_col = -1; - else if (selection->cursor_col == -1) - selection->cursor_col = 0; gtk_signal_emit(GTK_OBJECT(selection), - e_selection_model_signals[CURSOR_CHANGED], selection->cursor_row, selection->cursor_col); + e_selection_model_signals[SELECTION_CHANGED]); } diff --git a/widgets/misc/e-selection-model.h b/widgets/misc/e-selection-model.h index 5ba0411587..3fb027e1a7 100644 --- a/widgets/misc/e-selection-model.h +++ b/widgets/misc/e-selection-model.h @@ -31,20 +31,6 @@ typedef struct { ESorter *sorter; - gint row_count; - guint32 *selection; - - gint cursor_row; - gint cursor_col; - gint selection_start_row; - - guint model_changed_id; - guint model_row_inserted_id, model_row_deleted_id; - - guint frozen : 1; - guint selection_model_changed : 1; - guint group_info_changed : 1; - GtkSelectionMode mode; ECursorMode cursor_mode; } ESelectionModel; @@ -52,58 +38,85 @@ typedef struct { typedef struct { GtkObjectClass parent_class; - gint (*get_row_count) (ESelectionModel *selection); + /* Virtual methods */ + gboolean (*is_row_selected) (ESelectionModel *esm, int row); + void (*foreach) (ESelectionModel *esm, EForeachFunc callback, gpointer closure); + void (*clear) (ESelectionModel *esm); + gint (*selected_count) (ESelectionModel *esm); + void (*select_all) (ESelectionModel *esm); + void (*invert_selection) (ESelectionModel *esm); + int (*row_count) (ESelectionModel *esm); + + /* Protected virtual methods. */ + void (*change_one_row) (ESelectionModel *esm, int row, gboolean on); + void (*change_cursor) (ESelectionModel *esm, int row, int col); + int (*cursor_row) (ESelectionModel *esm); + int (*cursor_col) (ESelectionModel *esm); + + void (*select_single_row) (ESelectionModel *selection, int row); + void (*toggle_single_row) (ESelectionModel *selection, int row); + void (*move_selection_end) (ESelectionModel *selection, int row); + void (*set_selection_end) (ESelectionModel *selection, int row); /* * Signals */ - void (*cursor_changed) (ESelectionModel *selection, int row, int col); - void (*cursor_activated) (ESelectionModel *selection, int row, int col); - void (*selection_changed) (ESelectionModel *selection); + void (*cursor_changed) (ESelectionModel *esm, int row, int col); + void (*cursor_activated) (ESelectionModel *esm, int row, int col); + void (*selection_changed) (ESelectionModel *esm); } ESelectionModelClass; + GtkType e_selection_model_get_type (void); -gboolean e_selection_model_is_row_selected (ESelectionModel *selection, - gint n); -void e_selection_model_foreach (ESelectionModel *selection, - EForeachFunc callback, - gpointer closure); -void e_selection_model_do_something (ESelectionModel *selection, +void e_selection_model_do_something (ESelectionModel *esm, guint row, guint col, GdkModifierType state); -void e_selection_model_maybe_do_something (ESelectionModel *selection, +void e_selection_model_maybe_do_something (ESelectionModel *esm, guint row, guint col, GdkModifierType state); -gint e_selection_model_key_press (ESelectionModel *selection, +gint e_selection_model_key_press (ESelectionModel *esm, GdkEventKey *key); -void e_selection_model_clear (ESelectionModel *selection); -gint e_selection_model_selected_count (ESelectionModel *selection); -void e_selection_model_select_all (ESelectionModel *selection); -void e_selection_model_invert_selection (ESelectionModel *selection); -/* Private Functions */ -void e_selection_model_insert_rows (ESelectionModel *esm, - int row, - int count); -void e_selection_model_delete_rows (ESelectionModel *esm, - int row, - int count); -void e_selection_model_move_row (ESelectionModel *esm, - int old_row, - int new_row); +/* Virtual functions */ +gboolean e_selection_model_is_row_selected (ESelectionModel *esm, + gint n); +void e_selection_model_foreach (ESelectionModel *esm, + EForeachFunc callback, + gpointer closure); +void e_selection_model_clear (ESelectionModel *esm); +gint e_selection_model_selected_count (ESelectionModel *esm); +void e_selection_model_select_all (ESelectionModel *esm); +void e_selection_model_invert_selection (ESelectionModel *esm); +int e_selection_model_row_count (ESelectionModel *esm); + + +/* Private virtual Functions */ void e_selection_model_change_one_row (ESelectionModel *esm, int row, gboolean on); void e_selection_model_change_cursor (ESelectionModel *esm, + int row, + int col); +int e_selection_model_cursor_row (ESelectionModel *esm); +int e_selection_model_cursor_col (ESelectionModel *esm); +void e_selection_model_select_single_row (ESelectionModel *selection, + int row); +void e_selection_model_toggle_single_row (ESelectionModel *selection, + int row); +void e_selection_model_move_selection_end (ESelectionModel *selection, + int row); +void e_selection_model_set_selection_end (ESelectionModel *selection, int row); -gboolean e_selection_model_confirm_row_count (ESelectionModel *esm); -/* Virtual Function */ -gint e_selection_model_get_row_count (ESelectionModel *esm); +/* Signals */ +void e_selection_model_cursor_changed (ESelectionModel *selection, + int row, + int col); +void e_selection_model_selection_changed (ESelectionModel *selection); #ifdef __cplusplus } -- cgit v1.2.3