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.c | 652 +++++++++++---------------------------- 1 file changed, 184 insertions(+), 468 deletions(-) (limited to 'widgets/misc/e-selection-model.c') 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]); } -- cgit v1.2.3