diff options
34 files changed, 2752 insertions, 2681 deletions
diff --git a/addressbook/gui/widgets/e-addressbook-table-adapter.c b/addressbook/gui/widgets/e-addressbook-table-adapter.c index 5bd188ccec..7a7dd4d69b 100644 --- a/addressbook/gui/widgets/e-addressbook-table-adapter.c +++ b/addressbook/gui/widgets/e-addressbook-table-adapter.c @@ -49,8 +49,6 @@ struct _EAddressbookTableAdapterPrivate { GHashTable *emails; }; -#define COLS (E_CONTACT_FIELD_LAST) - G_DEFINE_TYPE ( EAddressbookTableAdapter, e_addressbook_table_adapter, @@ -95,7 +93,7 @@ addressbook_finalize (GObject *object) static gint addressbook_col_count (ETableModel *etc) { - return COLS; + return E_CONTACT_FIELD_LAST; } /* This function returns the number of rows in our ETableModel. */ @@ -108,6 +106,40 @@ addressbook_row_count (ETableModel *etc) return e_addressbook_model_contact_count (priv->model); } +static void +addressbook_append_row (ETableModel *etm, + ETableModel *source, + gint row) +{ + EAddressbookTableAdapter *adapter = E_ADDRESSBOOK_TABLE_ADAPTER (etm); + EAddressbookTableAdapterPrivate *priv = adapter->priv; + EClientCache *client_cache; + ESourceRegistry *registry; + EBookClient *book_client; + EContact *contact; + gint col; + + contact = e_contact_new (); + + for (col = 1; col < E_CONTACT_LAST_SIMPLE_STRING; col++) { + gconstpointer val = e_table_model_value_at (source, col, row); + e_contact_set (contact, col, (gpointer) val); + } + + client_cache = + e_addressbook_model_get_client_cache (priv->model); + book_client = e_addressbook_model_get_client (priv->model); + + registry = e_client_cache_ref_registry (client_cache); + + eab_merging_book_add_contact ( + registry, book_client, contact, NULL, NULL); + + g_object_unref (registry); + + g_object_unref (contact); +} + /* This function returns the value at a particular point in our ETableModel. */ static gpointer addressbook_value_at (ETableModel *etc, @@ -119,7 +151,10 @@ addressbook_value_at (ETableModel *etc, EContact *contact; const gchar *value; - if (col >= COLS || row >= e_addressbook_model_contact_count (priv->model)) + if (col >= E_CONTACT_FIELD_LAST) + return NULL; + + if (row >= e_addressbook_model_contact_count (priv->model)) return NULL; contact = e_addressbook_model_contact_at (priv->model, row); @@ -176,7 +211,10 @@ addressbook_set_value_at (ETableModel *etc, EBookClient *book_client; EContact *contact; - if (col >= COLS || row >= e_addressbook_model_contact_count (priv->model)) + if (col >= E_CONTACT_FIELD_LAST) + return; + + if (row >= e_addressbook_model_contact_count (priv->model)) return; contact = e_addressbook_model_get_contact (priv->model, row); @@ -225,40 +263,6 @@ addressbook_is_cell_editable (ETableModel *etc, return FALSE; } -static void -addressbook_append_row (ETableModel *etm, - ETableModel *source, - gint row) -{ - EAddressbookTableAdapter *adapter = E_ADDRESSBOOK_TABLE_ADAPTER (etm); - EAddressbookTableAdapterPrivate *priv = adapter->priv; - EClientCache *client_cache; - ESourceRegistry *registry; - EBookClient *book_client; - EContact *contact; - gint col; - - contact = e_contact_new (); - - for (col = 1; col < E_CONTACT_LAST_SIMPLE_STRING; col++) { - gconstpointer val = e_table_model_value_at (source, col, row); - e_contact_set (contact, col, (gpointer) val); - } - - client_cache = - e_addressbook_model_get_client_cache (priv->model); - book_client = e_addressbook_model_get_client (priv->model); - - registry = e_client_cache_ref_registry (client_cache); - - eab_merging_book_add_contact ( - registry, book_client, contact, NULL, NULL); - - g_object_unref (registry); - - g_object_unref (contact); -} - /* This function duplicates the value passed to it. */ static gpointer addressbook_duplicate_value (ETableModel *etc, @@ -315,10 +319,10 @@ e_addressbook_table_adapter_class_init (EAddressbookTableAdapterClass *class) model_class = E_TABLE_MODEL_CLASS (class); model_class->column_count = addressbook_col_count; model_class->row_count = addressbook_row_count; + model_class->append_row = addressbook_append_row; model_class->value_at = addressbook_value_at; model_class->set_value_at = addressbook_set_value_at; model_class->is_cell_editable = addressbook_is_cell_editable; - model_class->append_row = addressbook_append_row; model_class->duplicate_value = addressbook_duplicate_value; model_class->free_value = addressbook_free_value; model_class->initialize_value = addressbook_initialize_value; diff --git a/calendar/gui/e-cal-model-calendar.c b/calendar/gui/e-cal-model-calendar.c index 5759d3acb1..114ffd4a7e 100644 --- a/calendar/gui/e-cal-model-calendar.c +++ b/calendar/gui/e-cal-model-calendar.c @@ -35,52 +35,10 @@ #include "dialogs/recur-comp.h" #include "dialogs/send-comp.h" -static gint ecmc_column_count (ETableModel *etm); -static gpointer ecmc_value_at (ETableModel *etm, gint col, gint row); -static void ecmc_set_value_at (ETableModel *etm, gint col, gint row, gconstpointer value); -static gboolean ecmc_is_cell_editable (ETableModel *etm, gint col, gint row); -static gpointer ecmc_duplicate_value (ETableModel *etm, gint col, gconstpointer value); -static void ecmc_free_value (ETableModel *etm, gint col, gpointer value); -static gpointer ecmc_initialize_value (ETableModel *etm, gint col); -static gboolean ecmc_value_is_empty (ETableModel *etm, gint col, gconstpointer value); -static gchar *ecmc_value_to_string (ETableModel *etm, gint col, gconstpointer value); - -static void ecmc_fill_component_from_model (ECalModel *model, ECalModelComponent *comp_data, - ETableModel *source_model, gint row); - -G_DEFINE_TYPE (ECalModelCalendar, e_cal_model_calendar, E_TYPE_CAL_MODEL) - -static void -e_cal_model_calendar_class_init (ECalModelCalendarClass *class) -{ - ETableModelClass *etm_class = E_TABLE_MODEL_CLASS (class); - ECalModelClass *model_class = E_CAL_MODEL_CLASS (class); - - etm_class->column_count = ecmc_column_count; - etm_class->value_at = ecmc_value_at; - etm_class->set_value_at = ecmc_set_value_at; - etm_class->is_cell_editable = ecmc_is_cell_editable; - etm_class->duplicate_value = ecmc_duplicate_value; - etm_class->free_value = ecmc_free_value; - etm_class->initialize_value = ecmc_initialize_value; - etm_class->value_is_empty = ecmc_value_is_empty; - etm_class->value_to_string = ecmc_value_to_string; - - model_class->fill_component_from_model = ecmc_fill_component_from_model; -} - -static void -e_cal_model_calendar_init (ECalModelCalendar *model) -{ - e_cal_model_set_component_kind (E_CAL_MODEL (model), ICAL_VEVENT_COMPONENT); -} - -/* ETableModel methods */ -static gint -ecmc_column_count (ETableModel *etm) -{ - return E_CAL_MODEL_CALENDAR_FIELD_LAST; -} +G_DEFINE_TYPE ( + ECalModelCalendar, + e_cal_model_calendar, + E_TYPE_CAL_MODEL) static ECellDateEditValue * get_dtend (ECalModelCalendar *model, @@ -164,38 +122,6 @@ get_transparency (ECalModelComponent *comp_data) return NULL; } -static gpointer -ecmc_value_at (ETableModel *etm, - gint col, - gint row) -{ - ECalModelComponent *comp_data; - ECalModelCalendar *model = (ECalModelCalendar *) etm; - - g_return_val_if_fail (E_IS_CAL_MODEL_CALENDAR (model), NULL); - - g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_CALENDAR_FIELD_LAST, NULL); - g_return_val_if_fail (row >= 0 && row < e_table_model_row_count (etm), NULL); - - if (col < E_CAL_MODEL_FIELD_LAST) - return E_TABLE_MODEL_CLASS (e_cal_model_calendar_parent_class)->value_at (etm, col, row); - - comp_data = e_cal_model_get_component_at (E_CAL_MODEL (model), row); - if (!comp_data) - return (gpointer) ""; - - switch (col) { - case E_CAL_MODEL_CALENDAR_FIELD_DTEND : - return get_dtend (model, comp_data); - case E_CAL_MODEL_CALENDAR_FIELD_LOCATION : - return get_location (comp_data); - case E_CAL_MODEL_CALENDAR_FIELD_TRANSPARENCY : - return get_transparency (comp_data); - } - - return (gpointer) ""; -} - static void set_dtend (ECalModel *model, ECalModelComponent *comp_data, @@ -266,10 +192,69 @@ set_transparency (ECalModelComponent *comp_data, } static void -ecmc_set_value_at (ETableModel *etm, - gint col, - gint row, - gconstpointer value) +cal_model_calendar_fill_component_from_model (ECalModel *model, + ECalModelComponent *comp_data, + ETableModel *source_model, + gint row) +{ + g_return_if_fail (E_IS_CAL_MODEL_CALENDAR (model)); + g_return_if_fail (comp_data != NULL); + g_return_if_fail (E_IS_TABLE_MODEL (source_model)); + + set_dtend ( + model, comp_data, + e_table_model_value_at (source_model, E_CAL_MODEL_CALENDAR_FIELD_DTEND, row)); + set_location ( + comp_data, + e_table_model_value_at (source_model, E_CAL_MODEL_CALENDAR_FIELD_LOCATION, row)); + set_transparency ( + comp_data, + e_table_model_value_at (source_model, E_CAL_MODEL_CALENDAR_FIELD_TRANSPARENCY, row)); +} + +static gint +cal_model_calendar_column_count (ETableModel *etm) +{ + return E_CAL_MODEL_CALENDAR_FIELD_LAST; +} + +static gpointer +cal_model_calendar_value_at (ETableModel *etm, + gint col, + gint row) +{ + ECalModelComponent *comp_data; + ECalModelCalendar *model = (ECalModelCalendar *) etm; + + g_return_val_if_fail (E_IS_CAL_MODEL_CALENDAR (model), NULL); + + g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_CALENDAR_FIELD_LAST, NULL); + g_return_val_if_fail (row >= 0 && row < e_table_model_row_count (etm), NULL); + + if (col < E_CAL_MODEL_FIELD_LAST) + return E_TABLE_MODEL_CLASS (e_cal_model_calendar_parent_class)->value_at (etm, col, row); + + comp_data = e_cal_model_get_component_at (E_CAL_MODEL (model), row); + if (!comp_data) + return (gpointer) ""; + + switch (col) { + case E_CAL_MODEL_CALENDAR_FIELD_DTEND : + return get_dtend (model, comp_data); + case E_CAL_MODEL_CALENDAR_FIELD_LOCATION : + return get_location (comp_data); + case E_CAL_MODEL_CALENDAR_FIELD_TRANSPARENCY : + return get_transparency (comp_data); + } + + return (gpointer) ""; +} + +static void +cal_model_calendar_set_value_at (ETableModel *etm, + gint col, + gint row, + gconstpointer value) { ECalModelComponent *comp_data; CalObjModType mod = CALOBJ_MOD_ALL; @@ -366,9 +351,9 @@ ecmc_set_value_at (ETableModel *etm, } static gboolean -ecmc_is_cell_editable (ETableModel *etm, - gint col, - gint row) +cal_model_calendar_is_cell_editable (ETableModel *etm, + gint col, + gint row) { ECalModelCalendar *model = (ECalModelCalendar *) etm; @@ -393,9 +378,9 @@ ecmc_is_cell_editable (ETableModel *etm, } static gpointer -ecmc_duplicate_value (ETableModel *etm, - gint col, - gconstpointer value) +cal_model_calendar_duplicate_value (ETableModel *etm, + gint col, + gconstpointer value) { g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_CALENDAR_FIELD_LAST, NULL); @@ -423,9 +408,9 @@ ecmc_duplicate_value (ETableModel *etm, } static void -ecmc_free_value (ETableModel *etm, - gint col, - gpointer value) +cal_model_calendar_free_value (ETableModel *etm, + gint col, + gpointer value) { g_return_if_fail (col >= 0 && col < E_CAL_MODEL_CALENDAR_FIELD_LAST); @@ -445,8 +430,8 @@ ecmc_free_value (ETableModel *etm, } static gpointer -ecmc_initialize_value (ETableModel *etm, - gint col) +cal_model_calendar_initialize_value (ETableModel *etm, + gint col) { g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_CALENDAR_FIELD_LAST, NULL); @@ -465,9 +450,9 @@ ecmc_initialize_value (ETableModel *etm, } static gboolean -ecmc_value_is_empty (ETableModel *etm, - gint col, - gconstpointer value) +cal_model_calendar_value_is_empty (ETableModel *etm, + gint col, + gconstpointer value) { g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_CALENDAR_FIELD_LAST, TRUE); @@ -486,9 +471,9 @@ ecmc_value_is_empty (ETableModel *etm, } static gchar * -ecmc_value_to_string (ETableModel *etm, - gint col, - gconstpointer value) +cal_model_calendar_value_to_string (ETableModel *etm, + gint col, + gconstpointer value) { g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_CALENDAR_FIELD_LAST, g_strdup ("")); @@ -506,32 +491,34 @@ ecmc_value_to_string (ETableModel *etm, return g_strdup (""); } -/* ECalModel class methods */ - static void -ecmc_fill_component_from_model (ECalModel *model, - ECalModelComponent *comp_data, - ETableModel *source_model, - gint row) +e_cal_model_calendar_class_init (ECalModelCalendarClass *class) { - g_return_if_fail (E_IS_CAL_MODEL_CALENDAR (model)); - g_return_if_fail (comp_data != NULL); - g_return_if_fail (E_IS_TABLE_MODEL (source_model)); + ECalModelClass *model_class; + ETableModelClass *etm_class; + + model_class = E_CAL_MODEL_CLASS (class); + model_class->fill_component_from_model = cal_model_calendar_fill_component_from_model; + + etm_class = E_TABLE_MODEL_CLASS (class); + etm_class->column_count = cal_model_calendar_column_count; + etm_class->value_at = cal_model_calendar_value_at; + etm_class->set_value_at = cal_model_calendar_set_value_at; + etm_class->is_cell_editable = cal_model_calendar_is_cell_editable; + etm_class->duplicate_value = cal_model_calendar_duplicate_value; + etm_class->free_value = cal_model_calendar_free_value; + etm_class->initialize_value = cal_model_calendar_initialize_value; + etm_class->value_is_empty = cal_model_calendar_value_is_empty; + etm_class->value_to_string = cal_model_calendar_value_to_string; +} - set_dtend ( - model, comp_data, - e_table_model_value_at (source_model, E_CAL_MODEL_CALENDAR_FIELD_DTEND, row)); - set_location ( - comp_data, - e_table_model_value_at (source_model, E_CAL_MODEL_CALENDAR_FIELD_LOCATION, row)); - set_transparency ( - comp_data, - e_table_model_value_at (source_model, E_CAL_MODEL_CALENDAR_FIELD_TRANSPARENCY, row)); +static void +e_cal_model_calendar_init (ECalModelCalendar *model) +{ + e_cal_model_set_component_kind ( + E_CAL_MODEL (model), ICAL_VEVENT_COMPONENT); } -/** - * e_cal_model_calendar_new - */ ECalModel * e_cal_model_calendar_new (ESourceRegistry *registry) { diff --git a/calendar/gui/e-cal-model-memos.c b/calendar/gui/e-cal-model-memos.c index a6d3f1d612..dc3440e54d 100644 --- a/calendar/gui/e-cal-model-memos.c +++ b/calendar/gui/e-cal-model-memos.c @@ -35,57 +35,39 @@ #define d(x) (x) -static gint ecmm_column_count (ETableModel *etm); -static gpointer ecmm_value_at (ETableModel *etm, gint col, gint row); -static void ecmm_set_value_at (ETableModel *etm, gint col, gint row, gconstpointer value); -static gboolean ecmm_is_cell_editable (ETableModel *etm, gint col, gint row); -static gpointer ecmm_duplicate_value (ETableModel *etm, gint col, gconstpointer value); -static void ecmm_free_value (ETableModel *etm, gint col, gpointer value); -static gpointer ecmm_initialize_value (ETableModel *etm, gint col); -static gboolean ecmm_value_is_empty (ETableModel *etm, gint col, gconstpointer value); -static gchar *ecmm_value_to_string (ETableModel *etm, gint col, gconstpointer value); - -static void ecmm_fill_component_from_model (ECalModel *model, ECalModelComponent *comp_data, - ETableModel *source_model, gint row); - -G_DEFINE_TYPE (ECalModelMemos, e_cal_model_memos, E_TYPE_CAL_MODEL) +G_DEFINE_TYPE ( + ECalModelMemos, + e_cal_model_memos, + E_TYPE_CAL_MODEL) static void -e_cal_model_memos_class_init (ECalModelMemosClass *class) +cal_model_memos_fill_component_from_model (ECalModel *model, + ECalModelComponent *comp_data, + ETableModel *source_model, + gint row) { - ETableModelClass *etm_class = E_TABLE_MODEL_CLASS (class); - ECalModelClass *model_class = E_CAL_MODEL_CLASS (class); - - etm_class->column_count = ecmm_column_count; - etm_class->value_at = ecmm_value_at; - etm_class->set_value_at = ecmm_set_value_at; - etm_class->is_cell_editable = ecmm_is_cell_editable; - etm_class->duplicate_value = ecmm_duplicate_value; - etm_class->free_value = ecmm_free_value; - etm_class->initialize_value = ecmm_initialize_value; - etm_class->value_is_empty = ecmm_value_is_empty; - etm_class->value_to_string = ecmm_value_to_string; - - model_class->fill_component_from_model = ecmm_fill_component_from_model; -} + icaltimetype start; + g_return_if_fail (E_IS_CAL_MODEL_MEMOS (model)); + g_return_if_fail (comp_data != NULL); + g_return_if_fail (E_IS_TABLE_MODEL (source_model)); -static void -e_cal_model_memos_init (ECalModelMemos *model) -{ - e_cal_model_set_component_kind (E_CAL_MODEL (model), ICAL_VJOURNAL_COMPONENT); + start = icalcomponent_get_dtstart (comp_data->icalcomp); + if (icaltime_compare_date_only (start, icaltime_null_time ()) == 0) { + start = icaltime_today (); + icalcomponent_set_dtstart (comp_data->icalcomp, start); + } } -/* ETableModel methods */ static gint -ecmm_column_count (ETableModel *etm) +cal_model_memos_column_count (ETableModel *etm) { return E_CAL_MODEL_MEMOS_FIELD_LAST; } static gpointer -ecmm_value_at (ETableModel *etm, - gint col, - gint row) +cal_model_memos_value_at (ETableModel *etm, + gint col, + gint row) { ECalModelComponent *comp_data; ECalModelMemos *model = (ECalModelMemos *) etm; @@ -106,10 +88,10 @@ ecmm_value_at (ETableModel *etm, } static void -ecmm_set_value_at (ETableModel *etm, - gint col, - gint row, - gconstpointer value) +cal_model_memos_set_value_at (ETableModel *etm, + gint col, + gint row, + gconstpointer value) { ECalModelComponent *comp_data; ECalModelMemos *model = (ECalModelMemos *) etm; @@ -146,9 +128,9 @@ ecmm_set_value_at (ETableModel *etm, } static gboolean -ecmm_is_cell_editable (ETableModel *etm, - gint col, - gint row) +cal_model_memos_is_cell_editable (ETableModel *etm, + gint col, + gint row) { ECalModelMemos *model = (ECalModelMemos *) etm; gboolean retval = FALSE; @@ -167,9 +149,9 @@ ecmm_is_cell_editable (ETableModel *etm, } static gpointer -ecmm_duplicate_value (ETableModel *etm, - gint col, - gconstpointer value) +cal_model_memos_duplicate_value (ETableModel *etm, + gint col, + gconstpointer value) { g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_MEMOS_FIELD_LAST, NULL); @@ -180,9 +162,9 @@ ecmm_duplicate_value (ETableModel *etm, } static void -ecmm_free_value (ETableModel *etm, - gint col, - gpointer value) +cal_model_memos_free_value (ETableModel *etm, + gint col, + gpointer value) { g_return_if_fail (col >= 0 && col < E_CAL_MODEL_MEMOS_FIELD_LAST); @@ -193,8 +175,8 @@ ecmm_free_value (ETableModel *etm, } static gpointer -ecmm_initialize_value (ETableModel *etm, - gint col) +cal_model_memos_initialize_value (ETableModel *etm, + gint col) { g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_MEMOS_FIELD_LAST, NULL); @@ -205,9 +187,9 @@ ecmm_initialize_value (ETableModel *etm, } static gboolean -ecmm_value_is_empty (ETableModel *etm, - gint col, - gconstpointer value) +cal_model_memos_value_is_empty (ETableModel *etm, + gint col, + gconstpointer value) { g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_MEMOS_FIELD_LAST, TRUE); @@ -218,9 +200,9 @@ ecmm_value_is_empty (ETableModel *etm, } static gchar * -ecmm_value_to_string (ETableModel *etm, - gint col, - gconstpointer value) +cal_model_memos_value_to_string (ETableModel *etm, + gint col, + gconstpointer value) { g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_MEMOS_FIELD_LAST, g_strdup ("")); @@ -230,30 +212,34 @@ ecmm_value_to_string (ETableModel *etm, return g_strdup (""); } -/* ECalModel class methods */ - static void -ecmm_fill_component_from_model (ECalModel *model, - ECalModelComponent *comp_data, - ETableModel *source_model, - gint row) +e_cal_model_memos_class_init (ECalModelMemosClass *class) { - icaltimetype start; - g_return_if_fail (E_IS_CAL_MODEL_MEMOS (model)); - g_return_if_fail (comp_data != NULL); - g_return_if_fail (E_IS_TABLE_MODEL (source_model)); - - start = icalcomponent_get_dtstart (comp_data->icalcomp); - if (icaltime_compare_date_only (start, icaltime_null_time ()) == 0) { - start = icaltime_today (); - icalcomponent_set_dtstart (comp_data->icalcomp, start); - } + ECalModelClass *model_class; + ETableModelClass *etm_class; + + model_class = E_CAL_MODEL_CLASS (class); + model_class->fill_component_from_model = cal_model_memos_fill_component_from_model; + + etm_class = E_TABLE_MODEL_CLASS (class); + etm_class->column_count = cal_model_memos_column_count; + etm_class->value_at = cal_model_memos_value_at; + etm_class->set_value_at = cal_model_memos_set_value_at; + etm_class->is_cell_editable = cal_model_memos_is_cell_editable; + etm_class->duplicate_value = cal_model_memos_duplicate_value; + etm_class->free_value = cal_model_memos_free_value; + etm_class->initialize_value = cal_model_memos_initialize_value; + etm_class->value_is_empty = cal_model_memos_value_is_empty; + etm_class->value_to_string = cal_model_memos_value_to_string; +} +static void +e_cal_model_memos_init (ECalModelMemos *model) +{ + e_cal_model_set_component_kind ( + E_CAL_MODEL (model), ICAL_VJOURNAL_COMPONENT); } -/** - * e_cal_model_memos_new - */ ECalModel * e_cal_model_memos_new (ESourceRegistry *registry) { diff --git a/calendar/gui/e-cal-model-tasks.c b/calendar/gui/e-cal-model-tasks.c index 81c3cb3a45..a3e6cb8107 100644 --- a/calendar/gui/e-cal-model-tasks.c +++ b/calendar/gui/e-cal-model-tasks.c @@ -47,23 +47,6 @@ struct _ECalModelTasksPrivate { gchar *color_overdue; }; -static gint ecmt_column_count (ETableModel *etm); -static gpointer ecmt_value_at (ETableModel *etm, gint col, gint row); -static void ecmt_set_value_at (ETableModel *etm, gint col, gint row, gconstpointer value); -static gboolean ecmt_is_cell_editable (ETableModel *etm, gint col, gint row); -static gpointer ecmt_duplicate_value (ETableModel *etm, gint col, gconstpointer value); -static void ecmt_free_value (ETableModel *etm, gint col, gpointer value); -static gpointer ecmt_initialize_value (ETableModel *etm, gint col); -static gboolean ecmt_value_is_empty (ETableModel *etm, gint col, gconstpointer value); -static gchar *ecmt_value_to_string (ETableModel *etm, gint col, gconstpointer value); - -static const gchar *ecmt_get_color_for_component (ECalModel *model, ECalModelComponent *comp_data); -static void ecmt_fill_component_from_model (ECalModel *model, ECalModelComponent *comp_data, - ETableModel *source_model, gint row); -static void commit_component_changes (ECalModelComponent *comp_data); - -G_DEFINE_TYPE (ECalModelTasks, e_cal_model_tasks, E_TYPE_CAL_MODEL) - enum { PROP_0, PROP_HIGHLIGHT_DUE_TODAY, @@ -72,182 +55,10 @@ enum { PROP_COLOR_OVERDUE }; -static void -cal_model_tasks_set_property (GObject *object, - guint property_id, - const GValue *value, - GParamSpec *pspec) -{ - switch (property_id) { - case PROP_HIGHLIGHT_DUE_TODAY: - e_cal_model_tasks_set_highlight_due_today ( - E_CAL_MODEL_TASKS (object), - g_value_get_boolean (value)); - return; - - case PROP_COLOR_DUE_TODAY: - e_cal_model_tasks_set_color_due_today ( - E_CAL_MODEL_TASKS (object), - g_value_get_string (value)); - return; - - case PROP_HIGHLIGHT_OVERDUE: - e_cal_model_tasks_set_highlight_overdue ( - E_CAL_MODEL_TASKS (object), - g_value_get_boolean (value)); - return; - - case PROP_COLOR_OVERDUE: - e_cal_model_tasks_set_color_overdue ( - E_CAL_MODEL_TASKS (object), - g_value_get_string (value)); - return; - } - - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); -} - -static void -cal_model_tasks_get_property (GObject *object, - guint property_id, - GValue *value, - GParamSpec *pspec) -{ - switch (property_id) { - case PROP_HIGHLIGHT_DUE_TODAY: - g_value_set_boolean ( - value, - e_cal_model_tasks_get_highlight_due_today ( - E_CAL_MODEL_TASKS (object))); - return; - - case PROP_COLOR_DUE_TODAY: - g_value_set_string ( - value, - e_cal_model_tasks_get_color_due_today ( - E_CAL_MODEL_TASKS (object))); - return; - - case PROP_HIGHLIGHT_OVERDUE: - g_value_set_boolean ( - value, - e_cal_model_tasks_get_highlight_overdue ( - E_CAL_MODEL_TASKS (object))); - return; - - case PROP_COLOR_OVERDUE: - g_value_set_string ( - value, - e_cal_model_tasks_get_color_overdue ( - E_CAL_MODEL_TASKS (object))); - return; - } - - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); -} - -static void -cal_model_tasks_finalize (GObject *object) -{ - ECalModelTasksPrivate *priv; - - priv = E_CAL_MODEL_TASKS_GET_PRIVATE (object); - - g_free (priv->color_due_today); - g_free (priv->color_overdue); - - /* Chain up to parent's finalize() method. */ - G_OBJECT_CLASS (e_cal_model_tasks_parent_class)->finalize (object); -} - -static void -e_cal_model_tasks_class_init (ECalModelTasksClass *class) -{ - GObjectClass *object_class; - ETableModelClass *table_model_class; - ECalModelClass *cal_model_class; - - g_type_class_add_private (class, sizeof (ECalModelTasksPrivate)); - - object_class = G_OBJECT_CLASS (class); - object_class->set_property = cal_model_tasks_set_property; - object_class->get_property = cal_model_tasks_get_property; - object_class->finalize = cal_model_tasks_finalize; - - table_model_class = E_TABLE_MODEL_CLASS (class); - table_model_class->column_count = ecmt_column_count; - table_model_class->value_at = ecmt_value_at; - table_model_class->set_value_at = ecmt_set_value_at; - table_model_class->is_cell_editable = ecmt_is_cell_editable; - table_model_class->duplicate_value = ecmt_duplicate_value; - table_model_class->free_value = ecmt_free_value; - table_model_class->initialize_value = ecmt_initialize_value; - table_model_class->value_is_empty = ecmt_value_is_empty; - table_model_class->value_to_string = ecmt_value_to_string; - - cal_model_class = E_CAL_MODEL_CLASS (class); - cal_model_class->get_color_for_component = ecmt_get_color_for_component; - cal_model_class->fill_component_from_model = ecmt_fill_component_from_model; - - g_object_class_install_property ( - object_class, - PROP_HIGHLIGHT_DUE_TODAY, - g_param_spec_boolean ( - "highlight-due-today", - "Highlight Due Today", - NULL, - TRUE, - G_PARAM_READWRITE)); - - g_object_class_install_property ( - object_class, - PROP_COLOR_DUE_TODAY, - g_param_spec_string ( - "color-due-today", - "Color Due Today", - NULL, - "#1e90ff", - G_PARAM_READWRITE)); - - g_object_class_install_property ( - object_class, - PROP_HIGHLIGHT_OVERDUE, - g_param_spec_boolean ( - "highlight-overdue", - "Highlight Overdue", - NULL, - TRUE, - G_PARAM_READWRITE)); - - g_object_class_install_property ( - object_class, - PROP_COLOR_OVERDUE, - g_param_spec_string ( - "color-overdue", - "Color Overdue", - NULL, - "#ff0000", - G_PARAM_READWRITE)); -} - -static void -e_cal_model_tasks_init (ECalModelTasks *model) -{ - model->priv = E_CAL_MODEL_TASKS_GET_PRIVATE (model); - - model->priv->highlight_due_today = TRUE; - model->priv->highlight_overdue = TRUE; - - e_cal_model_set_component_kind ( - E_CAL_MODEL (model), ICAL_VTODO_COMPONENT); -} - -/* ETableModel methods */ -static gint -ecmt_column_count (ETableModel *etm) -{ - return E_CAL_MODEL_TASKS_FIELD_LAST; -} +G_DEFINE_TYPE ( + ECalModelTasks, + e_cal_model_tasks, + E_TYPE_CAL_MODEL) /* This makes sure a task is marked as complete. * It makes sure the "Date Completed" property is set. If the completed_date @@ -617,52 +428,6 @@ is_overdue (ECalModelTasks *model, return FALSE; } -static gpointer -ecmt_value_at (ETableModel *etm, - gint col, - gint row) -{ - ECalModelComponent *comp_data; - ECalModelTasks *model = (ECalModelTasks *) etm; - - g_return_val_if_fail (E_IS_CAL_MODEL_TASKS (model), NULL); - - g_return_val_if_fail (col >= 0 && (col < E_CAL_MODEL_TASKS_FIELD_LAST || col == E_CAL_MODEL_TASKS_FIELD_STRIKEOUT), NULL); - g_return_val_if_fail (row >= 0 && row < e_table_model_row_count (etm), NULL); - - if (col < E_CAL_MODEL_FIELD_LAST) - return E_TABLE_MODEL_CLASS (e_cal_model_tasks_parent_class)->value_at (etm, col, row); - - comp_data = e_cal_model_get_component_at (E_CAL_MODEL (model), row); - if (!comp_data) - return (gpointer) ""; - - switch (col) { - case E_CAL_MODEL_TASKS_FIELD_COMPLETED : - return get_completed (comp_data); - case E_CAL_MODEL_TASKS_FIELD_STRIKEOUT : - return GINT_TO_POINTER (is_status_canceled (comp_data) || is_complete (comp_data)); - case E_CAL_MODEL_TASKS_FIELD_COMPLETE : - return GINT_TO_POINTER (is_complete (comp_data)); - case E_CAL_MODEL_TASKS_FIELD_DUE : - return get_due (comp_data); - case E_CAL_MODEL_TASKS_FIELD_GEO : - return get_geo (comp_data); - case E_CAL_MODEL_TASKS_FIELD_OVERDUE : - return GINT_TO_POINTER (is_overdue (model, comp_data)); - case E_CAL_MODEL_TASKS_FIELD_PERCENT : - return GINT_TO_POINTER (get_percent (comp_data)); - case E_CAL_MODEL_TASKS_FIELD_PRIORITY : - return get_priority (comp_data); - case E_CAL_MODEL_TASKS_FIELD_STATUS : - return get_status (comp_data); - case E_CAL_MODEL_TASKS_FIELD_URL : - return get_url (comp_data); - } - - return (gpointer) ""; -} - static void set_completed (ECalModelTasks *model, ECalModelComponent *comp_data, @@ -906,11 +671,250 @@ set_url (ECalModelComponent *comp_data, } } +/** + * commit_component_changes + * @comp_data: Component of our interest, which has been changed. + * + * Commits changes to the backend calendar of the component. + **/ +static void +commit_component_changes (ECalModelComponent *comp_data) +{ + GError *error = NULL; + + g_return_if_fail (comp_data != NULL); + + /* FIXME ask about mod type */ + e_cal_client_modify_object_sync ( + comp_data->client, comp_data->icalcomp, + CALOBJ_MOD_ALL, NULL, &error); + + if (error != NULL) { + g_warning ( + G_STRLOC ": Could not modify the object! %s", + error->message); + + /* FIXME Show error dialog */ + g_error_free (error); + } +} + +static void +cal_model_tasks_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (property_id) { + case PROP_HIGHLIGHT_DUE_TODAY: + e_cal_model_tasks_set_highlight_due_today ( + E_CAL_MODEL_TASKS (object), + g_value_get_boolean (value)); + return; + + case PROP_COLOR_DUE_TODAY: + e_cal_model_tasks_set_color_due_today ( + E_CAL_MODEL_TASKS (object), + g_value_get_string (value)); + return; + + case PROP_HIGHLIGHT_OVERDUE: + e_cal_model_tasks_set_highlight_overdue ( + E_CAL_MODEL_TASKS (object), + g_value_get_boolean (value)); + return; + + case PROP_COLOR_OVERDUE: + e_cal_model_tasks_set_color_overdue ( + E_CAL_MODEL_TASKS (object), + g_value_get_string (value)); + return; + } + + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); +} + static void -ecmt_set_value_at (ETableModel *etm, - gint col, - gint row, - gconstpointer value) +cal_model_tasks_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + switch (property_id) { + case PROP_HIGHLIGHT_DUE_TODAY: + g_value_set_boolean ( + value, + e_cal_model_tasks_get_highlight_due_today ( + E_CAL_MODEL_TASKS (object))); + return; + + case PROP_COLOR_DUE_TODAY: + g_value_set_string ( + value, + e_cal_model_tasks_get_color_due_today ( + E_CAL_MODEL_TASKS (object))); + return; + + case PROP_HIGHLIGHT_OVERDUE: + g_value_set_boolean ( + value, + e_cal_model_tasks_get_highlight_overdue ( + E_CAL_MODEL_TASKS (object))); + return; + + case PROP_COLOR_OVERDUE: + g_value_set_string ( + value, + e_cal_model_tasks_get_color_overdue ( + E_CAL_MODEL_TASKS (object))); + return; + } + + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); +} + +static void +cal_model_tasks_finalize (GObject *object) +{ + ECalModelTasksPrivate *priv; + + priv = E_CAL_MODEL_TASKS_GET_PRIVATE (object); + + g_free (priv->color_due_today); + g_free (priv->color_overdue); + + /* Chain up to parent's finalize() method. */ + G_OBJECT_CLASS (e_cal_model_tasks_parent_class)->finalize (object); +} + +static const gchar * +cal_model_tasks_get_color_for_component (ECalModel *model, + ECalModelComponent *comp_data) +{ + ECalModelTasks *tasks; + + g_return_val_if_fail (E_IS_CAL_MODEL_TASKS (model), NULL); + g_return_val_if_fail (comp_data != NULL, NULL); + + tasks = E_CAL_MODEL_TASKS (model); + + /* XXX ECalModel's get_color_for_component() method should really + * get a GdkColor instead of a color specification string. */ + + switch (get_due_status (tasks, comp_data)) { + case E_CAL_MODEL_TASKS_DUE_TODAY: + if (!e_cal_model_tasks_get_highlight_due_today (tasks)) + break; + return e_cal_model_tasks_get_color_due_today (tasks); + case E_CAL_MODEL_TASKS_DUE_OVERDUE: + if (!e_cal_model_tasks_get_highlight_overdue (tasks)) + break; + return e_cal_model_tasks_get_color_overdue (tasks); + case E_CAL_MODEL_TASKS_DUE_NEVER: + case E_CAL_MODEL_TASKS_DUE_FUTURE: + case E_CAL_MODEL_TASKS_DUE_COMPLETE: + break; + } + + return E_CAL_MODEL_CLASS (e_cal_model_tasks_parent_class)-> + get_color_for_component (model, comp_data); +} + +static void +cal_model_tasks_fill_component_from_model (ECalModel *model, + ECalModelComponent *comp_data, + ETableModel *source_model, + gint row) +{ + gpointer value; + + g_return_if_fail (E_IS_CAL_MODEL_TASKS (model)); + g_return_if_fail (comp_data != NULL); + g_return_if_fail (E_IS_TABLE_MODEL (source_model)); + + /* This just makes sure if anything indicates completion, all + * three fields do or if percent is 0, status is sane */ + + value = e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_COMPLETED, row); + set_completed ((ECalModelTasks *) model, comp_data, value); + if (!value) { + value = e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_PERCENT, row); + set_percent (comp_data, value); + if (GPOINTER_TO_INT (value) != 100 && GPOINTER_TO_INT (value) != 0) + set_status (comp_data, e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_STATUS, row)); + } + + set_due ( + model, comp_data, + e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_DUE, row)); + set_geo ( + comp_data, + e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_GEO, row)); + set_priority ( + comp_data, + e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_PRIORITY, row)); + set_url ( + comp_data, + e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_URL, row)); +} + +static gint +cal_model_tasks_column_count (ETableModel *etm) +{ + return E_CAL_MODEL_TASKS_FIELD_LAST; +} + +static gpointer +cal_model_tasks_value_at (ETableModel *etm, + gint col, + gint row) +{ + ECalModelComponent *comp_data; + ECalModelTasks *model = (ECalModelTasks *) etm; + + g_return_val_if_fail (E_IS_CAL_MODEL_TASKS (model), NULL); + + g_return_val_if_fail (col >= 0 && (col < E_CAL_MODEL_TASKS_FIELD_LAST || col == E_CAL_MODEL_TASKS_FIELD_STRIKEOUT), NULL); + g_return_val_if_fail (row >= 0 && row < e_table_model_row_count (etm), NULL); + + if (col < E_CAL_MODEL_FIELD_LAST) + return E_TABLE_MODEL_CLASS (e_cal_model_tasks_parent_class)->value_at (etm, col, row); + + comp_data = e_cal_model_get_component_at (E_CAL_MODEL (model), row); + if (!comp_data) + return (gpointer) ""; + + switch (col) { + case E_CAL_MODEL_TASKS_FIELD_COMPLETED : + return get_completed (comp_data); + case E_CAL_MODEL_TASKS_FIELD_STRIKEOUT : + return GINT_TO_POINTER (is_status_canceled (comp_data) || is_complete (comp_data)); + case E_CAL_MODEL_TASKS_FIELD_COMPLETE : + return GINT_TO_POINTER (is_complete (comp_data)); + case E_CAL_MODEL_TASKS_FIELD_DUE : + return get_due (comp_data); + case E_CAL_MODEL_TASKS_FIELD_GEO : + return get_geo (comp_data); + case E_CAL_MODEL_TASKS_FIELD_OVERDUE : + return GINT_TO_POINTER (is_overdue (model, comp_data)); + case E_CAL_MODEL_TASKS_FIELD_PERCENT : + return GINT_TO_POINTER (get_percent (comp_data)); + case E_CAL_MODEL_TASKS_FIELD_PRIORITY : + return get_priority (comp_data); + case E_CAL_MODEL_TASKS_FIELD_STATUS : + return get_status (comp_data); + case E_CAL_MODEL_TASKS_FIELD_URL : + return get_url (comp_data); + } + + return (gpointer) ""; +} + +static void +cal_model_tasks_set_value_at (ETableModel *etm, + gint col, + gint row, + gconstpointer value) { ECalModelComponent *comp_data; ECalModelTasks *model = (ECalModelTasks *) etm; @@ -960,9 +964,9 @@ ecmt_set_value_at (ETableModel *etm, } static gboolean -ecmt_is_cell_editable (ETableModel *etm, - gint col, - gint row) +cal_model_tasks_is_cell_editable (ETableModel *etm, + gint col, + gint row) { ECalModelTasks *model = (ECalModelTasks *) etm; @@ -993,9 +997,9 @@ ecmt_is_cell_editable (ETableModel *etm, } static gpointer -ecmt_duplicate_value (ETableModel *etm, - gint col, - gconstpointer value) +cal_model_tasks_duplicate_value (ETableModel *etm, + gint col, + gconstpointer value) { g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_TASKS_FIELD_LAST, NULL); @@ -1031,9 +1035,9 @@ ecmt_duplicate_value (ETableModel *etm, } static void -ecmt_free_value (ETableModel *etm, - gint col, - gpointer value) +cal_model_tasks_free_value (ETableModel *etm, + gint col, + gpointer value) { g_return_if_fail (col >= 0 && col < E_CAL_MODEL_TASKS_FIELD_LAST); @@ -1060,8 +1064,8 @@ ecmt_free_value (ETableModel *etm, } static gpointer -ecmt_initialize_value (ETableModel *etm, - gint col) +cal_model_tasks_initialize_value (ETableModel *etm, + gint col) { ECalModelTasks *model = (ECalModelTasks *) etm; @@ -1090,9 +1094,9 @@ ecmt_initialize_value (ETableModel *etm, } static gboolean -ecmt_value_is_empty (ETableModel *etm, - gint col, - gconstpointer value) +cal_model_tasks_value_is_empty (ETableModel *etm, + gint col, + gconstpointer value) { ECalModelTasks *model = (ECalModelTasks *) etm; @@ -1122,9 +1126,9 @@ ecmt_value_is_empty (ETableModel *etm, } static gchar * -ecmt_value_to_string (ETableModel *etm, - gint col, - gconstpointer value) +cal_model_tasks_value_to_string (ETableModel *etm, + gint col, + gconstpointer value) { ECalModelTasks *model = (ECalModelTasks *) etm; @@ -1156,77 +1160,86 @@ ecmt_value_to_string (ETableModel *etm, return g_strdup (""); } -/* ECalModel class methods */ - -static const gchar * -ecmt_get_color_for_component (ECalModel *model, - ECalModelComponent *comp_data) +static void +e_cal_model_tasks_class_init (ECalModelTasksClass *class) { - ECalModelTasks *tasks; + GObjectClass *object_class; + ECalModelClass *cal_model_class; + ETableModelClass *table_model_class; - g_return_val_if_fail (E_IS_CAL_MODEL_TASKS (model), NULL); - g_return_val_if_fail (comp_data != NULL, NULL); + g_type_class_add_private (class, sizeof (ECalModelTasksPrivate)); - tasks = E_CAL_MODEL_TASKS (model); + object_class = G_OBJECT_CLASS (class); + object_class->set_property = cal_model_tasks_set_property; + object_class->get_property = cal_model_tasks_get_property; + object_class->finalize = cal_model_tasks_finalize; - /* XXX ECalModel's get_color_for_component() method should really - * get a GdkColor instead of a color specification string. */ + cal_model_class = E_CAL_MODEL_CLASS (class); + cal_model_class->get_color_for_component = cal_model_tasks_get_color_for_component; + cal_model_class->fill_component_from_model = cal_model_tasks_fill_component_from_model; - switch (get_due_status (tasks, comp_data)) { - case E_CAL_MODEL_TASKS_DUE_TODAY: - if (!e_cal_model_tasks_get_highlight_due_today (tasks)) - break; - return e_cal_model_tasks_get_color_due_today (tasks); - case E_CAL_MODEL_TASKS_DUE_OVERDUE: - if (!e_cal_model_tasks_get_highlight_overdue (tasks)) - break; - return e_cal_model_tasks_get_color_overdue (tasks); - case E_CAL_MODEL_TASKS_DUE_NEVER: - case E_CAL_MODEL_TASKS_DUE_FUTURE: - case E_CAL_MODEL_TASKS_DUE_COMPLETE: - break; - } + table_model_class = E_TABLE_MODEL_CLASS (class); + table_model_class->column_count = cal_model_tasks_column_count; + table_model_class->value_at = cal_model_tasks_value_at; + table_model_class->set_value_at = cal_model_tasks_set_value_at; + table_model_class->is_cell_editable = cal_model_tasks_is_cell_editable; + table_model_class->duplicate_value = cal_model_tasks_duplicate_value; + table_model_class->free_value = cal_model_tasks_free_value; + table_model_class->initialize_value = cal_model_tasks_initialize_value; + table_model_class->value_is_empty = cal_model_tasks_value_is_empty; + table_model_class->value_to_string = cal_model_tasks_value_to_string; - return E_CAL_MODEL_CLASS (e_cal_model_tasks_parent_class)-> - get_color_for_component (model, comp_data); + g_object_class_install_property ( + object_class, + PROP_HIGHLIGHT_DUE_TODAY, + g_param_spec_boolean ( + "highlight-due-today", + "Highlight Due Today", + NULL, + TRUE, + G_PARAM_READWRITE)); + + g_object_class_install_property ( + object_class, + PROP_COLOR_DUE_TODAY, + g_param_spec_string ( + "color-due-today", + "Color Due Today", + NULL, + "#1e90ff", + G_PARAM_READWRITE)); + + g_object_class_install_property ( + object_class, + PROP_HIGHLIGHT_OVERDUE, + g_param_spec_boolean ( + "highlight-overdue", + "Highlight Overdue", + NULL, + TRUE, + G_PARAM_READWRITE)); + + g_object_class_install_property ( + object_class, + PROP_COLOR_OVERDUE, + g_param_spec_string ( + "color-overdue", + "Color Overdue", + NULL, + "#ff0000", + G_PARAM_READWRITE)); } static void -ecmt_fill_component_from_model (ECalModel *model, - ECalModelComponent *comp_data, - ETableModel *source_model, - gint row) +e_cal_model_tasks_init (ECalModelTasks *model) { - gpointer value; - - g_return_if_fail (E_IS_CAL_MODEL_TASKS (model)); - g_return_if_fail (comp_data != NULL); - g_return_if_fail (E_IS_TABLE_MODEL (source_model)); - - /* This just makes sure if anything indicates completion, all - * three fields do or if percent is 0, status is sane */ + model->priv = E_CAL_MODEL_TASKS_GET_PRIVATE (model); - value = e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_COMPLETED, row); - set_completed ((ECalModelTasks *) model, comp_data, value); - if (!value) { - value = e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_PERCENT, row); - set_percent (comp_data, value); - if (GPOINTER_TO_INT (value) != 100 && GPOINTER_TO_INT (value) != 0) - set_status (comp_data, e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_STATUS, row)); - } + model->priv->highlight_due_today = TRUE; + model->priv->highlight_overdue = TRUE; - set_due ( - model, comp_data, - e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_DUE, row)); - set_geo ( - comp_data, - e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_GEO, row)); - set_priority ( - comp_data, - e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_PRIORITY, row)); - set_url ( - comp_data, - e_table_model_value_at (source_model, E_CAL_MODEL_TASKS_FIELD_URL, row)); + e_cal_model_set_component_kind ( + E_CAL_MODEL (model), ICAL_VTODO_COMPONENT); } ECalModel * @@ -1338,7 +1351,9 @@ e_cal_model_tasks_set_color_overdue (ECalModelTasks *model, * * Marks component as complete and commits changes to the calendar backend. **/ -void e_cal_model_tasks_mark_comp_complete (ECalModelTasks *model, ECalModelComponent *comp_data) +void +e_cal_model_tasks_mark_comp_complete (ECalModelTasks *model, + ECalModelComponent *comp_data) { g_return_if_fail (model != NULL); g_return_if_fail (comp_data != NULL); @@ -1360,7 +1375,9 @@ void e_cal_model_tasks_mark_comp_complete (ECalModelTasks *model, ECalModelCompo * * Marks component as incomplete and commits changes to the calendar backend. **/ -void e_cal_model_tasks_mark_comp_incomplete (ECalModelTasks *model, ECalModelComponent *comp_data) +void +e_cal_model_tasks_mark_comp_incomplete (ECalModelTasks *model, + ECalModelComponent *comp_data) { icalproperty *prop,*prop1; @@ -1396,37 +1413,6 @@ void e_cal_model_tasks_mark_comp_incomplete (ECalModelTasks *model, ECalModelCom commit_component_changes (comp_data); } -/** - * commit_component_changes - * @comp_data: Component of our interest, which has been changed. - * - * Commits changes to the backend calendar of the component. - **/ -static void -commit_component_changes (ECalModelComponent *comp_data) -{ - GError *error = NULL; - - g_return_if_fail (comp_data != NULL); - - /* FIXME ask about mod type */ - e_cal_client_modify_object_sync ( - comp_data->client, comp_data->icalcomp, - CALOBJ_MOD_ALL, NULL, &error); - - if (error != NULL) { - g_warning ( - G_STRLOC ": Could not modify the object! %s", - error->message); - - /* FIXME Show error dialog */ - g_error_free (error); - } -} - -/** - * e_cal_model_tasks_update_due_tasks - */ void e_cal_model_tasks_update_due_tasks (ECalModelTasks *model) { diff --git a/calendar/gui/e-cal-model.c b/calendar/gui/e-cal-model.c index 16c968d704..288a896f9d 100644 --- a/calendar/gui/e-cal-model.c +++ b/calendar/gui/e-cal-model.c @@ -145,19 +145,12 @@ struct _ECalModelPrivate { GCancellable *loading_clients; }; -static gint ecm_column_count (ETableModel *etm); -static gint ecm_row_count (ETableModel *etm); -static gpointer ecm_value_at (ETableModel *etm, gint col, gint row); -static void ecm_set_value_at (ETableModel *etm, gint col, gint row, gconstpointer value); -static gboolean ecm_is_cell_editable (ETableModel *etm, gint col, gint row); -static void ecm_append_row (ETableModel *etm, ETableModel *source, gint row); -static gpointer ecm_duplicate_value (ETableModel *etm, gint col, gconstpointer value); -static void ecm_free_value (ETableModel *etm, gint col, gpointer value); -static gpointer ecm_initialize_value (ETableModel *etm, gint col); -static gboolean ecm_value_is_empty (ETableModel *etm, gint col, gconstpointer value); -static gchar *ecm_value_to_string (ETableModel *etm, gint col, gconstpointer value); - -static const gchar *ecm_get_color_for_component (ECalModel *model, ECalModelComponent *comp_data); +typedef struct { + const gchar *color; + GList *uids; +} AssignedColorData; + +static const gchar *cal_model_get_color_for_component (ECalModel *model, ECalModelComponent *comp_data); static gboolean add_new_client (ECalModel *model, ECalClient *client, gboolean do_query); static void remove_client_objects (ECalModel *model, ClientData *client_data); @@ -415,6 +408,349 @@ cal_model_clients_remove (ECalModel *model, return removed; } +static gpointer +get_categories (ECalModelComponent *comp_data) +{ + if (!comp_data->priv->categories_str) { + icalproperty *prop; + + comp_data->priv->categories_str = g_string_new (""); + + for (prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_CATEGORIES_PROPERTY); + prop; + prop = icalcomponent_get_next_property (comp_data->icalcomp, ICAL_CATEGORIES_PROPERTY)) { + const gchar *categories = icalproperty_get_categories (prop); + if (!categories) + continue; + + if (comp_data->priv->categories_str->len) + g_string_append_c (comp_data->priv->categories_str, ','); + g_string_append (comp_data->priv->categories_str, categories); + } + } + + return comp_data->priv->categories_str->str; +} + +static gchar * +get_classification (ECalModelComponent *comp_data) +{ + icalproperty *prop; + icalproperty_class class; + + prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_CLASS_PROPERTY); + + if (!prop) + return _("Public"); + + class = icalproperty_get_class (prop); + + switch (class) + { + case ICAL_CLASS_PUBLIC: + return _("Public"); + case ICAL_CLASS_PRIVATE: + return _("Private"); + case ICAL_CLASS_CONFIDENTIAL: + return _("Confidential"); + default: + return _("Unknown"); + } +} + +static const gchar * +get_color (ECalModel *model, + ECalModelComponent *comp_data) +{ + g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL); + + return e_cal_model_get_color_for_component (model, comp_data); +} + +static gpointer +get_description (ECalModelComponent *comp_data) +{ + icalproperty *prop; + static GString *str = NULL; + + if (str) { + g_string_free (str, TRUE); + str = NULL; + } + + prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DESCRIPTION_PROPERTY); + if (prop) { + str = g_string_new (NULL); + do { + str = g_string_append (str, icalproperty_get_description (prop)); + } while ((prop = icalcomponent_get_next_property (comp_data->icalcomp, ICAL_DESCRIPTION_PROPERTY))); + + return str->str; + } + + return (gpointer) ""; +} + +static ECellDateEditValue * +get_dtstart (ECalModel *model, + ECalModelComponent *comp_data) +{ + ECalModelPrivate *priv; + struct icaltimetype tt_start; + + priv = model->priv; + + if (!comp_data->dtstart) { + icalproperty *prop; + icaltimezone *zone; + gboolean got_zone = FALSE; + + prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DTSTART_PROPERTY); + if (!prop) + return NULL; + + tt_start = icalproperty_get_dtstart (prop); + + if (icaltime_get_tzid (tt_start) + && e_cal_client_get_timezone_sync (comp_data->client, icaltime_get_tzid (tt_start), &zone, NULL, NULL)) + got_zone = TRUE; + + if (e_cal_model_get_flags (model) & E_CAL_MODEL_FLAGS_EXPAND_RECURRENCES) { + if (got_zone) { + tt_start = icaltime_from_timet_with_zone (comp_data->instance_start, tt_start.is_date, zone); + if (priv->zone) + icaltimezone_convert_time (&tt_start, zone, priv->zone); + } else + if (priv->zone) + tt_start = icaltime_from_timet_with_zone (comp_data->instance_start, tt_start.is_date, priv->zone); + } + + if (!icaltime_is_valid_time (tt_start) || icaltime_is_null_time (tt_start)) + return NULL; + + comp_data->dtstart = g_new0 (ECellDateEditValue, 1); + comp_data->dtstart->tt = tt_start; + + if (got_zone) + comp_data->dtstart->zone = zone; + else + comp_data->dtstart->zone = NULL; + } + + return comp_data->dtstart; +} + +static ECellDateEditValue * +get_datetime_from_utc (ECalModel *model, + ECalModelComponent *comp_data, + icalproperty_kind propkind, + struct icaltimetype (*get_value) (const icalproperty *prop), + ECellDateEditValue **buffer) +{ + ECalModelPrivate *priv; + struct icaltimetype tt_value; + icalproperty *prop; + ECellDateEditValue *res; + + g_return_val_if_fail (buffer!= NULL, NULL); + + if (*buffer) + return *buffer; + + priv = model->priv; + + prop = icalcomponent_get_first_property (comp_data->icalcomp, propkind); + if (!prop) + return NULL; + + tt_value = get_value (prop); + + /* these are always in UTC, thus convert to default zone, if any and done */ + if (priv->zone) + icaltimezone_convert_time (&tt_value, icaltimezone_get_utc_timezone (), priv->zone); + + if (!icaltime_is_valid_time (tt_value) || icaltime_is_null_time (tt_value)) + return NULL; + + res = g_new0 (ECellDateEditValue, 1); + res->tt = tt_value; + res->zone = NULL; + + *buffer = res; + + return res; +} + +static gpointer +get_summary (ECalModelComponent *comp_data) +{ + icalproperty *prop; + + prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_SUMMARY_PROPERTY); + if (prop) + return (gpointer) icalproperty_get_summary (prop); + + return (gpointer) ""; +} + +static gchar * +get_uid (ECalModelComponent *comp_data) +{ + return (gchar *) icalcomponent_get_uid (comp_data->icalcomp); +} + +static void +set_categories (ECalModelComponent *comp_data, + const gchar *value) +{ + icalproperty *prop; + + /* remove all categories first */ + prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_CATEGORIES_PROPERTY); + while (prop) { + icalproperty *to_remove = prop; + prop = icalcomponent_get_next_property (comp_data->icalcomp, ICAL_CATEGORIES_PROPERTY); + + icalcomponent_remove_property (comp_data->icalcomp, to_remove); + icalproperty_free (to_remove); + } + + if (comp_data->priv->categories_str) + g_string_free (comp_data->priv->categories_str, TRUE); + comp_data->priv->categories_str = NULL; + + /* then set a new value; no need to populate categories_str, + * it'll be populated on demand (in the get_categories() function) + */ + if (value && *value) { + prop = icalproperty_new_categories (value); + icalcomponent_add_property (comp_data->icalcomp, prop); + } +} + +static void +set_classification (ECalModelComponent *comp_data, + const gchar *value) +{ + icalproperty *prop; + + prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_CLASS_PROPERTY); + if (!value || !(*value)) { + if (prop) { + icalcomponent_remove_property (comp_data->icalcomp, prop); + icalproperty_free (prop); + } + } else { + icalproperty_class ical_class; + + if (!g_ascii_strcasecmp (value, "PUBLIC")) + ical_class = ICAL_CLASS_PUBLIC; + else if (!g_ascii_strcasecmp (value, "PRIVATE")) + ical_class = ICAL_CLASS_PRIVATE; + else if (!g_ascii_strcasecmp (value, "CONFIDENTIAL")) + ical_class = ICAL_CLASS_CONFIDENTIAL; + else + ical_class = ICAL_CLASS_NONE; + + if (!prop) { + prop = icalproperty_new_class (ical_class); + icalcomponent_add_property (comp_data->icalcomp, prop); + } else + icalproperty_set_class (prop, ical_class); + } +} + +static void +set_description (ECalModelComponent *comp_data, + const gchar *value) +{ + icalproperty *prop; + + /* remove old description(s) */ + prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DESCRIPTION_PROPERTY); + while (prop) { + icalproperty *next; + + next = icalcomponent_get_next_property (comp_data->icalcomp, ICAL_DESCRIPTION_PROPERTY); + + icalcomponent_remove_property (comp_data->icalcomp, prop); + icalproperty_free (prop); + + prop = next; + } + + /* now add the new description */ + if (!value || !(*value)) + return; + + prop = icalproperty_new_description (value); + icalcomponent_add_property (comp_data->icalcomp, prop); +} + +static void +set_dtstart (ECalModel *model, + ECalModelComponent *comp_data, + gconstpointer value) +{ + e_cal_model_update_comp_time ( + model, comp_data, value, + ICAL_DTSTART_PROPERTY, + icalproperty_set_dtstart, + icalproperty_new_dtstart); +} + +static void +set_summary (ECalModelComponent *comp_data, + const gchar *value) +{ + icalproperty *prop; + + prop = icalcomponent_get_first_property ( + comp_data->icalcomp, ICAL_SUMMARY_PROPERTY); + + if (string_is_empty (value)) { + if (prop) { + icalcomponent_remove_property (comp_data->icalcomp, prop); + icalproperty_free (prop); + } + } else { + if (prop) + icalproperty_set_summary (prop, value); + else { + prop = icalproperty_new_summary (value); + icalcomponent_add_property (comp_data->icalcomp, prop); + } + } +} + +static void +datetime_to_zone (ECalClient *client, + struct icaltimetype *tt, + icaltimezone *tt_zone, + const gchar *tzid) +{ + icaltimezone *from, *to; + const gchar *tt_tzid = NULL; + + g_return_if_fail (tt != NULL); + + if (tt_zone) + tt_tzid = icaltimezone_get_tzid (tt_zone); + + if (tt_tzid == NULL || tzid == NULL || + tt_tzid == tzid || g_str_equal (tt_tzid, tzid)) + return; + + from = tt_zone; + to = icaltimezone_get_builtin_timezone_from_tzid (tzid); + if (!to) { + /* do not check failure here, maybe the zone is not available there */ + e_cal_client_get_timezone_sync (client, tzid, &to, NULL, NULL); + } + + icaltimezone_convert_time (tt, from, to); +} + static void cal_model_set_registry (ECalModel *model, ESourceRegistry *registry) @@ -800,6 +1136,538 @@ cal_model_finalize (GObject *object) G_OBJECT_CLASS (e_cal_model_parent_class)->finalize (object); } +static const gchar * +cal_model_get_color_for_component (ECalModel *model, + ECalModelComponent *comp_data) +{ + ESource *source; + ESourceSelectable *extension; + const gchar *color_spec; + const gchar *extension_name; + const gchar *uid; + gint i, first_empty = 0; + + static AssignedColorData assigned_colors[] = { + { "#BECEDD", NULL }, /* 190 206 221 Blue */ + { "#E2F0EF", NULL }, /* 226 240 239 Light Blue */ + { "#C6E2B7", NULL }, /* 198 226 183 Green */ + { "#E2F0D3", NULL }, /* 226 240 211 Light Green */ + { "#E2D4B7", NULL }, /* 226 212 183 Khaki */ + { "#EAEAC1", NULL }, /* 234 234 193 Light Khaki */ + { "#F0B8B7", NULL }, /* 240 184 183 Pink */ + { "#FED4D3", NULL }, /* 254 212 211 Light Pink */ + { "#E2C6E1", NULL }, /* 226 198 225 Purple */ + { "#F0E2EF", NULL } /* 240 226 239 Light Purple */ + }; + + g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL); + + switch (e_cal_client_get_source_type (comp_data->client)) { + case E_CAL_CLIENT_SOURCE_TYPE_EVENTS: + extension_name = E_SOURCE_EXTENSION_CALENDAR; + break; + case E_CAL_CLIENT_SOURCE_TYPE_TASKS: + extension_name = E_SOURCE_EXTENSION_TASK_LIST; + break; + case E_CAL_CLIENT_SOURCE_TYPE_MEMOS: + extension_name = E_SOURCE_EXTENSION_MEMO_LIST; + break; + default: + g_return_val_if_reached (NULL); + } + + source = e_client_get_source (E_CLIENT (comp_data->client)); + extension = e_source_get_extension (source, extension_name); + color_spec = e_source_selectable_get_color (extension); + + if (color_spec != NULL) { + g_free (comp_data->color); + comp_data->color = g_strdup (color_spec); + return comp_data->color; + } + + uid = e_source_get_uid (source); + + for (i = 0; i < G_N_ELEMENTS (assigned_colors); i++) { + GList *l; + + if (assigned_colors[i].uids == NULL) { + first_empty = i; + continue; + } + + for (l = assigned_colors[i].uids; l != NULL; l = l->next) + if (g_strcmp0 (l->data, uid) == 0) + return assigned_colors[i].color; + } + + /* return the first unused color */ + assigned_colors[first_empty].uids = g_list_append ( + assigned_colors[first_empty].uids, g_strdup (uid)); + + return assigned_colors[first_empty].color; +} + +static gint +cal_model_column_count (ETableModel *etm) +{ + return E_CAL_MODEL_FIELD_LAST; +} + +static gint +cal_model_row_count (ETableModel *etm) +{ + ECalModelPrivate *priv; + ECalModel *model = (ECalModel *) etm; + + g_return_val_if_fail (E_IS_CAL_MODEL (model), -1); + + priv = model->priv; + + return priv->objects->len; +} + +static void +cal_model_append_row (ETableModel *etm, + ETableModel *source, + gint row) +{ + ECalModelClass *model_class; + ECalModelComponent *comp_data; + ECalModel *model = (ECalModel *) etm; + gchar *uid = NULL; + GError *error = NULL; + + g_return_if_fail (E_IS_CAL_MODEL (model)); + g_return_if_fail (E_IS_TABLE_MODEL (source)); + + comp_data = g_object_new (E_TYPE_CAL_MODEL_COMPONENT, NULL); + + comp_data->client = e_cal_model_ref_default_client (model); + + if (comp_data->client == NULL) { + g_object_unref (comp_data); + return; + } + + comp_data->icalcomp = e_cal_model_create_component_with_defaults (model, FALSE); + + /* set values for our fields */ + set_categories (comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_CATEGORIES, row)); + set_classification (comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_CLASSIFICATION, row)); + set_description (comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_DESCRIPTION, row)); + set_summary (comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_SUMMARY, row)); + + if (e_table_model_value_at (source, E_CAL_MODEL_FIELD_DTSTART, row)) { + set_dtstart (model, comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_DTSTART, row)); + } else if (model->priv->get_default_time) { + time_t tt = model->priv->get_default_time (model, model->priv->get_default_time_user_data); + + if (tt > 0) { + struct icaltimetype itt = icaltime_from_timet_with_zone (tt, FALSE, e_cal_model_get_timezone (model)); + icalproperty *prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DTSTART_PROPERTY); + + if (prop) { + icalproperty_set_dtstart (prop, itt); + } else { + prop = icalproperty_new_dtstart (itt); + icalcomponent_add_property (comp_data->icalcomp, prop); + } + } + } + + /* call the class' method for filling the component */ + model_class = (ECalModelClass *) G_OBJECT_GET_CLASS (model); + if (model_class->fill_component_from_model != NULL) { + model_class->fill_component_from_model (model, comp_data, source, row); + } + + e_cal_client_create_object_sync ( + comp_data->client, comp_data->icalcomp, &uid, NULL, &error); + + if (error != NULL) { + g_warning ( + G_STRLOC ": Could not create the object! %s", + error->message); + + /* FIXME: show error dialog */ + g_error_free (error); + } else { + if (uid) + icalcomponent_set_uid (comp_data->icalcomp, uid); + + g_signal_emit (model, signals[ROW_APPENDED], 0); + } + + g_free (uid); + g_object_unref (comp_data); +} + +static gpointer +cal_model_value_at (ETableModel *etm, + gint col, + gint row) +{ + ECalModelPrivate *priv; + ECalModelComponent *comp_data; + ECalModel *model = (ECalModel *) etm; + ESourceRegistry *registry; + + g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL); + + priv = model->priv; + + registry = e_cal_model_get_registry (model); + + g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, NULL); + g_return_val_if_fail (row >= 0 && row < priv->objects->len, NULL); + + comp_data = g_ptr_array_index (priv->objects, row); + g_return_val_if_fail (comp_data != NULL, NULL); + g_return_val_if_fail (comp_data->icalcomp != NULL, NULL); + + switch (col) { + case E_CAL_MODEL_FIELD_CATEGORIES : + return get_categories (comp_data); + case E_CAL_MODEL_FIELD_CLASSIFICATION : + return get_classification (comp_data); + case E_CAL_MODEL_FIELD_COLOR : + return (gpointer) get_color (model, comp_data); + case E_CAL_MODEL_FIELD_COMPONENT : + return comp_data->icalcomp; + case E_CAL_MODEL_FIELD_DESCRIPTION : + return get_description (comp_data); + case E_CAL_MODEL_FIELD_DTSTART : + return (gpointer) get_dtstart (model, comp_data); + case E_CAL_MODEL_FIELD_CREATED : + return (gpointer) get_datetime_from_utc ( + model, comp_data, ICAL_CREATED_PROPERTY, + icalproperty_get_created, &comp_data->created); + case E_CAL_MODEL_FIELD_LASTMODIFIED : + return (gpointer) get_datetime_from_utc ( + model, comp_data, ICAL_LASTMODIFIED_PROPERTY, + icalproperty_get_lastmodified, &comp_data->lastmodified); + case E_CAL_MODEL_FIELD_HAS_ALARMS : + return GINT_TO_POINTER ( + icalcomponent_get_first_component ( + comp_data->icalcomp, + ICAL_VALARM_COMPONENT) != NULL); + case E_CAL_MODEL_FIELD_ICON : + { + ECalComponent *comp; + icalcomponent *icalcomp; + gint retval = 0; + + comp = e_cal_component_new (); + icalcomp = icalcomponent_new_clone (comp_data->icalcomp); + if (e_cal_component_set_icalcomponent (comp, icalcomp)) { + if (e_cal_component_get_vtype (comp) == E_CAL_COMPONENT_JOURNAL) { + g_object_unref (comp); + return GINT_TO_POINTER (retval); + } + + if (e_cal_component_has_recurrences (comp)) + retval = 1; + else if (itip_organizer_is_user (registry, comp, comp_data->client)) + retval = 3; + else { + GSList *attendees = NULL, *sl; + + e_cal_component_get_attendee_list (comp, &attendees); + for (sl = attendees; sl != NULL; sl = sl->next) { + ECalComponentAttendee *ca = sl->data; + const gchar *text; + + text = itip_strip_mailto (ca->value); + if (itip_address_is_user (registry, text)) { + if (ca->delto != NULL) + retval = 3; + else + retval = 2; + break; + } + } + + e_cal_component_free_attendee_list (attendees); + } + } else + icalcomponent_free (icalcomp); + + g_object_unref (comp); + + return GINT_TO_POINTER (retval); + } + case E_CAL_MODEL_FIELD_SUMMARY : + return get_summary (comp_data); + case E_CAL_MODEL_FIELD_UID : + return get_uid (comp_data); + } + + return (gpointer) ""; +} + +static void +cal_model_set_value_at (ETableModel *etm, + gint col, + gint row, + gconstpointer value) +{ + ECalModelPrivate *priv; + ECalModelComponent *comp_data; + ECalModel *model = (ECalModel *) etm; + GError *error = NULL; + + g_return_if_fail (E_IS_CAL_MODEL (model)); + + priv = model->priv; + + g_return_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST); + g_return_if_fail (row >= 0 && row < priv->objects->len); + + comp_data = g_ptr_array_index (priv->objects, row); + g_return_if_fail (comp_data != NULL); + + switch (col) { + case E_CAL_MODEL_FIELD_CATEGORIES : + set_categories (comp_data, value); + break; + case E_CAL_MODEL_FIELD_CLASSIFICATION : + set_classification (comp_data, value); + break; + case E_CAL_MODEL_FIELD_DESCRIPTION : + set_description (comp_data, value); + break; + case E_CAL_MODEL_FIELD_DTSTART : + set_dtstart (model, comp_data, value); + break; + case E_CAL_MODEL_FIELD_SUMMARY : + set_summary (comp_data, value); + break; + } + + /* FIXME ask about mod type */ + e_cal_client_modify_object_sync ( + comp_data->client, comp_data->icalcomp, + CALOBJ_MOD_ALL, NULL, &error); + + if (error != NULL) { + g_warning ( + G_STRLOC ": Could not modify the object! %s", + error->message); + + /* FIXME Show error dialog */ + g_error_free (error); + } +} + +static gboolean +cal_model_is_cell_editable (ETableModel *etm, + gint col, + gint row) +{ + ECalModelPrivate *priv; + ECalModel *model = (ECalModel *) etm; + + g_return_val_if_fail (E_IS_CAL_MODEL (model), FALSE); + + priv = model->priv; + + g_return_val_if_fail (col >= 0 && col <= E_CAL_MODEL_FIELD_LAST, FALSE); + g_return_val_if_fail (row >= -1 || (row >= 0 && row < priv->objects->len), FALSE); + + if (!e_cal_model_test_row_editable (E_CAL_MODEL (etm), row)) + return FALSE; + + switch (col) { + case E_CAL_MODEL_FIELD_CATEGORIES : + case E_CAL_MODEL_FIELD_CLASSIFICATION : + case E_CAL_MODEL_FIELD_DESCRIPTION : + case E_CAL_MODEL_FIELD_DTSTART : + case E_CAL_MODEL_FIELD_SUMMARY : + return TRUE; + } + + return FALSE; +} + +static gpointer +cal_model_duplicate_value (ETableModel *etm, + gint col, + gconstpointer value) +{ + g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, NULL); + + switch (col) { + case E_CAL_MODEL_FIELD_CATEGORIES : + case E_CAL_MODEL_FIELD_CLASSIFICATION : + case E_CAL_MODEL_FIELD_DESCRIPTION : + case E_CAL_MODEL_FIELD_SUMMARY : + return g_strdup (value); + case E_CAL_MODEL_FIELD_HAS_ALARMS : + case E_CAL_MODEL_FIELD_ICON : + case E_CAL_MODEL_FIELD_COLOR : + return (gpointer) value; + case E_CAL_MODEL_FIELD_COMPONENT : + return icalcomponent_new_clone ((icalcomponent *) value); + case E_CAL_MODEL_FIELD_DTSTART : + case E_CAL_MODEL_FIELD_CREATED : + case E_CAL_MODEL_FIELD_LASTMODIFIED : + if (value) { + ECellDateEditValue *dv, *orig_dv; + + orig_dv = (ECellDateEditValue *) value; + dv = g_new0 (ECellDateEditValue, 1); + *dv = *orig_dv; + + return dv; + } + break; + } + + return NULL; +} + +static void +cal_model_free_value (ETableModel *etm, + gint col, + gpointer value) +{ + g_return_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST); + + switch (col) { + case E_CAL_MODEL_FIELD_CATEGORIES : + case E_CAL_MODEL_FIELD_DESCRIPTION : + case E_CAL_MODEL_FIELD_SUMMARY : + if (value) + g_free (value); + break; + case E_CAL_MODEL_FIELD_CLASSIFICATION : + case E_CAL_MODEL_FIELD_HAS_ALARMS : + case E_CAL_MODEL_FIELD_ICON : + case E_CAL_MODEL_FIELD_COLOR : + break; + case E_CAL_MODEL_FIELD_DTSTART : + case E_CAL_MODEL_FIELD_CREATED : + case E_CAL_MODEL_FIELD_LASTMODIFIED : + if (value) + g_free (value); + break; + case E_CAL_MODEL_FIELD_COMPONENT : + if (value) + icalcomponent_free ((icalcomponent *) value); + break; + } +} + +static gpointer +cal_model_initialize_value (ETableModel *etm, + gint col) +{ + ECalModelPrivate *priv; + ECalModel *model = (ECalModel *) etm; + + g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL); + g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, NULL); + + priv = model->priv; + + switch (col) { + case E_CAL_MODEL_FIELD_CATEGORIES : + return g_strdup (priv->default_category ? priv->default_category:""); + case E_CAL_MODEL_FIELD_CLASSIFICATION : + case E_CAL_MODEL_FIELD_DESCRIPTION : + case E_CAL_MODEL_FIELD_SUMMARY : + return g_strdup (""); + case E_CAL_MODEL_FIELD_DTSTART : + case E_CAL_MODEL_FIELD_CREATED : + case E_CAL_MODEL_FIELD_LASTMODIFIED : + case E_CAL_MODEL_FIELD_HAS_ALARMS : + case E_CAL_MODEL_FIELD_ICON : + case E_CAL_MODEL_FIELD_COLOR : + case E_CAL_MODEL_FIELD_COMPONENT : + return NULL; + } + + return NULL; +} + +static gboolean +cal_model_value_is_empty (ETableModel *etm, + gint col, + gconstpointer value) +{ + ECalModelPrivate *priv; + ECalModel *model = (ECalModel *) etm; + + g_return_val_if_fail (E_IS_CAL_MODEL (model), TRUE); + g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, TRUE); + + priv = model->priv; + + switch (col) { + case E_CAL_MODEL_FIELD_CATEGORIES : + /* This could be a hack or not. If the categories field only + * contains the default category, then it possibly means that + * the user has not entered anything at all in the click-to-add; + * the category is in the value because we put it there in + * ecm_initialize_value(). + */ + if (priv->default_category && value && strcmp (priv->default_category, value) == 0) + return TRUE; + else + return string_is_empty (value); + case E_CAL_MODEL_FIELD_CLASSIFICATION : + case E_CAL_MODEL_FIELD_DESCRIPTION : + case E_CAL_MODEL_FIELD_SUMMARY : + return string_is_empty (value); + case E_CAL_MODEL_FIELD_DTSTART : + case E_CAL_MODEL_FIELD_CREATED : + case E_CAL_MODEL_FIELD_LASTMODIFIED : + return value ? FALSE : TRUE; + case E_CAL_MODEL_FIELD_HAS_ALARMS : + case E_CAL_MODEL_FIELD_ICON : + case E_CAL_MODEL_FIELD_COLOR : + case E_CAL_MODEL_FIELD_COMPONENT : + return TRUE; + } + + return TRUE; +} + +static gchar * +cal_model_value_to_string (ETableModel *etm, + gint col, + gconstpointer value) +{ + g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, g_strdup ("")); + + switch (col) { + case E_CAL_MODEL_FIELD_CATEGORIES : + case E_CAL_MODEL_FIELD_CLASSIFICATION : + case E_CAL_MODEL_FIELD_DESCRIPTION : + case E_CAL_MODEL_FIELD_SUMMARY : + return g_strdup (value); + case E_CAL_MODEL_FIELD_DTSTART : + case E_CAL_MODEL_FIELD_CREATED : + case E_CAL_MODEL_FIELD_LASTMODIFIED : + return e_cal_model_date_value_to_string (E_CAL_MODEL (etm), value); + case E_CAL_MODEL_FIELD_ICON : + if (GPOINTER_TO_INT (value) == 0) + return g_strdup (_("Normal")); + else if (GPOINTER_TO_INT (value) == 1) + return g_strdup (_("Recurring")); + else + return g_strdup (_("Assigned")); + case E_CAL_MODEL_FIELD_HAS_ALARMS : + return g_strdup (value ? _("Yes") : _("No")); + case E_CAL_MODEL_FIELD_COLOR : + case E_CAL_MODEL_FIELD_COMPONENT : + return g_strdup (""); + } + + return g_strdup (""); +} + static void e_cal_model_class_init (ECalModelClass *class) { @@ -815,22 +1683,22 @@ e_cal_model_class_init (ECalModelClass *class) object_class->dispose = cal_model_dispose; object_class->finalize = cal_model_finalize; - etm_class = E_TABLE_MODEL_CLASS (class); - etm_class->column_count = ecm_column_count; - etm_class->row_count = ecm_row_count; - etm_class->value_at = ecm_value_at; - etm_class->set_value_at = ecm_set_value_at; - etm_class->is_cell_editable = ecm_is_cell_editable; - etm_class->append_row = ecm_append_row; - etm_class->duplicate_value = ecm_duplicate_value; - etm_class->free_value = ecm_free_value; - etm_class->initialize_value = ecm_initialize_value; - etm_class->value_is_empty = ecm_value_is_empty; - etm_class->value_to_string = ecm_value_to_string; - - class->get_color_for_component = ecm_get_color_for_component; + class->get_color_for_component = cal_model_get_color_for_component; class->fill_component_from_model = NULL; + etm_class = E_TABLE_MODEL_CLASS (class); + etm_class->column_count = cal_model_column_count; + etm_class->row_count = cal_model_row_count; + etm_class->append_row = cal_model_append_row; + etm_class->value_at = cal_model_value_at; + etm_class->set_value_at = cal_model_set_value_at; + etm_class->is_cell_editable = cal_model_is_cell_editable; + etm_class->duplicate_value = cal_model_duplicate_value; + etm_class->free_value = cal_model_free_value; + etm_class->initialize_value = cal_model_initialize_value; + etm_class->value_is_empty = cal_model_value_is_empty; + etm_class->value_to_string = cal_model_value_to_string; + g_object_class_install_property ( object_class, PROP_COMPRESS_WEEKEND, @@ -1174,437 +2042,6 @@ e_cal_model_init (ECalModel *model) model->priv->loading_clients = g_cancellable_new (); } -/* ETableModel methods */ - -static gint -ecm_column_count (ETableModel *etm) -{ - return E_CAL_MODEL_FIELD_LAST; -} - -static gint -ecm_row_count (ETableModel *etm) -{ - ECalModelPrivate *priv; - ECalModel *model = (ECalModel *) etm; - - g_return_val_if_fail (E_IS_CAL_MODEL (model), -1); - - priv = model->priv; - - return priv->objects->len; -} - -static gpointer -get_categories (ECalModelComponent *comp_data) -{ - if (!comp_data->priv->categories_str) { - icalproperty *prop; - - comp_data->priv->categories_str = g_string_new (""); - - for (prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_CATEGORIES_PROPERTY); - prop; - prop = icalcomponent_get_next_property (comp_data->icalcomp, ICAL_CATEGORIES_PROPERTY)) { - const gchar *categories = icalproperty_get_categories (prop); - if (!categories) - continue; - - if (comp_data->priv->categories_str->len) - g_string_append_c (comp_data->priv->categories_str, ','); - g_string_append (comp_data->priv->categories_str, categories); - } - } - - return comp_data->priv->categories_str->str; -} - -static gchar * -get_classification (ECalModelComponent *comp_data) -{ - icalproperty *prop; - icalproperty_class class; - - prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_CLASS_PROPERTY); - - if (!prop) - return _("Public"); - - class = icalproperty_get_class (prop); - - switch (class) - { - case ICAL_CLASS_PUBLIC: - return _("Public"); - case ICAL_CLASS_PRIVATE: - return _("Private"); - case ICAL_CLASS_CONFIDENTIAL: - return _("Confidential"); - default: - return _("Unknown"); - } -} - -static const gchar * -get_color (ECalModel *model, - ECalModelComponent *comp_data) -{ - g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL); - - return e_cal_model_get_color_for_component (model, comp_data); -} - -static gpointer -get_description (ECalModelComponent *comp_data) -{ - icalproperty *prop; - static GString *str = NULL; - - if (str) { - g_string_free (str, TRUE); - str = NULL; - } - - prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DESCRIPTION_PROPERTY); - if (prop) { - str = g_string_new (NULL); - do { - str = g_string_append (str, icalproperty_get_description (prop)); - } while ((prop = icalcomponent_get_next_property (comp_data->icalcomp, ICAL_DESCRIPTION_PROPERTY))); - - return str->str; - } - - return (gpointer) ""; -} - -static ECellDateEditValue * -get_dtstart (ECalModel *model, - ECalModelComponent *comp_data) -{ - ECalModelPrivate *priv; - struct icaltimetype tt_start; - - priv = model->priv; - - if (!comp_data->dtstart) { - icalproperty *prop; - icaltimezone *zone; - gboolean got_zone = FALSE; - - prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DTSTART_PROPERTY); - if (!prop) - return NULL; - - tt_start = icalproperty_get_dtstart (prop); - - if (icaltime_get_tzid (tt_start) - && e_cal_client_get_timezone_sync (comp_data->client, icaltime_get_tzid (tt_start), &zone, NULL, NULL)) - got_zone = TRUE; - - if (e_cal_model_get_flags (model) & E_CAL_MODEL_FLAGS_EXPAND_RECURRENCES) { - if (got_zone) { - tt_start = icaltime_from_timet_with_zone (comp_data->instance_start, tt_start.is_date, zone); - if (priv->zone) - icaltimezone_convert_time (&tt_start, zone, priv->zone); - } else - if (priv->zone) - tt_start = icaltime_from_timet_with_zone (comp_data->instance_start, tt_start.is_date, priv->zone); - } - - if (!icaltime_is_valid_time (tt_start) || icaltime_is_null_time (tt_start)) - return NULL; - - comp_data->dtstart = g_new0 (ECellDateEditValue, 1); - comp_data->dtstart->tt = tt_start; - - if (got_zone) - comp_data->dtstart->zone = zone; - else - comp_data->dtstart->zone = NULL; - } - - return comp_data->dtstart; -} - -static ECellDateEditValue * -get_datetime_from_utc (ECalModel *model, - ECalModelComponent *comp_data, - icalproperty_kind propkind, - struct icaltimetype (*get_value) (const icalproperty *prop), - ECellDateEditValue **buffer) -{ - ECalModelPrivate *priv; - struct icaltimetype tt_value; - icalproperty *prop; - ECellDateEditValue *res; - - g_return_val_if_fail (buffer!= NULL, NULL); - - if (*buffer) - return *buffer; - - priv = model->priv; - - prop = icalcomponent_get_first_property (comp_data->icalcomp, propkind); - if (!prop) - return NULL; - - tt_value = get_value (prop); - - /* these are always in UTC, thus convert to default zone, if any and done */ - if (priv->zone) - icaltimezone_convert_time (&tt_value, icaltimezone_get_utc_timezone (), priv->zone); - - if (!icaltime_is_valid_time (tt_value) || icaltime_is_null_time (tt_value)) - return NULL; - - res = g_new0 (ECellDateEditValue, 1); - res->tt = tt_value; - res->zone = NULL; - - *buffer = res; - - return res; -} - -static gpointer -get_summary (ECalModelComponent *comp_data) -{ - icalproperty *prop; - - prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_SUMMARY_PROPERTY); - if (prop) - return (gpointer) icalproperty_get_summary (prop); - - return (gpointer) ""; -} - -static gchar * -get_uid (ECalModelComponent *comp_data) -{ - return (gchar *) icalcomponent_get_uid (comp_data->icalcomp); -} - -static gpointer -ecm_value_at (ETableModel *etm, - gint col, - gint row) -{ - ECalModelPrivate *priv; - ECalModelComponent *comp_data; - ECalModel *model = (ECalModel *) etm; - ESourceRegistry *registry; - - g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL); - - priv = model->priv; - - registry = e_cal_model_get_registry (model); - - g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, NULL); - g_return_val_if_fail (row >= 0 && row < priv->objects->len, NULL); - - comp_data = g_ptr_array_index (priv->objects, row); - g_return_val_if_fail (comp_data != NULL, NULL); - g_return_val_if_fail (comp_data->icalcomp != NULL, NULL); - - switch (col) { - case E_CAL_MODEL_FIELD_CATEGORIES : - return get_categories (comp_data); - case E_CAL_MODEL_FIELD_CLASSIFICATION : - return get_classification (comp_data); - case E_CAL_MODEL_FIELD_COLOR : - return (gpointer) get_color (model, comp_data); - case E_CAL_MODEL_FIELD_COMPONENT : - return comp_data->icalcomp; - case E_CAL_MODEL_FIELD_DESCRIPTION : - return get_description (comp_data); - case E_CAL_MODEL_FIELD_DTSTART : - return (gpointer) get_dtstart (model, comp_data); - case E_CAL_MODEL_FIELD_CREATED : - return (gpointer) get_datetime_from_utc ( - model, comp_data, ICAL_CREATED_PROPERTY, - icalproperty_get_created, &comp_data->created); - case E_CAL_MODEL_FIELD_LASTMODIFIED : - return (gpointer) get_datetime_from_utc ( - model, comp_data, ICAL_LASTMODIFIED_PROPERTY, - icalproperty_get_lastmodified, &comp_data->lastmodified); - case E_CAL_MODEL_FIELD_HAS_ALARMS : - return GINT_TO_POINTER ( - icalcomponent_get_first_component ( - comp_data->icalcomp, - ICAL_VALARM_COMPONENT) != NULL); - case E_CAL_MODEL_FIELD_ICON : - { - ECalComponent *comp; - icalcomponent *icalcomp; - gint retval = 0; - - comp = e_cal_component_new (); - icalcomp = icalcomponent_new_clone (comp_data->icalcomp); - if (e_cal_component_set_icalcomponent (comp, icalcomp)) { - if (e_cal_component_get_vtype (comp) == E_CAL_COMPONENT_JOURNAL) { - g_object_unref (comp); - return GINT_TO_POINTER (retval); - } - - if (e_cal_component_has_recurrences (comp)) - retval = 1; - else if (itip_organizer_is_user (registry, comp, comp_data->client)) - retval = 3; - else { - GSList *attendees = NULL, *sl; - - e_cal_component_get_attendee_list (comp, &attendees); - for (sl = attendees; sl != NULL; sl = sl->next) { - ECalComponentAttendee *ca = sl->data; - const gchar *text; - - text = itip_strip_mailto (ca->value); - if (itip_address_is_user (registry, text)) { - if (ca->delto != NULL) - retval = 3; - else - retval = 2; - break; - } - } - - e_cal_component_free_attendee_list (attendees); - } - } else - icalcomponent_free (icalcomp); - - g_object_unref (comp); - - return GINT_TO_POINTER (retval); - } - case E_CAL_MODEL_FIELD_SUMMARY : - return get_summary (comp_data); - case E_CAL_MODEL_FIELD_UID : - return get_uid (comp_data); - } - - return (gpointer) ""; -} - -static void -set_categories (ECalModelComponent *comp_data, - const gchar *value) -{ - icalproperty *prop; - - /* remove all categories first */ - prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_CATEGORIES_PROPERTY); - while (prop) { - icalproperty *to_remove = prop; - prop = icalcomponent_get_next_property (comp_data->icalcomp, ICAL_CATEGORIES_PROPERTY); - - icalcomponent_remove_property (comp_data->icalcomp, to_remove); - icalproperty_free (to_remove); - } - - if (comp_data->priv->categories_str) - g_string_free (comp_data->priv->categories_str, TRUE); - comp_data->priv->categories_str = NULL; - - /* then set a new value; no need to populate categories_str, - * it'll be populated on demand (in the get_categories() function) - */ - if (value && *value) { - prop = icalproperty_new_categories (value); - icalcomponent_add_property (comp_data->icalcomp, prop); - } -} - -static void -set_classification (ECalModelComponent *comp_data, - const gchar *value) -{ - icalproperty *prop; - - prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_CLASS_PROPERTY); - if (!value || !(*value)) { - if (prop) { - icalcomponent_remove_property (comp_data->icalcomp, prop); - icalproperty_free (prop); - } - } else { - icalproperty_class ical_class; - - if (!g_ascii_strcasecmp (value, "PUBLIC")) - ical_class = ICAL_CLASS_PUBLIC; - else if (!g_ascii_strcasecmp (value, "PRIVATE")) - ical_class = ICAL_CLASS_PRIVATE; - else if (!g_ascii_strcasecmp (value, "CONFIDENTIAL")) - ical_class = ICAL_CLASS_CONFIDENTIAL; - else - ical_class = ICAL_CLASS_NONE; - - if (!prop) { - prop = icalproperty_new_class (ical_class); - icalcomponent_add_property (comp_data->icalcomp, prop); - } else - icalproperty_set_class (prop, ical_class); - } -} - -static void -set_description (ECalModelComponent *comp_data, - const gchar *value) -{ - icalproperty *prop; - - /* remove old description(s) */ - prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DESCRIPTION_PROPERTY); - while (prop) { - icalproperty *next; - - next = icalcomponent_get_next_property (comp_data->icalcomp, ICAL_DESCRIPTION_PROPERTY); - - icalcomponent_remove_property (comp_data->icalcomp, prop); - icalproperty_free (prop); - - prop = next; - } - - /* now add the new description */ - if (!value || !(*value)) - return; - - prop = icalproperty_new_description (value); - icalcomponent_add_property (comp_data->icalcomp, prop); -} - -static void -datetime_to_zone (ECalClient *client, - struct icaltimetype *tt, - icaltimezone *tt_zone, - const gchar *tzid) -{ - icaltimezone *from, *to; - const gchar *tt_tzid = NULL; - - g_return_if_fail (tt != NULL); - - if (tt_zone) - tt_tzid = icaltimezone_get_tzid (tt_zone); - - if (tt_tzid == NULL || tzid == NULL || - tt_tzid == tzid || g_str_equal (tt_tzid, tzid)) - return; - - from = tt_zone; - to = icaltimezone_get_builtin_timezone_from_tzid (tzid); - if (!to) { - /* do not check failure here, maybe the zone is not available there */ - e_cal_client_get_timezone_sync (client, tzid, &to, NULL, NULL); - } - - icaltimezone_convert_time (tt, from, to); -} - /* updates time in a component, and keeps the timezone used in it, if exists */ void e_cal_model_update_comp_time (ECalModel *model, @@ -1669,96 +2106,6 @@ e_cal_model_update_comp_time (ECalModel *model, } } -static void -set_dtstart (ECalModel *model, - ECalModelComponent *comp_data, - gconstpointer value) -{ - e_cal_model_update_comp_time ( - model, comp_data, value, - ICAL_DTSTART_PROPERTY, - icalproperty_set_dtstart, - icalproperty_new_dtstart); -} - -static void -set_summary (ECalModelComponent *comp_data, - const gchar *value) -{ - icalproperty *prop; - - prop = icalcomponent_get_first_property ( - comp_data->icalcomp, ICAL_SUMMARY_PROPERTY); - - if (string_is_empty (value)) { - if (prop) { - icalcomponent_remove_property (comp_data->icalcomp, prop); - icalproperty_free (prop); - } - } else { - if (prop) - icalproperty_set_summary (prop, value); - else { - prop = icalproperty_new_summary (value); - icalcomponent_add_property (comp_data->icalcomp, prop); - } - } -} - -static void -ecm_set_value_at (ETableModel *etm, - gint col, - gint row, - gconstpointer value) -{ - ECalModelPrivate *priv; - ECalModelComponent *comp_data; - ECalModel *model = (ECalModel *) etm; - GError *error = NULL; - - g_return_if_fail (E_IS_CAL_MODEL (model)); - - priv = model->priv; - - g_return_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST); - g_return_if_fail (row >= 0 && row < priv->objects->len); - - comp_data = g_ptr_array_index (priv->objects, row); - g_return_if_fail (comp_data != NULL); - - switch (col) { - case E_CAL_MODEL_FIELD_CATEGORIES : - set_categories (comp_data, value); - break; - case E_CAL_MODEL_FIELD_CLASSIFICATION : - set_classification (comp_data, value); - break; - case E_CAL_MODEL_FIELD_DESCRIPTION : - set_description (comp_data, value); - break; - case E_CAL_MODEL_FIELD_DTSTART : - set_dtstart (model, comp_data, value); - break; - case E_CAL_MODEL_FIELD_SUMMARY : - set_summary (comp_data, value); - break; - } - - /* FIXME ask about mod type */ - e_cal_client_modify_object_sync ( - comp_data->client, comp_data->icalcomp, - CALOBJ_MOD_ALL, NULL, &error); - - if (error != NULL) { - g_warning ( - G_STRLOC ": Could not modify the object! %s", - error->message); - - /* FIXME Show error dialog */ - g_error_free (error); - } -} - /** * e_cal_model_test_row_editable * @model: an #ECalModel @@ -1799,369 +2146,6 @@ e_cal_model_test_row_editable (ECalModel *model, return !readonly; } -static gboolean -ecm_is_cell_editable (ETableModel *etm, - gint col, - gint row) -{ - ECalModelPrivate *priv; - ECalModel *model = (ECalModel *) etm; - - g_return_val_if_fail (E_IS_CAL_MODEL (model), FALSE); - - priv = model->priv; - - g_return_val_if_fail (col >= 0 && col <= E_CAL_MODEL_FIELD_LAST, FALSE); - g_return_val_if_fail (row >= -1 || (row >= 0 && row < priv->objects->len), FALSE); - - if (!e_cal_model_test_row_editable (E_CAL_MODEL (etm), row)) - return FALSE; - - switch (col) { - case E_CAL_MODEL_FIELD_CATEGORIES : - case E_CAL_MODEL_FIELD_CLASSIFICATION : - case E_CAL_MODEL_FIELD_DESCRIPTION : - case E_CAL_MODEL_FIELD_DTSTART : - case E_CAL_MODEL_FIELD_SUMMARY : - return TRUE; - } - - return FALSE; -} - -static void -ecm_append_row (ETableModel *etm, - ETableModel *source, - gint row) -{ - ECalModelClass *model_class; - ECalModelComponent *comp_data; - ECalModel *model = (ECalModel *) etm; - gchar *uid = NULL; - GError *error = NULL; - - g_return_if_fail (E_IS_CAL_MODEL (model)); - g_return_if_fail (E_IS_TABLE_MODEL (source)); - - comp_data = g_object_new (E_TYPE_CAL_MODEL_COMPONENT, NULL); - - comp_data->client = e_cal_model_ref_default_client (model); - - if (comp_data->client == NULL) { - g_object_unref (comp_data); - return; - } - - comp_data->icalcomp = e_cal_model_create_component_with_defaults (model, FALSE); - - /* set values for our fields */ - set_categories (comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_CATEGORIES, row)); - set_classification (comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_CLASSIFICATION, row)); - set_description (comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_DESCRIPTION, row)); - set_summary (comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_SUMMARY, row)); - - if (e_table_model_value_at (source, E_CAL_MODEL_FIELD_DTSTART, row)) { - set_dtstart (model, comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_DTSTART, row)); - } else if (model->priv->get_default_time) { - time_t tt = model->priv->get_default_time (model, model->priv->get_default_time_user_data); - - if (tt > 0) { - struct icaltimetype itt = icaltime_from_timet_with_zone (tt, FALSE, e_cal_model_get_timezone (model)); - icalproperty *prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DTSTART_PROPERTY); - - if (prop) { - icalproperty_set_dtstart (prop, itt); - } else { - prop = icalproperty_new_dtstart (itt); - icalcomponent_add_property (comp_data->icalcomp, prop); - } - } - } - - /* call the class' method for filling the component */ - model_class = (ECalModelClass *) G_OBJECT_GET_CLASS (model); - if (model_class->fill_component_from_model != NULL) { - model_class->fill_component_from_model (model, comp_data, source, row); - } - - e_cal_client_create_object_sync ( - comp_data->client, comp_data->icalcomp, &uid, NULL, &error); - - if (error != NULL) { - g_warning ( - G_STRLOC ": Could not create the object! %s", - error->message); - - /* FIXME: show error dialog */ - g_error_free (error); - } else { - if (uid) - icalcomponent_set_uid (comp_data->icalcomp, uid); - - g_signal_emit (model, signals[ROW_APPENDED], 0); - } - - g_free (uid); - g_object_unref (comp_data); -} - -static gpointer -ecm_duplicate_value (ETableModel *etm, - gint col, - gconstpointer value) -{ - g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, NULL); - - switch (col) { - case E_CAL_MODEL_FIELD_CATEGORIES : - case E_CAL_MODEL_FIELD_CLASSIFICATION : - case E_CAL_MODEL_FIELD_DESCRIPTION : - case E_CAL_MODEL_FIELD_SUMMARY : - return g_strdup (value); - case E_CAL_MODEL_FIELD_HAS_ALARMS : - case E_CAL_MODEL_FIELD_ICON : - case E_CAL_MODEL_FIELD_COLOR : - return (gpointer) value; - case E_CAL_MODEL_FIELD_COMPONENT : - return icalcomponent_new_clone ((icalcomponent *) value); - case E_CAL_MODEL_FIELD_DTSTART : - case E_CAL_MODEL_FIELD_CREATED : - case E_CAL_MODEL_FIELD_LASTMODIFIED : - if (value) { - ECellDateEditValue *dv, *orig_dv; - - orig_dv = (ECellDateEditValue *) value; - dv = g_new0 (ECellDateEditValue, 1); - *dv = *orig_dv; - - return dv; - } - break; - } - - return NULL; -} - -static void -ecm_free_value (ETableModel *etm, - gint col, - gpointer value) -{ - g_return_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST); - - switch (col) { - case E_CAL_MODEL_FIELD_CATEGORIES : - case E_CAL_MODEL_FIELD_DESCRIPTION : - case E_CAL_MODEL_FIELD_SUMMARY : - if (value) - g_free (value); - break; - case E_CAL_MODEL_FIELD_CLASSIFICATION : - case E_CAL_MODEL_FIELD_HAS_ALARMS : - case E_CAL_MODEL_FIELD_ICON : - case E_CAL_MODEL_FIELD_COLOR : - break; - case E_CAL_MODEL_FIELD_DTSTART : - case E_CAL_MODEL_FIELD_CREATED : - case E_CAL_MODEL_FIELD_LASTMODIFIED : - if (value) - g_free (value); - break; - case E_CAL_MODEL_FIELD_COMPONENT : - if (value) - icalcomponent_free ((icalcomponent *) value); - break; - } -} - -static gpointer -ecm_initialize_value (ETableModel *etm, - gint col) -{ - ECalModelPrivate *priv; - ECalModel *model = (ECalModel *) etm; - - g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL); - g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, NULL); - - priv = model->priv; - - switch (col) { - case E_CAL_MODEL_FIELD_CATEGORIES : - return g_strdup (priv->default_category ? priv->default_category:""); - case E_CAL_MODEL_FIELD_CLASSIFICATION : - case E_CAL_MODEL_FIELD_DESCRIPTION : - case E_CAL_MODEL_FIELD_SUMMARY : - return g_strdup (""); - case E_CAL_MODEL_FIELD_DTSTART : - case E_CAL_MODEL_FIELD_CREATED : - case E_CAL_MODEL_FIELD_LASTMODIFIED : - case E_CAL_MODEL_FIELD_HAS_ALARMS : - case E_CAL_MODEL_FIELD_ICON : - case E_CAL_MODEL_FIELD_COLOR : - case E_CAL_MODEL_FIELD_COMPONENT : - return NULL; - } - - return NULL; -} - -static gboolean -ecm_value_is_empty (ETableModel *etm, - gint col, - gconstpointer value) -{ - ECalModelPrivate *priv; - ECalModel *model = (ECalModel *) etm; - - g_return_val_if_fail (E_IS_CAL_MODEL (model), TRUE); - g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, TRUE); - - priv = model->priv; - - switch (col) { - case E_CAL_MODEL_FIELD_CATEGORIES : - /* This could be a hack or not. If the categories field only - * contains the default category, then it possibly means that - * the user has not entered anything at all in the click-to-add; - * the category is in the value because we put it there in - * ecm_initialize_value(). - */ - if (priv->default_category && value && strcmp (priv->default_category, value) == 0) - return TRUE; - else - return string_is_empty (value); - case E_CAL_MODEL_FIELD_CLASSIFICATION : - case E_CAL_MODEL_FIELD_DESCRIPTION : - case E_CAL_MODEL_FIELD_SUMMARY : - return string_is_empty (value); - case E_CAL_MODEL_FIELD_DTSTART : - case E_CAL_MODEL_FIELD_CREATED : - case E_CAL_MODEL_FIELD_LASTMODIFIED : - return value ? FALSE : TRUE; - case E_CAL_MODEL_FIELD_HAS_ALARMS : - case E_CAL_MODEL_FIELD_ICON : - case E_CAL_MODEL_FIELD_COLOR : - case E_CAL_MODEL_FIELD_COMPONENT : - return TRUE; - } - - return TRUE; -} - -static gchar * -ecm_value_to_string (ETableModel *etm, - gint col, - gconstpointer value) -{ - g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, g_strdup ("")); - - switch (col) { - case E_CAL_MODEL_FIELD_CATEGORIES : - case E_CAL_MODEL_FIELD_CLASSIFICATION : - case E_CAL_MODEL_FIELD_DESCRIPTION : - case E_CAL_MODEL_FIELD_SUMMARY : - return g_strdup (value); - case E_CAL_MODEL_FIELD_DTSTART : - case E_CAL_MODEL_FIELD_CREATED : - case E_CAL_MODEL_FIELD_LASTMODIFIED : - return e_cal_model_date_value_to_string (E_CAL_MODEL (etm), value); - case E_CAL_MODEL_FIELD_ICON : - if (GPOINTER_TO_INT (value) == 0) - return g_strdup (_("Normal")); - else if (GPOINTER_TO_INT (value) == 1) - return g_strdup (_("Recurring")); - else - return g_strdup (_("Assigned")); - case E_CAL_MODEL_FIELD_HAS_ALARMS : - return g_strdup (value ? _("Yes") : _("No")); - case E_CAL_MODEL_FIELD_COLOR : - case E_CAL_MODEL_FIELD_COMPONENT : - return g_strdup (""); - } - - return g_strdup (""); -} - -/* ECalModel class methods */ - -typedef struct { - const gchar *color; - GList *uids; -} AssignedColorData; - -static const gchar * -ecm_get_color_for_component (ECalModel *model, - ECalModelComponent *comp_data) -{ - ESource *source; - ESourceSelectable *extension; - const gchar *color_spec; - const gchar *extension_name; - const gchar *uid; - gint i, first_empty = 0; - - static AssignedColorData assigned_colors[] = { - { "#BECEDD", NULL }, /* 190 206 221 Blue */ - { "#E2F0EF", NULL }, /* 226 240 239 Light Blue */ - { "#C6E2B7", NULL }, /* 198 226 183 Green */ - { "#E2F0D3", NULL }, /* 226 240 211 Light Green */ - { "#E2D4B7", NULL }, /* 226 212 183 Khaki */ - { "#EAEAC1", NULL }, /* 234 234 193 Light Khaki */ - { "#F0B8B7", NULL }, /* 240 184 183 Pink */ - { "#FED4D3", NULL }, /* 254 212 211 Light Pink */ - { "#E2C6E1", NULL }, /* 226 198 225 Purple */ - { "#F0E2EF", NULL } /* 240 226 239 Light Purple */ - }; - - g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL); - - switch (e_cal_client_get_source_type (comp_data->client)) { - case E_CAL_CLIENT_SOURCE_TYPE_EVENTS: - extension_name = E_SOURCE_EXTENSION_CALENDAR; - break; - case E_CAL_CLIENT_SOURCE_TYPE_TASKS: - extension_name = E_SOURCE_EXTENSION_TASK_LIST; - break; - case E_CAL_CLIENT_SOURCE_TYPE_MEMOS: - extension_name = E_SOURCE_EXTENSION_MEMO_LIST; - break; - default: - g_return_val_if_reached (NULL); - } - - source = e_client_get_source (E_CLIENT (comp_data->client)); - extension = e_source_get_extension (source, extension_name); - color_spec = e_source_selectable_get_color (extension); - - if (color_spec != NULL) { - g_free (comp_data->color); - comp_data->color = g_strdup (color_spec); - return comp_data->color; - } - - uid = e_source_get_uid (source); - - for (i = 0; i < G_N_ELEMENTS (assigned_colors); i++) { - GList *l; - - if (assigned_colors[i].uids == NULL) { - first_empty = i; - continue; - } - - for (l = assigned_colors[i].uids; l != NULL; l = l->next) - if (g_strcmp0 (l->data, uid) == 0) - return assigned_colors[i].color; - } - - /* return the first unused color */ - assigned_colors[first_empty].uids = g_list_append ( - assigned_colors[first_empty].uids, g_strdup (uid)); - - return assigned_colors[first_empty].color; -} - gboolean e_cal_model_get_confirm_delete (ECalModel *model) { @@ -4045,7 +4029,7 @@ e_cal_model_get_color_for_component (ECalModel *model, color = model_class->get_color_for_component (model, comp_data); if (!color) - color = ecm_get_color_for_component (model, comp_data); + color = cal_model_get_color_for_component (model, comp_data); return color; } diff --git a/doc/reference/evolution-util/evolution-util-sections.txt b/doc/reference/evolution-util/evolution-util-sections.txt index 9a0753b55b..f8f0482e8f 100644 --- a/doc/reference/evolution-util/evolution-util-sections.txt +++ b/doc/reference/evolution-util/evolution-util-sections.txt @@ -3973,6 +3973,7 @@ e_table_state_get_type ETableSubset e_table_subset_new e_table_subset_construct +e_table_subset_get_source_model e_table_subset_model_to_view_row e_table_subset_view_to_model_row e_table_subset_get_toplevel diff --git a/e-util/e-table-click-to-add.c b/e-util/e-table-click-to-add.c index 6de00f913b..8d80e197f4 100644 --- a/e-util/e-table-click-to-add.c +++ b/e-util/e-table-click-to-add.c @@ -49,9 +49,10 @@ enum { static guint etcta_signals[LAST_SIGNAL] = { 0 }; -/* workaround for avoiding APi breakage */ -#define etcta_get_type e_table_click_to_add_get_type -G_DEFINE_TYPE (ETableClickToAdd, etcta, GNOME_TYPE_CANVAS_GROUP) +G_DEFINE_TYPE ( + ETableClickToAdd, + e_table_click_to_add, + GNOME_TYPE_CANVAS_GROUP) enum { PROP_0, @@ -199,7 +200,7 @@ etcta_dispose (GObject *object) etcta->selection = NULL; /* Chain up to parent's dispose() method. */ - G_OBJECT_CLASS (etcta_parent_class)->dispose (object); + G_OBJECT_CLASS (e_table_click_to_add_parent_class)->dispose (object); } static void @@ -324,8 +325,8 @@ etcta_realize (GnomeCanvasItem *item) create_rect_and_text (etcta); e_canvas_item_move_absolute (etcta->text, 2, 2); - if (GNOME_CANVAS_ITEM_CLASS (etcta_parent_class)->realize) - (*GNOME_CANVAS_ITEM_CLASS (etcta_parent_class)->realize)(item); + if (GNOME_CANVAS_ITEM_CLASS (e_table_click_to_add_parent_class)->realize) + (*GNOME_CANVAS_ITEM_CLASS (e_table_click_to_add_parent_class)->realize)(item); e_canvas_item_request_reflow (item); } @@ -333,8 +334,8 @@ etcta_realize (GnomeCanvasItem *item) static void etcta_unrealize (GnomeCanvasItem *item) { - if (GNOME_CANVAS_ITEM_CLASS (etcta_parent_class)->unrealize) - (*GNOME_CANVAS_ITEM_CLASS (etcta_parent_class)->unrealize)(item); + if (GNOME_CANVAS_ITEM_CLASS (e_table_click_to_add_parent_class)->unrealize) + (*GNOME_CANVAS_ITEM_CLASS (e_table_click_to_add_parent_class)->unrealize)(item); } static void finish_editing (ETableClickToAdd *etcta); @@ -519,7 +520,7 @@ etcta_reflow (GnomeCanvasItem *item, } static void -etcta_class_init (ETableClickToAddClass *class) +e_table_click_to_add_class_init (ETableClickToAddClass *class) { GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (class); GObjectClass *object_class = G_OBJECT_CLASS (class); @@ -612,7 +613,7 @@ etcta_class_init (ETableClickToAddClass *class) } static void -etcta_init (ETableClickToAdd *etcta) +e_table_click_to_add_init (ETableClickToAdd *etcta) { AtkObject *a11y; diff --git a/e-util/e-table-column-specification.c b/e-util/e-table-column-specification.c index d1cf089d2d..32c16a5553 100644 --- a/e-util/e-table-column-specification.c +++ b/e-util/e-table-column-specification.c @@ -35,9 +35,10 @@ #include "e-xml-utils.h" -/* workaround for avoiding API breakage */ -#define etcs_get_type e_table_column_specification_get_type -G_DEFINE_TYPE (ETableColumnSpecification, etcs, G_TYPE_OBJECT) +G_DEFINE_TYPE ( + ETableColumnSpecification, + e_table_column_specification, + G_TYPE_OBJECT) static void free_strings (ETableColumnSpecification *etcs) @@ -63,11 +64,11 @@ etcs_finalize (GObject *object) free_strings (etcs); - G_OBJECT_CLASS (etcs_parent_class)->finalize (object); + G_OBJECT_CLASS (e_table_column_specification_parent_class)->finalize (object); } static void -etcs_class_init (ETableColumnSpecificationClass *class) +e_table_column_specification_class_init (ETableColumnSpecificationClass *class) { GObjectClass *object_class = G_OBJECT_CLASS (class); @@ -75,7 +76,7 @@ etcs_class_init (ETableColumnSpecificationClass *class) } static void -etcs_init (ETableColumnSpecification *specification) +e_table_column_specification_init (ETableColumnSpecification *specification) { specification->model_col = 0; specification->compare_col = 0; diff --git a/e-util/e-table-config.c b/e-util/e-table-config.c index 98f89ffd10..1c7f5563d5 100644 --- a/e-util/e-table-config.c +++ b/e-util/e-table-config.c @@ -788,7 +788,8 @@ get_source_model_col_index (ETableConfig *config, gint visible_index; ETableModel *src_model; - src_model = E_TABLE_SUBSET (config->available_model)->source; + src_model = e_table_subset_get_source_model ( + E_TABLE_SUBSET (config->available_model)); visible_index = e_table_subset_view_to_model_row ( E_TABLE_SUBSET (config->available_model), idx); diff --git a/e-util/e-table-extras.c b/e-util/e-table-extras.c index 1820f35451..35658fd0cc 100644 --- a/e-util/e-table-extras.c +++ b/e-util/e-table-extras.c @@ -52,9 +52,10 @@ struct _ETableExtrasPrivate { GHashTable *searches; }; -/* workaround for avoiding API breakage */ -#define ete_get_type e_table_extras_get_type -G_DEFINE_TYPE (ETableExtras, ete, G_TYPE_OBJECT) +G_DEFINE_TYPE ( + ETableExtras, + e_table_extras, + G_TYPE_OBJECT) static void ete_finalize (GObject *object) @@ -83,11 +84,11 @@ ete_finalize (GObject *object) priv->icon_names = NULL; } - G_OBJECT_CLASS (ete_parent_class)->finalize (object); + G_OBJECT_CLASS (e_table_extras_parent_class)->finalize (object); } static void -ete_class_init (ETableExtrasClass *class) +e_table_extras_class_init (ETableExtrasClass *class) { GObjectClass *object_class; @@ -235,7 +236,7 @@ safe_unref (gpointer object) } static void -ete_init (ETableExtras *extras) +e_table_extras_init (ETableExtras *extras) { ECell *cell, *sub_cell; diff --git a/e-util/e-table-field-chooser-item.c b/e-util/e-table-field-chooser-item.c index c7335f8a5c..f4a85d6b83 100644 --- a/e-util/e-table-field-chooser-item.c +++ b/e-util/e-table-field-chooser-item.c @@ -50,9 +50,10 @@ enum { static guint etfci_signals[LAST_SIGNAL] = { 0, }; #endif -/* workaround for avoiding API breakage */ -#define etfci_get_type e_table_field_chooser_item_get_type -G_DEFINE_TYPE (ETableFieldChooserItem, etfci, GNOME_TYPE_CANVAS_ITEM) +G_DEFINE_TYPE ( + ETableFieldChooserItem, + e_table_field_chooser_item, + GNOME_TYPE_CANVAS_ITEM) static void etfci_drop_table_header (ETableFieldChooserItem *etfci); static void etfci_drop_full_header (ETableFieldChooserItem *etfci); @@ -83,7 +84,7 @@ etfci_dispose (GObject *object) etfci->font_desc = NULL; /* Chain up to parent's dispose() method. */ - G_OBJECT_CLASS (etfci_parent_class)->dispose (object); + G_OBJECT_CLASS (e_table_field_chooser_item_parent_class)->dispose (object); } static gint @@ -191,8 +192,8 @@ etfci_update (GnomeCanvasItem *item, ETableFieldChooserItem *etfci = E_TABLE_FIELD_CHOOSER_ITEM (item); gdouble x1, y1, x2, y2; - if (GNOME_CANVAS_ITEM_CLASS (etfci_parent_class)->update) - GNOME_CANVAS_ITEM_CLASS (etfci_parent_class)->update ( + if (GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)->update) + GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)->update ( item, i2c, flags); x1 = y1 = 0; @@ -450,8 +451,8 @@ etfci_realize (GnomeCanvasItem *item) { ETableFieldChooserItem *etfci = E_TABLE_FIELD_CHOOSER_ITEM (item); - if (GNOME_CANVAS_ITEM_CLASS (etfci_parent_class)-> realize) - (*GNOME_CANVAS_ITEM_CLASS (etfci_parent_class)->realize)(item); + if (GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)-> realize) + (*GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)->realize)(item); if (!etfci->font_desc) etfci_font_load (etfci); @@ -479,8 +480,8 @@ etfci_unrealize (GnomeCanvasItem *item) g_signal_handler_disconnect (item->canvas, etfci->drag_data_get_id); etfci->drag_data_get_id = 0; - if (GNOME_CANVAS_ITEM_CLASS (etfci_parent_class)->unrealize) - (*GNOME_CANVAS_ITEM_CLASS (etfci_parent_class)->unrealize)(item); + if (GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)->unrealize) + (*GNOME_CANVAS_ITEM_CLASS (e_table_field_chooser_item_parent_class)->unrealize)(item); } static void @@ -660,7 +661,7 @@ etfci_event (GnomeCanvasItem *item, } static void -etfci_class_init (ETableFieldChooserItemClass *class) +e_table_field_chooser_item_class_init (ETableFieldChooserItemClass *class) { GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (class); GObjectClass *object_class = G_OBJECT_CLASS (class); @@ -728,7 +729,7 @@ etfci_class_init (ETableFieldChooserItemClass *class) } static void -etfci_init (ETableFieldChooserItem *etfci) +e_table_field_chooser_item_init (ETableFieldChooserItem *etfci) { etfci->full_header = NULL; etfci->header = NULL; diff --git a/e-util/e-table-field-chooser.c b/e-util/e-table-field-chooser.c index dd8a171f9d..85069b6317 100644 --- a/e-util/e-table-field-chooser.c +++ b/e-util/e-table-field-chooser.c @@ -45,7 +45,10 @@ enum { PROP_DND_CODE }; -G_DEFINE_TYPE (ETableFieldChooser, e_table_field_chooser, GTK_TYPE_VBOX) +G_DEFINE_TYPE ( + ETableFieldChooser, + e_table_field_chooser, + GTK_TYPE_VBOX) static void e_table_field_chooser_class_init (ETableFieldChooserClass *class) diff --git a/e-util/e-table-group-container.c b/e-util/e-table-group-container.c index 5741cd1093..72fee11c26 100644 --- a/e-util/e-table-group-container.c +++ b/e-util/e-table-group-container.c @@ -42,9 +42,10 @@ #define TITLE_HEIGHT 16 -/* workaround for avoiding API breakage */ -#define etgc_get_type e_table_group_container_get_type -G_DEFINE_TYPE (ETableGroupContainer, etgc, E_TYPE_TABLE_GROUP) +G_DEFINE_TYPE ( + ETableGroupContainer, + e_table_group_container, + E_TYPE_TABLE_GROUP) enum { PROP_0, @@ -124,7 +125,7 @@ etgc_dispose (GObject *object) g_object_run_dispose (G_OBJECT (etgc->rect)); etgc->rect = NULL; - G_OBJECT_CLASS (etgc_parent_class)->dispose (object); + G_OBJECT_CLASS (e_table_group_container_parent_class)->dispose (object); } /** @@ -315,8 +316,8 @@ etgc_event (GnomeCanvasItem *item, break; } if (return_val == FALSE) { - if (GNOME_CANVAS_ITEM_CLASS (etgc_parent_class)->event) - return GNOME_CANVAS_ITEM_CLASS (etgc_parent_class)->event (item, event); + if (GNOME_CANVAS_ITEM_CLASS (e_table_group_container_parent_class)->event) + return GNOME_CANVAS_ITEM_CLASS (e_table_group_container_parent_class)->event (item, event); } return return_val; @@ -328,8 +329,8 @@ etgc_realize (GnomeCanvasItem *item) { ETableGroupContainer *etgc; - if (GNOME_CANVAS_ITEM_CLASS (etgc_parent_class)->realize) - (* GNOME_CANVAS_ITEM_CLASS (etgc_parent_class)->realize) (item); + if (GNOME_CANVAS_ITEM_CLASS (e_table_group_container_parent_class)->realize) + (* GNOME_CANVAS_ITEM_CLASS (e_table_group_container_parent_class)->realize) (item); etgc = E_TABLE_GROUP_CONTAINER (item); @@ -340,8 +341,8 @@ etgc_realize (GnomeCanvasItem *item) static void etgc_unrealize (GnomeCanvasItem *item) { - if (GNOME_CANVAS_ITEM_CLASS (etgc_parent_class)->unrealize) - (* GNOME_CANVAS_ITEM_CLASS (etgc_parent_class)->unrealize) (item); + if (GNOME_CANVAS_ITEM_CLASS (e_table_group_container_parent_class)->unrealize) + (* GNOME_CANVAS_ITEM_CLASS (e_table_group_container_parent_class)->unrealize) (item); } static void @@ -998,7 +999,7 @@ etgc_get_property (GObject *object, } static void -etgc_class_init (ETableGroupContainerClass *class) +e_table_group_container_class_init (ETableGroupContainerClass *class) { GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (class); GObjectClass *object_class = G_OBJECT_CLASS (class); @@ -1247,7 +1248,7 @@ etgc_reflow (GnomeCanvasItem *item, } static void -etgc_init (ETableGroupContainer *container) +e_table_group_container_init (ETableGroupContainer *container) { container->children = NULL; diff --git a/e-util/e-table-group-leaf.c b/e-util/e-table-group-leaf.c index 8d1a91da69..027ba299ec 100644 --- a/e-util/e-table-group-leaf.c +++ b/e-util/e-table-group-leaf.c @@ -37,9 +37,10 @@ #include "e-table-sorted.h" #include "e-table-sorted-variable.h" -/* workaround for avoiding APi breakage */ -#define etgl_get_type e_table_group_leaf_get_type -G_DEFINE_TYPE (ETableGroupLeaf, etgl, E_TYPE_TABLE_GROUP) +G_DEFINE_TYPE ( + ETableGroupLeaf, + e_table_group_leaf, + E_TYPE_TABLE_GROUP) enum { PROP_0, @@ -115,7 +116,7 @@ etgl_dispose (GObject *object) } /* Chain up to parent's dispose() method. */ - G_OBJECT_CLASS (etgl_parent_class)->dispose (object); + G_OBJECT_CLASS (e_table_group_leaf_parent_class)->dispose (object); } static void @@ -130,13 +131,11 @@ e_table_group_leaf_construct (GnomeCanvasGroup *parent, (e_table_sort_info_grouping_get_count (sort_info) > 0); if (etgl->is_grouped) - etgl->ets = E_TABLE_SUBSET ( - e_table_sorted_variable_new ( - model, full_header, sort_info)); + etgl->ets = e_table_sorted_variable_new ( + model, full_header, sort_info); else - etgl->ets = E_TABLE_SUBSET ( - e_table_sorted_new ( - model, full_header, sort_info)); + etgl->ets = e_table_sorted_new ( + model, full_header, sort_info); e_table_group_construct ( parent, E_TABLE_GROUP (etgl), full_header, header, model); @@ -177,13 +176,19 @@ e_table_group_leaf_new (GnomeCanvasGroup *parent, static void etgl_cursor_change (GObject *object, - gint row, + gint view_row, ETableGroupLeaf *etgl) { - if (row < E_TABLE_SUBSET (etgl->ets)->n_map) - e_table_group_cursor_change ( - E_TABLE_GROUP (etgl), - E_TABLE_SUBSET (etgl->ets)->map_table[row]); + ETableSubset *table_subset; + gint model_row; + + table_subset = E_TABLE_SUBSET (etgl->ets); + model_row = e_table_subset_view_to_model_row (table_subset, view_row); + + if (model_row < 0) + return; + + e_table_group_cursor_change (E_TABLE_GROUP (etgl), model_row); } static void @@ -191,10 +196,16 @@ etgl_cursor_activated (GObject *object, gint view_row, ETableGroupLeaf *etgl) { - if (view_row < E_TABLE_SUBSET (etgl->ets)->n_map) - e_table_group_cursor_activated ( - E_TABLE_GROUP (etgl), - E_TABLE_SUBSET (etgl->ets)->map_table[view_row]); + ETableSubset *table_subset; + gint model_row; + + table_subset = E_TABLE_SUBSET (etgl->ets); + model_row = e_table_subset_view_to_model_row (table_subset, view_row); + + if (model_row < 0) + return; + + e_table_group_cursor_activated (E_TABLE_GROUP (etgl), model_row); } static void @@ -215,13 +226,17 @@ etgl_key_press (GObject *object, GdkEvent *event, ETableGroupLeaf *etgl) { - if (row < E_TABLE_SUBSET (etgl->ets)->n_map && row >= 0) - return e_table_group_key_press ( - E_TABLE_GROUP (etgl), - E_TABLE_SUBSET (etgl->ets)->map_table[row], - col, event); - else + ETableSubset *table_subset; + gint model_row; + + table_subset = E_TABLE_SUBSET (etgl->ets); + model_row = e_table_subset_view_to_model_row (table_subset, row); + + if (model_row < 0) return FALSE; + + return e_table_group_key_press ( + E_TABLE_GROUP (etgl), model_row, col, event); } static gboolean @@ -242,13 +257,17 @@ etgl_right_click (GObject *object, GdkEvent *event, ETableGroupLeaf *etgl) { - if (view_row < E_TABLE_SUBSET (etgl->ets)->n_map) - return e_table_group_right_click ( - E_TABLE_GROUP (etgl), - E_TABLE_SUBSET (etgl->ets)->map_table[view_row], - model_col, event); - else + ETableSubset *table_subset; + gint model_row; + + table_subset = E_TABLE_SUBSET (etgl->ets); + model_row = e_table_subset_view_to_model_row (table_subset, view_row); + + if (model_row < 0) return FALSE; + + return e_table_group_right_click ( + E_TABLE_GROUP (etgl), model_row, model_col, event); } static gboolean @@ -258,13 +277,17 @@ etgl_click (GObject *object, GdkEvent *event, ETableGroupLeaf *etgl) { - if (row < E_TABLE_SUBSET (etgl->ets)->n_map) - return e_table_group_click ( - E_TABLE_GROUP (etgl), - E_TABLE_SUBSET (etgl->ets)->map_table[row], - col, event); - else + ETableSubset *table_subset; + gint model_row; + + table_subset = E_TABLE_SUBSET (etgl->ets); + model_row = e_table_subset_view_to_model_row (table_subset, row); + + if (model_row < 0) return FALSE; + + return e_table_group_click ( + E_TABLE_GROUP (etgl), model_row, col, event); } static void @@ -284,8 +307,8 @@ etgl_realize (GnomeCanvasItem *item) { ETableGroupLeaf *etgl = E_TABLE_GROUP_LEAF (item); - if (GNOME_CANVAS_ITEM_CLASS (etgl_parent_class)->realize) - GNOME_CANVAS_ITEM_CLASS (etgl_parent_class)->realize (item); + if (GNOME_CANVAS_ITEM_CLASS (e_table_group_leaf_parent_class)->realize) + GNOME_CANVAS_ITEM_CLASS (e_table_group_leaf_parent_class)->realize (item); etgl->item = E_TABLE_ITEM (gnome_canvas_item_new ( GNOME_CANVAS_GROUP (etgl), @@ -634,7 +657,7 @@ etgl_get_property (GObject *object, } static void -etgl_class_init (ETableGroupLeafClass *class) +e_table_group_leaf_class_init (ETableGroupLeafClass *class) { GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (class); ETableGroupClass *e_group_class = E_TABLE_GROUP_CLASS (class); @@ -784,7 +807,7 @@ etgl_class_init (ETableGroupLeafClass *class) } static void -etgl_init (ETableGroupLeaf *etgl) +e_table_group_leaf_init (ETableGroupLeaf *etgl) { etgl->width = 1; etgl->height = 1; diff --git a/e-util/e-table-group-leaf.h b/e-util/e-table-group-leaf.h index 93aa2bf2da..8c47e2e52e 100644 --- a/e-util/e-table-group-leaf.h +++ b/e-util/e-table-group-leaf.h @@ -72,7 +72,7 @@ struct _ETableGroupLeaf { gint length_threshold; - ETableSubset *ets; + ETableModel *ets; guint is_grouped : 1; guint alternating_row_colors : 1; diff --git a/e-util/e-table-group.c b/e-util/e-table-group.c index b5671d90f8..a4a23bef67 100644 --- a/e-util/e-table-group.c +++ b/e-util/e-table-group.c @@ -32,9 +32,10 @@ #include "e-table-group-leaf.h" #include "e-table-item.h" -/* workaround for avoiding API breakage*/ -#define etg_get_type e_table_group_get_type -G_DEFINE_TYPE (ETableGroup, etg, GNOME_TYPE_CANVAS_GROUP) +G_DEFINE_TYPE ( + ETableGroup, + e_table_group, + GNOME_TYPE_CANVAS_GROUP) #define ETG_CLASS(e) (E_TABLE_GROUP_CLASS(G_OBJECT_GET_CLASS(e))) @@ -74,7 +75,7 @@ etg_dispose (GObject *object) } /* Chain up to parent's dispose() method. */ - G_OBJECT_CLASS (etg_parent_class)->dispose (object); + G_OBJECT_CLASS (e_table_group_parent_class)->dispose (object); } /** @@ -619,8 +620,8 @@ etg_event (GnomeCanvasItem *item, return_val = FALSE; } if (return_val == FALSE) { - if (GNOME_CANVAS_ITEM_CLASS (etg_parent_class)->event) - return GNOME_CANVAS_ITEM_CLASS (etg_parent_class)->event (item, event); + if (GNOME_CANVAS_ITEM_CLASS (e_table_group_parent_class)->event) + return GNOME_CANVAS_ITEM_CLASS (e_table_group_parent_class)->event (item, event); } return return_val; @@ -633,7 +634,7 @@ etg_get_focus (ETableGroup *table_group) } static void -etg_class_init (ETableGroupClass *class) +e_table_group_class_init (ETableGroupClass *class) { GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (class); GObjectClass *object_class = G_OBJECT_CLASS (class); @@ -746,7 +747,7 @@ etg_class_init (ETableGroupClass *class) } static void -etg_init (ETableGroup *table_group) +e_table_group_init (ETableGroup *table_group) { /* nothing to do */ } diff --git a/e-util/e-table-item.c b/e-util/e-table-item.c index de749ead68..289d26d973 100644 --- a/e-util/e-table-item.c +++ b/e-util/e-table-item.c @@ -49,9 +49,10 @@ #include "gal-a11y-e-table-item-factory.h" #include "gal-a11y-e-table-item.h" -/* workaround for avoiding API breakage */ -#define eti_get_type e_table_item_get_type -G_DEFINE_TYPE (ETableItem, eti, GNOME_TYPE_CANVAS_ITEM) +G_DEFINE_TYPE ( + ETableItem, + e_table_item, + GNOME_TYPE_CANVAS_ITEM) #define FOCUSED_BORDER 2 @@ -168,21 +169,18 @@ inline static gint model_to_view_row (ETableItem *eti, gint row) { - gint i; if (row == -1) return -1; if (eti->uses_source_model) { - ETableSubset *etss = E_TABLE_SUBSET (eti->table_model); - if (eti->row_guess >= 0 && eti->row_guess < etss->n_map) { - if (etss->map_table[eti->row_guess] == row) { - return eti->row_guess; - } - } - for (i = 0; i < etss->n_map; i++) { - if (etss->map_table[i] == row) - return i; - } - return -1; + gint model_row; + + model_row = e_table_subset_view_to_model_row ( + E_TABLE_SUBSET (eti->table_model), eti->row_guess); + if (model_row >= 0 && model_row == row) + return eti->row_guess; + + return e_table_subset_model_to_view_row ( + E_TABLE_SUBSET (eti->table_model), row); } else return row; } @@ -192,12 +190,15 @@ view_to_model_row (ETableItem *eti, gint row) { if (eti->uses_source_model) { - ETableSubset *etss = E_TABLE_SUBSET (eti->table_model); - if (row >= 0 && row < etss->n_map) { + gint model_row; + + model_row = e_table_subset_view_to_model_row ( + E_TABLE_SUBSET (eti->table_model), row); + + if (model_row >= 0) eti->row_guess = row; - return etss->map_table[row]; - } else - return -1; + + return model_row; } else return row; } @@ -559,8 +560,8 @@ eti_update (GnomeCanvasItem *item, ETableItem *eti = E_TABLE_ITEM (item); gdouble x1, x2, y1, y2; - if (GNOME_CANVAS_ITEM_CLASS (eti_parent_class)->update) - (*GNOME_CANVAS_ITEM_CLASS (eti_parent_class)->update)(item, i2c, flags); + if (GNOME_CANVAS_ITEM_CLASS (e_table_item_parent_class)->update) + (*GNOME_CANVAS_ITEM_CLASS (e_table_item_parent_class)->update)(item, i2c, flags); x1 = item->x1; y1 = item->y1; @@ -1432,7 +1433,8 @@ eti_add_table_model (ETableItem *eti, if (E_IS_TABLE_SUBSET (table_model)) { eti->uses_source_model = 1; - eti->source_model = E_TABLE_SUBSET (table_model)->source; + eti->source_model = e_table_subset_get_source_model ( + E_TABLE_SUBSET (table_model)); if (eti->source_model) g_object_ref (eti->source_model); } @@ -1576,7 +1578,7 @@ eti_dispose (GObject *object) eti->height_cache = NULL; /* Chain up to parent's dispose() method. */ - G_OBJECT_CLASS (eti_parent_class)->dispose (object); + G_OBJECT_CLASS (e_table_item_parent_class)->dispose (object); } static void @@ -1704,7 +1706,7 @@ eti_get_property (GObject *object, } static void -eti_init (ETableItem *eti) +e_table_item_init (ETableItem *eti) { eti->motion_row = -1; eti->motion_col = -1; @@ -1795,8 +1797,8 @@ eti_realize (GnomeCanvasItem *item) { ETableItem *eti = E_TABLE_ITEM (item); - if (GNOME_CANVAS_ITEM_CLASS (eti_parent_class)->realize) - (*GNOME_CANVAS_ITEM_CLASS (eti_parent_class)->realize)(item); + if (GNOME_CANVAS_ITEM_CLASS (e_table_item_parent_class)->realize) + (*GNOME_CANVAS_ITEM_CLASS (e_table_item_parent_class)->realize)(item); eti->rows = e_table_model_row_count (eti->table_model); @@ -1857,8 +1859,8 @@ eti_unrealize (GnomeCanvasItem *item) eti->height = 0; - if (GNOME_CANVAS_ITEM_CLASS (eti_parent_class)->unrealize) - (*GNOME_CANVAS_ITEM_CLASS (eti_parent_class)->unrealize)(item); + if (GNOME_CANVAS_ITEM_CLASS (e_table_item_parent_class)->unrealize) + (*GNOME_CANVAS_ITEM_CLASS (e_table_item_parent_class)->unrealize)(item); } static void @@ -3104,7 +3106,7 @@ eti_style_set (ETableItem *eti, } static void -eti_class_init (ETableItemClass *class) +e_table_item_class_init (ETableItemClass *class) { GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (class); GObjectClass *object_class = G_OBJECT_CLASS (class); diff --git a/e-util/e-table-memory-store.c b/e-util/e-table-memory-store.c index 51d8a3c107..6432cc3c5b 100644 --- a/e-util/e-table-memory-store.c +++ b/e-util/e-table-memory-store.c @@ -20,10 +20,6 @@ * */ -#ifdef HAVE_CONFIG_H -#include <config.h> -#endif - #include <string.h> #include "e-table-memory-store.h" @@ -40,7 +36,10 @@ struct _ETableMemoryStorePrivate { gpointer *store; }; -G_DEFINE_TYPE (ETableMemoryStore, e_table_memory_store, E_TYPE_TABLE_MEMORY) +G_DEFINE_TYPE ( + ETableMemoryStore, + e_table_memory_store, + E_TYPE_TABLE_MEMORY) static gpointer duplicate_value (ETableMemoryStore *etms, @@ -78,18 +77,55 @@ free_value (ETableMemoryStore *etms, } } +static void +table_memory_store_finalize (GObject *object) +{ + ETableMemoryStorePrivate *priv; + + priv = E_TABLE_MEMORY_STORE_GET_PRIVATE (object); + + e_table_memory_store_clear (E_TABLE_MEMORY_STORE (object)); + + g_free (priv->columns); + g_free (priv->store); + + /* Chain up to parent's finalize() method. */ + G_OBJECT_CLASS (e_table_memory_store_parent_class)->finalize (object); +} + static gint -etms_column_count (ETableModel *etm) +table_memory_store_column_count (ETableModel *etm) { ETableMemoryStore *etms = E_TABLE_MEMORY_STORE (etm); return etms->priv->col_count; } +static void +table_memory_store_append_row (ETableModel *etm, + ETableModel *source, + gint row) +{ + ETableMemoryStore *etms = E_TABLE_MEMORY_STORE (etm); + gpointer *new_data; + gint i; + gint row_count; + + new_data = g_new (gpointer , etms->priv->col_count); + + for (i = 0; i < etms->priv->col_count; i++) { + new_data[i] = e_table_model_value_at (source, i, row); + } + + row_count = e_table_model_row_count (E_TABLE_MODEL (etms)); + + e_table_memory_store_insert_array (etms, row_count, new_data, NULL); +} + static gpointer -etms_value_at (ETableModel *etm, - gint col, - gint row) +table_memory_store_value_at (ETableModel *etm, + gint col, + gint row) { ETableMemoryStore *etms = E_TABLE_MEMORY_STORE (etm); @@ -97,10 +133,10 @@ etms_value_at (ETableModel *etm, } static void -etms_set_value_at (ETableModel *etm, - gint col, - gint row, - gconstpointer val) +table_memory_store_set_value_at (ETableModel *etm, + gint col, + gint row, + gconstpointer val) { ETableMemoryStore *etms = E_TABLE_MEMORY_STORE (etm); @@ -112,20 +148,20 @@ etms_set_value_at (ETableModel *etm, } static gboolean -etms_is_cell_editable (ETableModel *etm, - gint col, - gint row) +table_memory_store_is_cell_editable (ETableModel *etm, + gint col, + gint row) { ETableMemoryStore *etms = E_TABLE_MEMORY_STORE (etm); return etms->priv->columns[col].editable; } -/* The default for etms_duplicate_value is to return the raw value. */ +/* The default for duplicate_value() is to return the raw value. */ static gpointer -etms_duplicate_value (ETableModel *etm, - gint col, - gconstpointer value) +table_memory_store_duplicate_value (ETableModel *etm, + gint col, + gconstpointer value) { ETableMemoryStore *etms = E_TABLE_MEMORY_STORE (etm); @@ -133,9 +169,9 @@ etms_duplicate_value (ETableModel *etm, } static void -etms_free_value (ETableModel *etm, - gint col, - gpointer value) +table_memory_store_free_value (ETableModel *etm, + gint col, + gpointer value) { ETableMemoryStore *etms = E_TABLE_MEMORY_STORE (etm); @@ -143,102 +179,59 @@ etms_free_value (ETableModel *etm, } static gpointer -etms_initialize_value (ETableModel *etm, - gint col) +table_memory_store_initialize_value (ETableModel *etm, + gint col) { ETableMemoryStore *etms = E_TABLE_MEMORY_STORE (etm); switch (etms->priv->columns[col].type) { - case E_TABLE_MEMORY_STORE_COLUMN_TYPE_STRING: - return g_strdup (""); - case E_TABLE_MEMORY_STORE_COLUMN_TYPE_PIXBUF: - return NULL; - default: - break; + case E_TABLE_MEMORY_STORE_COLUMN_TYPE_STRING: + return g_strdup (""); + case E_TABLE_MEMORY_STORE_COLUMN_TYPE_PIXBUF: + return NULL; + default: + break; } return NULL; } static gboolean -etms_value_is_empty (ETableModel *etm, - gint col, - gconstpointer value) +table_memory_store_value_is_empty (ETableModel *etm, + gint col, + gconstpointer value) { ETableMemoryStore *etms = E_TABLE_MEMORY_STORE (etm); switch (etms->priv->columns[col].type) { - case E_TABLE_MEMORY_STORE_COLUMN_TYPE_STRING: - return !(value && *(gchar *) value); - case E_TABLE_MEMORY_STORE_COLUMN_TYPE_PIXBUF: - return value == NULL; - default: - break; + case E_TABLE_MEMORY_STORE_COLUMN_TYPE_STRING: + return !(value && *(gchar *) value); + case E_TABLE_MEMORY_STORE_COLUMN_TYPE_PIXBUF: + return value == NULL; + default: + break; } return value == NULL; } static gchar * -etms_value_to_string (ETableModel *etm, - gint col, - gconstpointer value) +table_memory_store_value_to_string (ETableModel *etm, + gint col, + gconstpointer value) { ETableMemoryStore *etms = E_TABLE_MEMORY_STORE (etm); switch (etms->priv->columns[col].type) { - case E_TABLE_MEMORY_STORE_COLUMN_TYPE_STRING: - return g_strdup (value); - case E_TABLE_MEMORY_STORE_COLUMN_TYPE_PIXBUF: - return g_strdup (""); - default: - break; + case E_TABLE_MEMORY_STORE_COLUMN_TYPE_STRING: + return g_strdup (value); + case E_TABLE_MEMORY_STORE_COLUMN_TYPE_PIXBUF: + return g_strdup (""); + default: + break; } return g_strdup_printf ("%d", GPOINTER_TO_INT (value)); } static void -etms_append_row (ETableModel *etm, - ETableModel *source, - gint row) -{ - ETableMemoryStore *etms = E_TABLE_MEMORY_STORE (etm); - gpointer *new_data; - gint i; - gint row_count; - - new_data = g_new (gpointer , etms->priv->col_count); - - for (i = 0; i < etms->priv->col_count; i++) { - new_data[i] = e_table_model_value_at (source, i, row); - } - - row_count = e_table_model_row_count (E_TABLE_MODEL (etms)); - - e_table_memory_store_insert_array (etms, row_count, new_data, NULL); -} - -static void -etms_finalize (GObject *object) -{ - ETableMemoryStorePrivate *priv; - - priv = E_TABLE_MEMORY_STORE_GET_PRIVATE (object); - - e_table_memory_store_clear (E_TABLE_MEMORY_STORE (object)); - - g_free (priv->columns); - g_free (priv->store); - - /* Chain up to parent's finalize() method. */ - G_OBJECT_CLASS (e_table_memory_store_parent_class)->finalize (object); -} - -static void -e_table_memory_store_init (ETableMemoryStore *etms) -{ - etms->priv = E_TABLE_MEMORY_STORE_GET_PRIVATE (etms); -} - -static void e_table_memory_store_class_init (ETableMemoryStoreClass *class) { GObjectClass *object_class; @@ -247,19 +240,25 @@ e_table_memory_store_class_init (ETableMemoryStoreClass *class) g_type_class_add_private (class, sizeof (ETableMemoryStorePrivate)); object_class = G_OBJECT_CLASS (class); - object_class->finalize = etms_finalize; + object_class->finalize = table_memory_store_finalize; model_class = E_TABLE_MODEL_CLASS (class); - model_class->column_count = etms_column_count; - model_class->value_at = etms_value_at; - model_class->set_value_at = etms_set_value_at; - model_class->is_cell_editable = etms_is_cell_editable; - model_class->duplicate_value = etms_duplicate_value; - model_class->free_value = etms_free_value; - model_class->initialize_value = etms_initialize_value; - model_class->value_is_empty = etms_value_is_empty; - model_class->value_to_string = etms_value_to_string; - model_class->append_row = etms_append_row; + model_class->column_count = table_memory_store_column_count; + model_class->append_row = table_memory_store_append_row; + model_class->value_at = table_memory_store_value_at; + model_class->set_value_at = table_memory_store_set_value_at; + model_class->is_cell_editable = table_memory_store_is_cell_editable; + model_class->duplicate_value = table_memory_store_duplicate_value; + model_class->free_value = table_memory_store_free_value; + model_class->initialize_value = table_memory_store_initialize_value; + model_class->value_is_empty = table_memory_store_value_is_empty; + model_class->value_to_string = table_memory_store_value_to_string; +} + +static void +e_table_memory_store_init (ETableMemoryStore *etms) +{ + etms->priv = E_TABLE_MEMORY_STORE_GET_PRIVATE (etms); } /** diff --git a/e-util/e-table-memory.c b/e-util/e-table-memory.c index e12deb3007..5a0bcd1868 100644 --- a/e-util/e-table-memory.c +++ b/e-util/e-table-memory.c @@ -20,10 +20,6 @@ * */ -#ifdef HAVE_CONFIG_H -#include <config.h> -#endif - #include <stdio.h> #include <errno.h> #include <stdlib.h> @@ -41,7 +37,10 @@ (G_TYPE_INSTANCE_GET_PRIVATE \ ((obj), E_TYPE_TABLE_MEMORY, ETableMemoryPrivate)) -G_DEFINE_TYPE (ETableMemory, e_table_memory, E_TYPE_TABLE_MODEL) +G_DEFINE_TYPE ( + ETableMemory, + e_table_memory, + E_TYPE_TABLE_MODEL) struct _ETableMemoryPrivate { gpointer *data; @@ -63,9 +62,9 @@ table_memory_finalize (GObject *object) } static gint -table_memory_row_count (ETableModel *etm) +table_memory_row_count (ETableModel *table_model) { - ETableMemory *table_memory = E_TABLE_MEMORY (etm); + ETableMemory *table_memory = E_TABLE_MEMORY (table_model); return table_memory->priv->num_rows; } diff --git a/e-util/e-table-memory.h b/e-util/e-table-memory.h index e374fca5ca..db0809daf7 100644 --- a/e-util/e-table-memory.h +++ b/e-util/e-table-memory.h @@ -24,8 +24,8 @@ #error "Only <e-util/e-util.h> should be included directly." #endif -#ifndef _E_TABLE_MEMORY_H_ -#define _E_TABLE_MEMORY_H_ +#ifndef E_TABLE_MEMORY_H +#define E_TABLE_MEMORY_H #include <gdk-pixbuf/gdk-pixbuf.h> @@ -88,4 +88,4 @@ void e_table_memory_set_data (ETableMemory *table_memory, G_END_DECLS -#endif /* _E_TABLE_MEMORY_H */ +#endif /* E_TABLE_MEMORY_H */ diff --git a/e-util/e-table-model.c b/e-util/e-table-model.c index 1ae4d3e81b..7f9477b0f2 100644 --- a/e-util/e-table-model.c +++ b/e-util/e-table-model.c @@ -1,4 +1,5 @@ /* + * e-table-model.c * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -13,25 +14,10 @@ * You should have received a copy of the GNU Lesser General Public * License along with the program; if not, see <http://www.gnu.org/licenses/> * - * - * Authors: - * Chris Lahey <clahey@ximian.com> - * - * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com) - * */ -#ifdef HAVE_CONFIG_H -#include <config.h> -#endif - #include "e-table-model.h" -#include "e-marshal.h" - -#define ETM_FROZEN(e) \ - (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (e), "frozen")) != 0) - #define d(x) d (static gint depth = 0;) @@ -52,74 +38,158 @@ enum { static guint signals[LAST_SIGNAL] = { 0, }; +static gint +table_model_is_frozen (ETableModel *table_model) +{ + gpointer data; + + data = g_object_get_data (G_OBJECT (table_model), "frozen"); + + return (GPOINTER_TO_INT (data) != 0); +} + +static void +e_table_model_class_init (ETableModelClass *class) +{ + GObjectClass *object_class = G_OBJECT_CLASS (class); + + signals[MODEL_NO_CHANGE] = g_signal_new ( + "model_no_change", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETableModelClass, model_no_change), + NULL, NULL, NULL, + G_TYPE_NONE, 0); + + signals[MODEL_CHANGED] = g_signal_new ( + "model_changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETableModelClass, model_changed), + NULL, NULL, NULL, + G_TYPE_NONE, 0); + + signals[MODEL_PRE_CHANGE] = g_signal_new ( + "model_pre_change", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETableModelClass, model_pre_change), + NULL, NULL, NULL, + G_TYPE_NONE, 0); + + signals[MODEL_ROW_CHANGED] = g_signal_new ( + "model_row_changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETableModelClass, model_row_changed), + NULL, NULL, NULL, + G_TYPE_NONE, 1, + G_TYPE_INT); + + signals[MODEL_CELL_CHANGED] = g_signal_new ( + "model_cell_changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETableModelClass, model_cell_changed), + NULL, NULL, NULL, + G_TYPE_NONE, 2, + G_TYPE_INT, + G_TYPE_INT); + + signals[MODEL_ROWS_INSERTED] = g_signal_new ( + "model_rows_inserted", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETableModelClass, model_rows_inserted), + NULL, NULL, NULL, + G_TYPE_NONE, 2, + G_TYPE_INT, + G_TYPE_INT); + + signals[MODEL_ROWS_DELETED] = g_signal_new ( + "model_rows_deleted", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETableModelClass, model_rows_deleted), + NULL, NULL, NULL, + G_TYPE_NONE, 2, + G_TYPE_INT, + G_TYPE_INT); +} + +static void +e_table_model_init (ETableModel *table_model) +{ +} + /** * e_table_model_column_count: - * @e_table_model: The e-table-model to operate on + * @table_model: The e-table-model to operate on * * Returns: the number of columns in the table model. */ gint -e_table_model_column_count (ETableModel *e_table_model) +e_table_model_column_count (ETableModel *table_model) { ETableModelClass *class; - g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), 0); + g_return_val_if_fail (E_IS_TABLE_MODEL (table_model), 0); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); g_return_val_if_fail (class->column_count != NULL, 0); - return class->column_count (e_table_model); + return class->column_count (table_model); } /** * e_table_model_row_count: - * @e_table_model: the e-table-model to operate on + * @table_model: the e-table-model to operate on * * Returns: the number of rows in the Table model. */ gint -e_table_model_row_count (ETableModel *e_table_model) +e_table_model_row_count (ETableModel *table_model) { ETableModelClass *class; - g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), 0); + g_return_val_if_fail (E_IS_TABLE_MODEL (table_model), 0); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); g_return_val_if_fail (class->row_count != NULL, 0); - return class->row_count (e_table_model); + return class->row_count (table_model); } /** * e_table_model_append_row: - * @e_table_model: the table model to append the a row to. + * @table_model: the table model to append the a row to. * @source: * @row: * */ void -e_table_model_append_row (ETableModel *e_table_model, +e_table_model_append_row (ETableModel *table_model, ETableModel *source, gint row) { ETableModelClass *class; - g_return_if_fail (E_IS_TABLE_MODEL (e_table_model)); + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); if (class->append_row != NULL) - class->append_row (e_table_model, source, row); + class->append_row (table_model, source, row); } /** * e_table_value_at: - * @e_table_model: the e-table-model to operate on + * @table_model: the e-table-model to operate on * @col: column in the model to pull data from. * @row: row in the model to pull data from. * * Return value: This function returns the value that is stored - * by the @e_table_model in column @col and row @row. The data + * by the @table_model in column @col and row @row. The data * returned can be a pointer or any data value that can be stored * inside a pointer. * @@ -132,29 +202,29 @@ e_table_model_append_row (ETableModel *e_table_model, * rows_inserted and no_change don't affect any data in this way. **/ gpointer -e_table_model_value_at (ETableModel *e_table_model, +e_table_model_value_at (ETableModel *table_model, gint col, gint row) { ETableModelClass *class; - g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), NULL); + g_return_val_if_fail (E_IS_TABLE_MODEL (table_model), NULL); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); g_return_val_if_fail (class->value_at != NULL, NULL); - return class->value_at (e_table_model, col, row); + return class->value_at (table_model, col, row); } /** * e_table_model_set_value_at: - * @e_table_model: the table model to operate on. + * @table_model: the table model to operate on. * @col: the column where the data will be stored in the model. * @row: the row where the data will be stored in the model. * @value: the data to be stored. * * This function instructs the model to store the value in @data in the - * the @e_table_model at column @col and row @row. The @data typically + * the @table_model at column @col and row @row. The @data typically * comes from one of the ECell rendering objects. * * There should be an agreement between the Table Model and the user @@ -162,279 +232,171 @@ e_table_model_value_at (ETableModel *e_table_model, * be a pointer to a set of data, or a datum that fits inside a gpointer . */ void -e_table_model_set_value_at (ETableModel *e_table_model, +e_table_model_set_value_at (ETableModel *table_model, gint col, gint row, gconstpointer value) { ETableModelClass *class; - g_return_if_fail (E_IS_TABLE_MODEL (e_table_model)); + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); g_return_if_fail (class->set_value_at != NULL); - class->set_value_at (e_table_model, col, row, value); + class->set_value_at (table_model, col, row, value); } /** * e_table_model_is_cell_editable: - * @e_table_model: the table model to query. + * @table_model: the table model to query. * @col: column to query. * @row: row to query. * - * Returns: %TRUE if the cell in @e_table_model at @col,@row can be + * Returns: %TRUE if the cell in @table_model at @col,@row can be * edited, %FALSE otherwise */ gboolean -e_table_model_is_cell_editable (ETableModel *e_table_model, +e_table_model_is_cell_editable (ETableModel *table_model, gint col, gint row) { ETableModelClass *class; - g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), FALSE); + g_return_val_if_fail (E_IS_TABLE_MODEL (table_model), FALSE); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); g_return_val_if_fail (class->is_cell_editable != NULL, FALSE); - return class->is_cell_editable (e_table_model, col, row); + return class->is_cell_editable (table_model, col, row); } gpointer -e_table_model_duplicate_value (ETableModel *e_table_model, +e_table_model_duplicate_value (ETableModel *table_model, gint col, gconstpointer value) { ETableModelClass *class; - g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), NULL); + g_return_val_if_fail (E_IS_TABLE_MODEL (table_model), NULL); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); if (class->duplicate_value == NULL) return NULL; - return class->duplicate_value (e_table_model, col, value); + return class->duplicate_value (table_model, col, value); } void -e_table_model_free_value (ETableModel *e_table_model, +e_table_model_free_value (ETableModel *table_model, gint col, gpointer value) { ETableModelClass *class; - g_return_if_fail (E_IS_TABLE_MODEL (e_table_model)); + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); if (class->free_value != NULL) - class->free_value (e_table_model, col, value); + class->free_value (table_model, col, value); } gboolean -e_table_model_has_save_id (ETableModel *e_table_model) +e_table_model_has_save_id (ETableModel *table_model) { ETableModelClass *class; - g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), FALSE); + g_return_val_if_fail (E_IS_TABLE_MODEL (table_model), FALSE); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); if (class->has_save_id == NULL) return FALSE; - return class->has_save_id (e_table_model); + return class->has_save_id (table_model); } gchar * -e_table_model_get_save_id (ETableModel *e_table_model, +e_table_model_get_save_id (ETableModel *table_model, gint row) { ETableModelClass *class; - g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), NULL); + g_return_val_if_fail (E_IS_TABLE_MODEL (table_model), NULL); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); if (class->get_save_id == NULL) return NULL; - return class->get_save_id (e_table_model, row); + return class->get_save_id (table_model, row); } gboolean -e_table_model_has_change_pending (ETableModel *e_table_model) +e_table_model_has_change_pending (ETableModel *table_model) { ETableModelClass *class; - g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), FALSE); + g_return_val_if_fail (E_IS_TABLE_MODEL (table_model), FALSE); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); if (class->has_change_pending == NULL) return FALSE; - return class->has_change_pending (e_table_model); + return class->has_change_pending (table_model); } gpointer -e_table_model_initialize_value (ETableModel *e_table_model, +e_table_model_initialize_value (ETableModel *table_model, gint col) { ETableModelClass *class; - g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), NULL); + g_return_val_if_fail (E_IS_TABLE_MODEL (table_model), NULL); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); if (class->initialize_value == NULL) return NULL; - return class->initialize_value (e_table_model, col); + return class->initialize_value (table_model, col); } gboolean -e_table_model_value_is_empty (ETableModel *e_table_model, +e_table_model_value_is_empty (ETableModel *table_model, gint col, gconstpointer value) { ETableModelClass *class; - g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), FALSE); + g_return_val_if_fail (E_IS_TABLE_MODEL (table_model), FALSE); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); if (class->value_is_empty == NULL) return FALSE; - return class->value_is_empty (e_table_model, col, value); + return class->value_is_empty (table_model, col, value); } gchar * -e_table_model_value_to_string (ETableModel *e_table_model, +e_table_model_value_to_string (ETableModel *table_model, gint col, gconstpointer value) { ETableModelClass *class; - g_return_val_if_fail (E_IS_TABLE_MODEL (e_table_model), NULL); + g_return_val_if_fail (E_IS_TABLE_MODEL (table_model), NULL); - class = E_TABLE_MODEL_GET_CLASS (e_table_model); + class = E_TABLE_MODEL_GET_CLASS (table_model); if (class->value_to_string == NULL) return g_strdup (""); - return class->value_to_string (e_table_model, col, value); -} - -static void -e_table_model_class_init (ETableModelClass *class) -{ - GObjectClass *object_class = G_OBJECT_CLASS (class); - - signals[MODEL_NO_CHANGE] = g_signal_new ( - "model_no_change", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (ETableModelClass, model_no_change), - (GSignalAccumulator) NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); - - signals[MODEL_CHANGED] = g_signal_new ( - "model_changed", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (ETableModelClass, model_changed), - (GSignalAccumulator) NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); - - signals[MODEL_PRE_CHANGE] = g_signal_new ( - "model_pre_change", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (ETableModelClass, model_pre_change), - (GSignalAccumulator) NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); - - signals[MODEL_ROW_CHANGED] = g_signal_new ( - "model_row_changed", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (ETableModelClass, model_row_changed), - (GSignalAccumulator) NULL, NULL, - g_cclosure_marshal_VOID__INT, - G_TYPE_NONE, 1, - G_TYPE_INT); - - signals[MODEL_CELL_CHANGED] = g_signal_new ( - "model_cell_changed", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (ETableModelClass, model_cell_changed), - (GSignalAccumulator) NULL, NULL, - e_marshal_VOID__INT_INT, - G_TYPE_NONE, 2, - G_TYPE_INT, - G_TYPE_INT); - - signals[MODEL_ROWS_INSERTED] = g_signal_new ( - "model_rows_inserted", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (ETableModelClass, model_rows_inserted), - (GSignalAccumulator) NULL, NULL, - e_marshal_VOID__INT_INT, - G_TYPE_NONE, 2, - G_TYPE_INT, - G_TYPE_INT); - - signals[MODEL_ROWS_DELETED] = g_signal_new ( - "model_rows_deleted", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (ETableModelClass, model_rows_deleted), - (GSignalAccumulator) NULL, NULL, - e_marshal_VOID__INT_INT, - G_TYPE_NONE, 2, - G_TYPE_INT, - G_TYPE_INT); - - class->column_count = NULL; - class->row_count = NULL; - class->append_row = NULL; - - class->value_at = NULL; - class->set_value_at = NULL; - class->is_cell_editable = NULL; - - class->has_save_id = NULL; - class->get_save_id = NULL; - - class->has_change_pending = NULL; - - class->duplicate_value = NULL; - class->free_value = NULL; - class->initialize_value = NULL; - class->value_is_empty = NULL; - class->value_to_string = NULL; - - class->model_no_change = NULL; - class->model_changed = NULL; - class->model_row_changed = NULL; - class->model_cell_changed = NULL; - class->model_rows_inserted = NULL; - class->model_rows_deleted = NULL; -} - -static void -e_table_model_init (ETableModel *e_table_model) -{ - /* nothing to do */ + return class->value_to_string (table_model, col, value); } #if d(!)0 @@ -448,26 +410,26 @@ print_tabs (void) #endif void -e_table_model_pre_change (ETableModel *e_table_model) +e_table_model_pre_change (ETableModel *table_model) { - g_return_if_fail (E_IS_TABLE_MODEL (e_table_model)); + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); - if (ETM_FROZEN (e_table_model)) + if (table_model_is_frozen (table_model)) return; d (print_tabs ()); d (depth++); - g_signal_emit (e_table_model, signals[MODEL_PRE_CHANGE], 0); + g_signal_emit (table_model, signals[MODEL_PRE_CHANGE], 0); d (depth--); } /** * e_table_model_no_change: - * @e_table_model: the table model to notify of the lack of a change + * @table_model: the table model to notify of the lack of a change * * Use this function to notify any views of this table model that * the contents of the table model have changed. This will emit - * the signal "model_no_change" on the @e_table_model object. + * the signal "model_no_change" on the @table_model object. * * It is preferable to use the e_table_model_row_changed() and * the e_table_model_cell_changed() to notify of smaller changes @@ -475,26 +437,26 @@ e_table_model_pre_change (ETableModel *e_table_model) * ways of caching the information they render from the model. */ void -e_table_model_no_change (ETableModel *e_table_model) +e_table_model_no_change (ETableModel *table_model) { - g_return_if_fail (E_IS_TABLE_MODEL (e_table_model)); + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); - if (ETM_FROZEN (e_table_model)) + if (table_model_is_frozen (table_model)) return; d (print_tabs ()); d (depth++); - g_signal_emit (e_table_model, signals[MODEL_NO_CHANGE], 0); + g_signal_emit (table_model, signals[MODEL_NO_CHANGE], 0); d (depth--); } /** * e_table_model_changed: - * @e_table_model: the table model to notify of the change + * @table_model: the table model to notify of the change * * Use this function to notify any views of this table model that * the contents of the table model have changed. This will emit - * the signal "model_changed" on the @e_table_model object. + * the signal "model_changed" on the @table_model object. * * It is preferable to use the e_table_model_row_changed() and * the e_table_model_cell_changed() to notify of smaller changes @@ -502,181 +464,189 @@ e_table_model_no_change (ETableModel *e_table_model) * ways of caching the information they render from the model. */ void -e_table_model_changed (ETableModel *e_table_model) +e_table_model_changed (ETableModel *table_model) { - g_return_if_fail (E_IS_TABLE_MODEL (e_table_model)); + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); - if (ETM_FROZEN (e_table_model)) + if (table_model_is_frozen (table_model)) return; d (print_tabs ()); d (depth++); - g_signal_emit (e_table_model, signals[MODEL_CHANGED], 0); + g_signal_emit (table_model, signals[MODEL_CHANGED], 0); d (depth--); } /** * e_table_model_row_changed: - * @e_table_model: the table model to notify of the change + * @table_model: the table model to notify of the change * @row: the row that was changed in the model. * * Use this function to notify any views of the table model that * the contents of row @row have changed in model. This function - * will emit the "model_row_changed" signal on the @e_table_model + * will emit the "model_row_changed" signal on the @table_model * object */ void -e_table_model_row_changed (ETableModel *e_table_model, +e_table_model_row_changed (ETableModel *table_model, gint row) { - g_return_if_fail (E_IS_TABLE_MODEL (e_table_model)); + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); - if (ETM_FROZEN (e_table_model)) + if (table_model_is_frozen (table_model)) return; d (print_tabs ()); d (depth++); - g_signal_emit (e_table_model, signals[MODEL_ROW_CHANGED], 0, row); + g_signal_emit (table_model, signals[MODEL_ROW_CHANGED], 0, row); d (depth--); } /** * e_table_model_cell_changed: - * @e_table_model: the table model to notify of the change + * @table_model: the table model to notify of the change * @col: the column. * @row: the row * * Use this function to notify any views of the table model that * contents of the cell at @col,@row has changed. This will emit - * the "model_cell_changed" signal on the @e_table_model + * the "model_cell_changed" signal on the @table_model * object */ void -e_table_model_cell_changed (ETableModel *e_table_model, +e_table_model_cell_changed (ETableModel *table_model, gint col, gint row) { - g_return_if_fail (E_IS_TABLE_MODEL (e_table_model)); + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); - if (ETM_FROZEN (e_table_model)) + if (table_model_is_frozen (table_model)) return; d (print_tabs ()); d (depth++); g_signal_emit ( - e_table_model, signals[MODEL_CELL_CHANGED], 0, col, row); + table_model, signals[MODEL_CELL_CHANGED], 0, col, row); d (depth--); } /** * e_table_model_rows_inserted: - * @e_table_model: the table model to notify of the change + * @table_model: the table model to notify of the change * @row: the row that was inserted into the model. * @count: The number of rows that were inserted. * * Use this function to notify any views of the table model that * @count rows at row @row have been inserted into the model. This * function will emit the "model_rows_inserted" signal on the - * @e_table_model object + * @table_model object */ void -e_table_model_rows_inserted (ETableModel *e_table_model, +e_table_model_rows_inserted (ETableModel *table_model, gint row, gint count) { - g_return_if_fail (E_IS_TABLE_MODEL (e_table_model)); + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); - if (ETM_FROZEN (e_table_model)) + if (table_model_is_frozen (table_model)) return; d (print_tabs ()); d (depth++); g_signal_emit ( - e_table_model, signals[MODEL_ROWS_INSERTED], 0, row, count); + table_model, signals[MODEL_ROWS_INSERTED], 0, row, count); d (depth--); } /** * e_table_model_row_inserted: - * @e_table_model: the table model to notify of the change + * @table_model: the table model to notify of the change * @row: the row that was inserted into the model. * * Use this function to notify any views of the table model that the * row @row has been inserted into the model. This function will emit - * the "model_rows_inserted" signal on the @e_table_model object + * the "model_rows_inserted" signal on the @table_model object */ void -e_table_model_row_inserted (ETableModel *e_table_model, +e_table_model_row_inserted (ETableModel *table_model, gint row) { - e_table_model_rows_inserted (e_table_model, row, 1); + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); + + e_table_model_rows_inserted (table_model, row, 1); } /** * e_table_model_row_deleted: - * @e_table_model: the table model to notify of the change + * @table_model: the table model to notify of the change * @row: the row that was deleted * @count: The number of rows deleted * * Use this function to notify any views of the table model that * @count rows at row @row have been deleted from the model. This * function will emit the "model_rows_deleted" signal on the - * @e_table_model object + * @table_model object */ void -e_table_model_rows_deleted (ETableModel *e_table_model, +e_table_model_rows_deleted (ETableModel *table_model, gint row, gint count) { - g_return_if_fail (E_IS_TABLE_MODEL (e_table_model)); + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); - if (ETM_FROZEN (e_table_model)) + if (table_model_is_frozen (table_model)) return; d (print_tabs ()); d (depth++); g_signal_emit ( - e_table_model, signals[MODEL_ROWS_DELETED], 0, row, count); + table_model, signals[MODEL_ROWS_DELETED], 0, row, count); d (depth--); } /** * e_table_model_row_deleted: - * @e_table_model: the table model to notify of the change + * @table_model: the table model to notify of the change * @row: the row that was deleted * * Use this function to notify any views of the table model that the * row @row has been deleted from the model. This function will emit - * the "model_rows_deleted" signal on the @e_table_model object + * the "model_rows_deleted" signal on the @table_model object */ void -e_table_model_row_deleted (ETableModel *e_table_model, +e_table_model_row_deleted (ETableModel *table_model, gint row) { - e_table_model_rows_deleted (e_table_model, row, 1); + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); + + e_table_model_rows_deleted (table_model, row, 1); } void -e_table_model_freeze (ETableModel *e_table_model) +e_table_model_freeze (ETableModel *table_model) { - e_table_model_pre_change (e_table_model); + gpointer data; - /* FIXME This expression is awesome! */ - g_object_set_data ( - G_OBJECT (e_table_model), "frozen", - GINT_TO_POINTER (GPOINTER_TO_INT ( - g_object_get_data (G_OBJECT (e_table_model), "frozen")) + 1)); + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); + + e_table_model_pre_change (table_model); + + data = g_object_get_data (G_OBJECT (table_model), "frozen"); + data = GINT_TO_POINTER (GPOINTER_TO_INT (data) + 1); + g_object_set_data (G_OBJECT (table_model), "frozen", data); } void -e_table_model_thaw (ETableModel *e_table_model) +e_table_model_thaw (ETableModel *table_model) { - /* FIXME This expression is awesome! */ - g_object_set_data ( - G_OBJECT (e_table_model), "frozen", - GINT_TO_POINTER (GPOINTER_TO_INT ( - g_object_get_data (G_OBJECT (e_table_model), "frozen")) - 1)); + gpointer data; + + g_return_if_fail (E_IS_TABLE_MODEL (table_model)); + + data = g_object_get_data (G_OBJECT (table_model), "frozen"); + data = GINT_TO_POINTER (GPOINTER_TO_INT (data) - 1); + g_object_set_data (G_OBJECT (table_model), "frozen", data); - e_table_model_changed (e_table_model); + e_table_model_changed (table_model); } diff --git a/e-util/e-table-model.h b/e-util/e-table-model.h index 3ed188e11c..60fc11c53c 100644 --- a/e-util/e-table-model.h +++ b/e-util/e-table-model.h @@ -1,4 +1,5 @@ /* + * e-table-model.h * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -13,20 +14,14 @@ * You should have received a copy of the GNU Lesser General Public * License along with the program; if not, see <http://www.gnu.org/licenses/> * - * - * Authors: - * Chris Lahey <clahey@ximian.com> - * - * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com) - * */ #if !defined (__E_UTIL_H_INSIDE__) && !defined (LIBEUTIL_COMPILATION) #error "Only <e-util/e-util.h> should be included directly." #endif -#ifndef _E_TABLE_MODEL_H_ -#define _E_TABLE_MODEL_H_ +#ifndef E_TABLE_MODEL_H +#define E_TABLE_MODEL_H #include <glib-object.h> @@ -61,49 +56,46 @@ struct _ETableModel { struct _ETableModelClass { GObjectClass parent_class; - /* - * Virtual methods - */ - gint (*column_count) (ETableModel *etm); - gint (*row_count) (ETableModel *etm); - void (*append_row) (ETableModel *etm, + gint (*column_count) (ETableModel *table_model); + gint (*row_count) (ETableModel *table_model); + void (*append_row) (ETableModel *table_model, ETableModel *source, gint row); - gpointer (*value_at) (ETableModel *etm, + gpointer (*value_at) (ETableModel *table_model, gint col, gint row); - void (*set_value_at) (ETableModel *etm, + void (*set_value_at) (ETableModel *table_model, gint col, gint row, gconstpointer value); - gboolean (*is_cell_editable) (ETableModel *etm, + gboolean (*is_cell_editable) (ETableModel *table_model, gint col, gint row); - gboolean (*has_save_id) (ETableModel *etm); - gchar * (*get_save_id) (ETableModel *etm, + gboolean (*has_save_id) (ETableModel *table_model); + gchar * (*get_save_id) (ETableModel *table_model, gint row); - gboolean (*has_change_pending) (ETableModel *etm); + gboolean (*has_change_pending) (ETableModel *table_model); /* Allocate a copy of the given value. */ - gpointer (*duplicate_value) (ETableModel *etm, + gpointer (*duplicate_value) (ETableModel *table_model, gint col, gconstpointer value); /* Free an allocated value. */ - void (*free_value) (ETableModel *etm, + void (*free_value) (ETableModel *table_model, gint col, gpointer value); /* Return an allocated empty value. */ - gpointer (*initialize_value) (ETableModel *etm, + gpointer (*initialize_value) (ETableModel *table_model, gint col); /* Return TRUE if value is equivalent to an empty cell. */ - gboolean (*value_is_empty) (ETableModel *etm, + gboolean (*value_is_empty) (ETableModel *table_model, gint col, gconstpointer value); /* Return an allocated string. */ - gchar * (*value_to_string) (ETableModel *etm, + gchar * (*value_to_string) (ETableModel *table_model, gint col, gconstpointer value); @@ -120,19 +112,19 @@ struct _ETableModelClass { * A row inserted: row_inserted * A row deleted: row_deleted */ - void (*model_pre_change) (ETableModel *etm); + void (*model_pre_change) (ETableModel *table_model); - void (*model_no_change) (ETableModel *etm); - void (*model_changed) (ETableModel *etm); - void (*model_row_changed) (ETableModel *etm, + void (*model_no_change) (ETableModel *table_model); + void (*model_changed) (ETableModel *table_model); + void (*model_row_changed) (ETableModel *table_model, gint row); - void (*model_cell_changed) (ETableModel *etm, + void (*model_cell_changed) (ETableModel *table_model, gint col, gint row); - void (*model_rows_inserted) (ETableModel *etm, + void (*model_rows_inserted) (ETableModel *table_model, gint row, gint count); - void (*model_rows_deleted) (ETableModel *etm, + void (*model_rows_deleted) (ETableModel *table_model, gint row, gint count); }; @@ -140,78 +132,78 @@ struct _ETableModelClass { GType e_table_model_get_type (void) G_GNUC_CONST; /**/ -gint e_table_model_column_count (ETableModel *e_table_model); -const gchar * e_table_model_column_name (ETableModel *e_table_model, +gint e_table_model_column_count (ETableModel *table_model); +const gchar * e_table_model_column_name (ETableModel *table_model, gint col); -gint e_table_model_row_count (ETableModel *e_table_model); -void e_table_model_append_row (ETableModel *e_table_model, +gint e_table_model_row_count (ETableModel *table_model); +void e_table_model_append_row (ETableModel *table_model, ETableModel *source, gint row); /**/ -gpointer e_table_model_value_at (ETableModel *e_table_model, +gpointer e_table_model_value_at (ETableModel *table_model, gint col, gint row); -void e_table_model_set_value_at (ETableModel *e_table_model, +void e_table_model_set_value_at (ETableModel *table_model, gint col, gint row, gconstpointer value); -gboolean e_table_model_is_cell_editable (ETableModel *e_table_model, +gboolean e_table_model_is_cell_editable (ETableModel *table_model, gint col, gint row); /**/ -gboolean e_table_model_has_save_id (ETableModel *etm); -gchar * e_table_model_get_save_id (ETableModel *etm, +gboolean e_table_model_has_save_id (ETableModel *table_model); +gchar * e_table_model_get_save_id (ETableModel *table_model, gint row); /**/ gboolean e_table_model_has_change_pending - (ETableModel *etm); + (ETableModel *table_model); /**/ -gpointer e_table_model_duplicate_value (ETableModel *e_table_model, +gpointer e_table_model_duplicate_value (ETableModel *table_model, gint col, gconstpointer value); -void e_table_model_free_value (ETableModel *e_table_model, +void e_table_model_free_value (ETableModel *table_model, gint col, gpointer value); -gpointer e_table_model_initialize_value (ETableModel *e_table_model, +gpointer e_table_model_initialize_value (ETableModel *table_model, gint col); -gboolean e_table_model_value_is_empty (ETableModel *e_table_model, +gboolean e_table_model_value_is_empty (ETableModel *table_model, gint col, gconstpointer value); -gchar * e_table_model_value_to_string (ETableModel *e_table_model, +gchar * e_table_model_value_to_string (ETableModel *table_model, gint col, gconstpointer value); /* * Routines for emitting signals on the e_table */ -void e_table_model_pre_change (ETableModel *e_table_model); -void e_table_model_no_change (ETableModel *e_table_model); -void e_table_model_changed (ETableModel *e_table_model); -void e_table_model_row_changed (ETableModel *e_table_model, +void e_table_model_pre_change (ETableModel *table_model); +void e_table_model_no_change (ETableModel *table_model); +void e_table_model_changed (ETableModel *table_model); +void e_table_model_row_changed (ETableModel *table_model, gint row); -void e_table_model_cell_changed (ETableModel *e_table_model, +void e_table_model_cell_changed (ETableModel *table_model, gint col, gint row); -void e_table_model_rows_inserted (ETableModel *e_table_model, +void e_table_model_rows_inserted (ETableModel *table_model, gint row, gint count); -void e_table_model_rows_deleted (ETableModel *e_table_model, +void e_table_model_rows_deleted (ETableModel *table_model, gint row, gint count); /**/ -void e_table_model_row_inserted (ETableModel *e_table_model, +void e_table_model_row_inserted (ETableModel *table_model, gint row); -void e_table_model_row_deleted (ETableModel *e_table_model, +void e_table_model_row_deleted (ETableModel *table_model, gint row); -void e_table_model_freeze (ETableModel *e_table_model); -void e_table_model_thaw (ETableModel *e_table_model); +void e_table_model_freeze (ETableModel *table_model); +void e_table_model_thaw (ETableModel *table_model); G_END_DECLS -#endif /* _E_TABLE_MODEL_H_ */ +#endif /* E_TABLE_MODEL_H */ diff --git a/e-util/e-table-one.c b/e-util/e-table-one.c index db9c27e4d1..242484fdfa 100644 --- a/e-util/e-table-one.c +++ b/e-util/e-table-one.c @@ -27,10 +27,39 @@ #include "e-table-one.h" -G_DEFINE_TYPE (ETableOne, e_table_one, E_TYPE_TABLE_MODEL) +G_DEFINE_TYPE ( + ETableOne, + e_table_one, + E_TYPE_TABLE_MODEL) + +static void +table_one_dispose (GObject *object) +{ + ETableOne *one = E_TABLE_ONE (object); + + if (one->data) { + gint i; + gint col_count; + + if (one->source) { + col_count = e_table_model_column_count (one->source); + + for (i = 0; i < col_count; i++) + e_table_model_free_value (one->source, i, one->data[i]); + } + + g_free (one->data); + } + one->data = NULL; + + g_clear_object (&one->source); + + /* Chain up to parent's dispose() method. */ + G_OBJECT_CLASS (e_table_one_parent_class)->dispose (object); +} static gint -one_column_count (ETableModel *etm) +table_one_column_count (ETableModel *etm) { ETableOne *one = E_TABLE_ONE (etm); @@ -41,15 +70,15 @@ one_column_count (ETableModel *etm) } static gint -one_row_count (ETableModel *etm) +table_one_row_count (ETableModel *etm) { return 1; } static gpointer -one_value_at (ETableModel *etm, - gint col, - gint row) +table_one_value_at (ETableModel *etm, + gint col, + gint row) { ETableOne *one = E_TABLE_ONE (etm); @@ -60,10 +89,10 @@ one_value_at (ETableModel *etm, } static void -one_set_value_at (ETableModel *etm, - gint col, - gint row, - gconstpointer val) +table_one_set_value_at (ETableModel *etm, + gint col, + gint row, + gconstpointer val) { ETableOne *one = E_TABLE_ONE (etm); @@ -74,9 +103,9 @@ one_set_value_at (ETableModel *etm, } static gboolean -one_is_cell_editable (ETableModel *etm, - gint col, - gint row) +table_one_is_cell_editable (ETableModel *etm, + gint col, + gint row) { ETableOne *one = E_TABLE_ONE (etm); @@ -88,9 +117,9 @@ one_is_cell_editable (ETableModel *etm, /* The default for one_duplicate_value is to return the raw value. */ static gpointer -one_duplicate_value (ETableModel *etm, - gint col, - gconstpointer value) +table_one_duplicate_value (ETableModel *etm, + gint col, + gconstpointer value) { ETableOne *one = E_TABLE_ONE (etm); @@ -101,9 +130,9 @@ one_duplicate_value (ETableModel *etm, } static void -one_free_value (ETableModel *etm, - gint col, - gpointer value) +table_one_free_value (ETableModel *etm, + gint col, + gpointer value) { ETableOne *one = E_TABLE_ONE (etm); @@ -112,8 +141,8 @@ one_free_value (ETableModel *etm, } static gpointer -one_initialize_value (ETableModel *etm, - gint col) +table_one_initialize_value (ETableModel *etm, + gint col) { ETableOne *one = E_TABLE_ONE (etm); @@ -124,9 +153,9 @@ one_initialize_value (ETableModel *etm, } static gboolean -one_value_is_empty (ETableModel *etm, - gint col, - gconstpointer value) +table_one_value_is_empty (ETableModel *etm, + gint col, + gconstpointer value) { ETableOne *one = E_TABLE_ONE (etm); @@ -137,9 +166,9 @@ one_value_is_empty (ETableModel *etm, } static gchar * -one_value_to_string (ETableModel *etm, - gint col, - gconstpointer value) +table_one_value_to_string (ETableModel *etm, + gint col, + gconstpointer value) { ETableOne *one = E_TABLE_ONE (etm); @@ -150,64 +179,30 @@ one_value_to_string (ETableModel *etm, } static void -one_finalize (GObject *object) -{ - G_OBJECT_CLASS (e_table_one_parent_class)->finalize (object); -} - -static void -one_dispose (GObject *object) +e_table_one_class_init (ETableOneClass *class) { - ETableOne *one = E_TABLE_ONE (object); - - if (one->data) { - gint i; - gint col_count; - - if (one->source) { - col_count = e_table_model_column_count (one->source); - - for (i = 0; i < col_count; i++) - e_table_model_free_value (one->source, i, one->data[i]); - } - - g_free (one->data); - } - one->data = NULL; - - if (one->source) - g_object_unref (one->source); - one->source = NULL; + GObjectClass *object_class; + ETableModelClass *model_class; - G_OBJECT_CLASS (e_table_one_parent_class)->dispose (object); -} + object_class = G_OBJECT_CLASS (class); + object_class->dispose = table_one_dispose; -static void -e_table_one_class_init (ETableOneClass *class) -{ - GObjectClass *object_class = G_OBJECT_CLASS (class); - ETableModelClass *model_class = E_TABLE_MODEL_CLASS (class); - - model_class->column_count = one_column_count; - model_class->row_count = one_row_count; - model_class->value_at = one_value_at; - model_class->set_value_at = one_set_value_at; - model_class->is_cell_editable = one_is_cell_editable; - model_class->duplicate_value = one_duplicate_value; - model_class->free_value = one_free_value; - model_class->initialize_value = one_initialize_value; - model_class->value_is_empty = one_value_is_empty; - model_class->value_to_string = one_value_to_string; - - object_class->dispose = one_dispose; - object_class->finalize = one_finalize; + model_class = E_TABLE_MODEL_CLASS (class); + model_class->column_count = table_one_column_count; + model_class->row_count = table_one_row_count; + model_class->value_at = table_one_value_at; + model_class->set_value_at = table_one_set_value_at; + model_class->is_cell_editable = table_one_is_cell_editable; + model_class->duplicate_value = table_one_duplicate_value; + model_class->free_value = table_one_free_value; + model_class->initialize_value = table_one_initialize_value; + model_class->value_is_empty = table_one_value_is_empty; + model_class->value_to_string = table_one_value_to_string; } static void e_table_one_init (ETableOne *one) { - one->source = NULL; - one->data = NULL; } ETableModel * diff --git a/e-util/e-table-sorted-variable.c b/e-util/e-table-sorted-variable.c index 17c10d5328..e01f940b2c 100644 --- a/e-util/e-table-sorted-variable.c +++ b/e-util/e-table-sorted-variable.c @@ -37,9 +37,10 @@ /* maximum insertions between an idle event that we will do without scheduling an idle sort */ #define ETSV_INSERT_MAX (4) -/* workaround for avoiding API breakage */ -#define etsv_get_type e_table_sorted_variable_get_type -G_DEFINE_TYPE (ETableSortedVariable, etsv, E_TYPE_TABLE_SUBSET_VARIABLE) +G_DEFINE_TYPE ( + ETableSortedVariable, + e_table_sorted_variable, + E_TYPE_TABLE_SUBSET_VARIABLE) static void etsv_sort_info_changed (ETableSortInfo *info, ETableSortedVariable *etsv); static void etsv_sort (ETableSortedVariable *etsv); @@ -74,11 +75,11 @@ etsv_dispose (GObject *object) g_object_unref (etsv->full_header); etsv->full_header = NULL; - G_OBJECT_CLASS (etsv_parent_class)->dispose (object); + G_OBJECT_CLASS (e_table_sorted_variable_parent_class)->dispose (object); } static void -etsv_class_init (ETableSortedVariableClass *class) +e_table_sorted_variable_class_init (ETableSortedVariableClass *class) { ETableSubsetVariableClass *etssv_class = E_TABLE_SUBSET_VARIABLE_CLASS (class); GObjectClass *object_class = G_OBJECT_CLASS (class); @@ -90,7 +91,7 @@ etsv_class_init (ETableSortedVariableClass *class) } static void -etsv_init (ETableSortedVariable *etsv) +e_table_sorted_variable_init (ETableSortedVariable *etsv) { etsv->full_header = NULL; etsv->sort_info = NULL; @@ -127,8 +128,11 @@ etsv_add (ETableSubsetVariable *etssv, ETableModel *etm = E_TABLE_MODEL (etssv); ETableSubset *etss = E_TABLE_SUBSET (etssv); ETableSortedVariable *etsv = E_TABLE_SORTED_VARIABLE (etssv); + ETableModel *source_model; gint i; + source_model = e_table_subset_get_source_model (etss); + e_table_model_pre_change (etm); if (etss->n_map + 1 > etssv->n_vals_allocated) { @@ -148,7 +152,7 @@ etsv_add (ETableSubsetVariable *etssv, if (etsv->insert_idle_id == 0) { etsv->insert_idle_id = g_idle_add_full (40, (GSourceFunc) etsv_insert_idle, etsv, NULL); } - i = e_table_sorting_utils_insert (etss->source, etsv->sort_info, etsv->full_header, etss->map_table, etss->n_map, row); + i = e_table_sorting_utils_insert (source_model, etsv->sort_info, etsv->full_header, etss->map_table, etss->n_map, row); memmove (etss->map_table + i + 1, etss->map_table + i, (etss->n_map - i) * sizeof (gint)); } } @@ -164,12 +168,14 @@ etsv_add_all (ETableSubsetVariable *etssv) ETableModel *etm = E_TABLE_MODEL (etssv); ETableSubset *etss = E_TABLE_SUBSET (etssv); ETableSortedVariable *etsv = E_TABLE_SORTED_VARIABLE (etssv); + ETableModel *source_model; gint rows; gint i; e_table_model_pre_change (etm); - rows = e_table_model_row_count (etss->source); + source_model = e_table_subset_get_source_model (etss); + rows = e_table_model_row_count (source_model); if (etss->n_map + rows > etssv->n_vals_allocated) { etssv->n_vals_allocated += MAX (INCREMENT_AMOUNT, rows); @@ -221,14 +227,17 @@ static void etsv_sort (ETableSortedVariable *etsv) { ETableSubset *etss = E_TABLE_SUBSET (etsv); + ETableModel *source_model; static gint reentering = 0; + if (reentering) return; reentering = 1; e_table_model_pre_change (E_TABLE_MODEL (etsv)); - e_table_sorting_utils_sort (etss->source, etsv->sort_info, etsv->full_header, etss->map_table, etss->n_map); + source_model = e_table_subset_get_source_model (etss); + e_table_sorting_utils_sort (source_model, etsv->sort_info, etsv->full_header, etss->map_table, etss->n_map); e_table_model_changed (E_TABLE_MODEL (etsv)); reentering = 0; diff --git a/e-util/e-table-sorted.c b/e-util/e-table-sorted.c index 3f548d349b..f2b2b617cf 100644 --- a/e-util/e-table-sorted.c +++ b/e-util/e-table-sorted.c @@ -34,9 +34,7 @@ #define INCREMENT_AMOUNT 100 -/* workaround for avoding API breakage */ -#define ets_get_type e_table_sorted_get_type -G_DEFINE_TYPE (ETableSorted, ets, E_TYPE_TABLE_SUBSET) +G_DEFINE_TYPE (ETableSorted, e_table_sorted, E_TYPE_TABLE_SUBSET) /* maximum insertions between an idle event that we will do without scheduling an idle sort */ #define ETS_INSERT_MAX (4) @@ -74,11 +72,11 @@ ets_dispose (GObject *object) g_object_unref (ets->full_header); ets->full_header = NULL; - G_OBJECT_CLASS (ets_parent_class)->dispose (object); + G_OBJECT_CLASS (e_table_sorted_parent_class)->dispose (object); } static void -ets_class_init (ETableSortedClass *class) +e_table_sorted_class_init (ETableSortedClass *class) { ETableSubsetClass *etss_class = E_TABLE_SUBSET_CLASS (class); GObjectClass *object_class = G_OBJECT_CLASS (class); @@ -93,7 +91,7 @@ ets_class_init (ETableSortedClass *class) } static void -ets_init (ETableSorted *ets) +e_table_sorted_init (ETableSorted *ets) { ets->full_header = NULL; ets->sort_info = NULL; @@ -131,8 +129,8 @@ e_table_sorted_new (ETableModel *source, ETableSorted *ets = g_object_new (E_TYPE_TABLE_SORTED, NULL); ETableSubset *etss = E_TABLE_SUBSET (ets); - if (E_TABLE_SUBSET_CLASS (ets_parent_class)->proxy_model_pre_change) - (E_TABLE_SUBSET_CLASS (ets_parent_class)->proxy_model_pre_change) (etss, source); + if (E_TABLE_SUBSET_CLASS (e_table_sorted_parent_class)->proxy_model_pre_change) + (E_TABLE_SUBSET_CLASS (e_table_sorted_parent_class)->proxy_model_pre_change) (etss, source); if (e_table_subset_construct (etss, source, 0) == NULL) { g_object_unref (ets); @@ -190,8 +188,8 @@ ets_proxy_model_row_changed (ETableSubset *subset, if (!E_TABLE_SORTED (subset)->sort_idle_id) E_TABLE_SORTED (subset)->sort_idle_id = g_idle_add_full (50, (GSourceFunc) ets_sort_idle, subset, NULL); - if (E_TABLE_SUBSET_CLASS (ets_parent_class)->proxy_model_row_changed) - (E_TABLE_SUBSET_CLASS (ets_parent_class)->proxy_model_row_changed) (subset, source, row); + if (E_TABLE_SUBSET_CLASS (e_table_sorted_parent_class)->proxy_model_row_changed) + (E_TABLE_SUBSET_CLASS (e_table_sorted_parent_class)->proxy_model_row_changed) (subset, source, row); } static void @@ -203,8 +201,8 @@ ets_proxy_model_cell_changed (ETableSubset *subset, ETableSorted *ets = E_TABLE_SORTED (subset); if (e_table_sorting_utils_affects_sort (ets->sort_info, ets->full_header, col)) ets_proxy_model_row_changed (subset, source, row); - else if (E_TABLE_SUBSET_CLASS (ets_parent_class)->proxy_model_cell_changed) - (E_TABLE_SUBSET_CLASS (ets_parent_class)->proxy_model_cell_changed) (subset, source, col, row); + else if (E_TABLE_SUBSET_CLASS (e_table_sorted_parent_class)->proxy_model_cell_changed) + (E_TABLE_SUBSET_CLASS (e_table_sorted_parent_class)->proxy_model_cell_changed) (subset, source, col, row); } static void @@ -215,9 +213,12 @@ ets_proxy_model_rows_inserted (ETableSubset *etss, { ETableModel *etm = E_TABLE_MODEL (etss); ETableSorted *ets = E_TABLE_SORTED (etss); + ETableModel *source_model; gint i; gboolean full_change = FALSE; + source_model = e_table_subset_get_source_model (etss); + if (count == 0) { e_table_model_no_change (etm); return; @@ -250,7 +251,7 @@ ets_proxy_model_rows_inserted (ETableSubset *etss, if (ets->insert_idle_id == 0) { ets->insert_idle_id = g_idle_add_full (40, (GSourceFunc) ets_insert_idle, ets, NULL); } - i = e_table_sorting_utils_insert (etss->source, ets->sort_info, ets->full_header, etss->map_table, etss->n_map, row); + i = e_table_sorting_utils_insert (source_model, ets->sort_info, ets->full_header, etss->map_table, etss->n_map, row); memmove (etss->map_table + i + 1, etss->map_table + i, (etss->n_map - i) * sizeof (gint)); } } @@ -314,6 +315,8 @@ static void ets_sort (ETableSorted *ets) { ETableSubset *etss = E_TABLE_SUBSET (ets); + ETableModel *source_model; + static gint reentering = 0; if (reentering) return; @@ -321,7 +324,11 @@ ets_sort (ETableSorted *ets) e_table_model_pre_change (E_TABLE_MODEL (ets)); - e_table_sorting_utils_sort (etss->source, ets->sort_info, ets->full_header, etss->map_table, etss->n_map); + source_model = e_table_subset_get_source_model (etss); + + e_table_sorting_utils_sort ( + source_model, ets->sort_info, + ets->full_header, etss->map_table, etss->n_map); e_table_model_changed (E_TABLE_MODEL (ets)); reentering = 0; diff --git a/e-util/e-table-sorter.c b/e-util/e-table-sorter.c index f67b635cb8..0ff30db68b 100644 --- a/e-util/e-table-sorter.c +++ b/e-util/e-table-sorter.c @@ -39,9 +39,7 @@ enum { PROP_SORT_INFO }; -/* workaround for avoiding API breakage */ -#define ets_get_type e_table_sorter_get_type -G_DEFINE_TYPE (ETableSorter, ets, E_TYPE_SORTER) +G_DEFINE_TYPE (ETableSorter, e_table_sorter, E_TYPE_SORTER) #define INCREMENT_AMOUNT 100 @@ -116,7 +114,7 @@ ets_dispose (GObject *object) g_object_unref (ets->source); ets->source = NULL; - G_OBJECT_CLASS (ets_parent_class)->dispose (object); + G_OBJECT_CLASS (e_table_sorter_parent_class)->dispose (object); } static void @@ -168,7 +166,7 @@ ets_get_property (GObject *object, } static void -ets_class_init (ETableSorterClass *class) +e_table_sorter_class_init (ETableSorterClass *class) { GObjectClass *object_class = G_OBJECT_CLASS (class); ESorterClass *sorter_class = E_SORTER_CLASS (class); @@ -195,7 +193,7 @@ ets_class_init (ETableSorterClass *class) } static void -ets_init (ETableSorter *ets) +e_table_sorter_init (ETableSorter *ets) { ets->full_header = NULL; ets->sort_info = NULL; diff --git a/e-util/e-table-specification.c b/e-util/e-table-specification.c index b00db491aa..e109a840e5 100644 --- a/e-util/e-table-specification.c +++ b/e-util/e-table-specification.c @@ -37,9 +37,10 @@ #include "e-xml-utils.h" -/* workaround for avoiding API breakage */ -#define etsp_get_type e_table_specification_get_type -G_DEFINE_TYPE (ETableSpecification, etsp, G_TYPE_OBJECT) +G_DEFINE_TYPE ( + ETableSpecification, + e_table_specification, + G_TYPE_OBJECT) static void etsp_finalize (GObject *object) @@ -65,11 +66,11 @@ etsp_finalize (GObject *object) g_free (etsp->domain); etsp->domain = NULL; - G_OBJECT_CLASS (etsp_parent_class)->finalize (object); + G_OBJECT_CLASS (e_table_specification_parent_class)->finalize (object); } static void -etsp_class_init (ETableSpecificationClass *class) +e_table_specification_class_init (ETableSpecificationClass *class) { GObjectClass *object_class = G_OBJECT_CLASS (class); @@ -77,7 +78,7 @@ etsp_class_init (ETableSpecificationClass *class) } static void -etsp_init (ETableSpecification *etsp) +e_table_specification_init (ETableSpecification *etsp) { etsp->columns = NULL; etsp->state = NULL; diff --git a/e-util/e-table-subset-variable.c b/e-util/e-table-subset-variable.c index 8d9f3d0c8d..4750f168fa 100644 --- a/e-util/e-table-subset-variable.c +++ b/e-util/e-table-subset-variable.c @@ -31,9 +31,10 @@ #define ETSSV_CLASS(e) (E_TABLE_SUBSET_VARIABLE_GET_CLASS (e)) -/* workaround for avoiding API breakage */ -#define etssv_get_type e_table_subset_variable_get_type -G_DEFINE_TYPE (ETableSubsetVariable, etssv, E_TYPE_TABLE_SUBSET) +G_DEFINE_TYPE ( + ETableSubsetVariable, + e_table_subset_variable, + E_TYPE_TABLE_SUBSET) #define INCREMENT_AMOUNT 10 @@ -86,12 +87,15 @@ etssv_add_all (ETableSubsetVariable *etssv) { ETableModel *etm = E_TABLE_MODEL (etssv); ETableSubset *etss = E_TABLE_SUBSET (etssv); + ETableModel *source_model; gint rows; gint i; e_table_model_pre_change (etm); - rows = e_table_model_row_count (etss->source); + source_model = e_table_subset_get_source_model (etss); + rows = e_table_model_row_count (source_model); + if (etss->n_map + rows > etssv->n_vals_allocated) { etssv->n_vals_allocated += MAX (INCREMENT_AMOUNT, rows); etss->map_table = g_realloc ( @@ -129,7 +133,7 @@ etssv_remove (ETableSubsetVariable *etssv, } static void -etssv_class_init (ETableSubsetVariableClass *class) +e_table_subset_variable_class_init (ETableSubsetVariableClass *class) { class->add = etssv_add; class->add_array = etssv_add_array; @@ -138,7 +142,7 @@ etssv_class_init (ETableSubsetVariableClass *class) } static void -etssv_init (ETableSubsetVariable *etssv) +e_table_subset_variable_init (ETableSubsetVariable *etssv) { /* nothing to do */ } diff --git a/e-util/e-table-subset.c b/e-util/e-table-subset.c index 88532d03bd..92f71cedde 100644 --- a/e-util/e-table-subset.c +++ b/e-util/e-table-subset.c @@ -30,76 +30,63 @@ #include "e-table-subset.h" -static void etss_proxy_model_pre_change_real - (ETableSubset *etss, - ETableModel *etm); -static void etss_proxy_model_no_change_real (ETableSubset *etss, - ETableModel *etm); -static void etss_proxy_model_changed_real (ETableSubset *etss, - ETableModel *etm); -static void etss_proxy_model_row_changed_real - (ETableSubset *etss, - ETableModel *etm, - gint row); -static void etss_proxy_model_cell_changed_real - (ETableSubset *etss, - ETableModel *etm, - gint col, - gint row); -static void etss_proxy_model_rows_inserted_real - (ETableSubset *etss, - ETableModel *etm, - gint row, - gint count); -static void etss_proxy_model_rows_deleted_real - (ETableSubset *etss, - ETableModel *etm, - gint row, - gint count); +#define E_TABLE_SUBSET_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_TYPE_TABLE_SUBSET, ETableSubsetPrivate)) + +#define VALID_ROW(table_subset, row) \ + (row >= -1 && row < table_subset->n_map) +#define MAP_ROW(table_subset, row) \ + (row == -1 ? -1 : table_subset->map_table[row]) #define d(x) -/* workaround for avoding API breakage */ -#define etss_get_type e_table_subset_get_type -G_DEFINE_TYPE (ETableSubset, etss, E_TYPE_TABLE_MODEL) +struct _ETableSubsetPrivate { + ETableModel *source_model; + gulong table_model_pre_change_handler_id; + gulong table_model_no_change_handler_id; + gulong table_model_changed_handler_id; + gulong table_model_row_changed_handler_id; + gulong table_model_cell_changed_handler_id; + gulong table_model_rows_inserted_handler_id; + gulong table_model_rows_deleted_handler_id; -#define ETSS_CLASS(object) (E_TABLE_SUBSET_GET_CLASS(object)) + gint last_access; +}; -#define VALID_ROW(etss, row) (row >= -1 && row < etss->n_map) -#define MAP_ROW(etss, row) (row == -1 ? -1 : etss->map_table[row]) +G_DEFINE_TYPE (ETableSubset, e_table_subset, E_TYPE_TABLE_MODEL) static gint -etss_get_view_row (ETableSubset *etss, - gint row) +table_subset_get_view_row (ETableSubset *table_subset, + gint row) { - const gint n = etss->n_map; - const gint * const map_table = etss->map_table; + const gint n = table_subset->n_map; + const gint * const map_table = table_subset->map_table; gint i; - gint end = MIN (etss->n_map, etss->last_access + 10); - gint start = MAX (0, etss->last_access - 10); - gint initial = MAX (MIN (etss->last_access, end), start); + gint end = MIN ( + table_subset->n_map, + table_subset->priv->last_access + 10); + gint start = MAX (0, table_subset->priv->last_access - 10); + gint initial = MAX (MIN (table_subset->priv->last_access, end), start); for (i = initial; i < end; i++) { if (map_table[i] == row) { - d (g_print ("a) Found %d from %d\n", i, etss->last_access)); - etss->last_access = i; + table_subset->priv->last_access = i; return i; } } for (i = initial - 1; i >= start; i--) { if (map_table[i] == row) { - d (g_print ("b) Found %d from %d\n", i, etss->last_access)); - etss->last_access = i; + table_subset->priv->last_access = i; return i; } } for (i = 0; i < n; i++) { if (map_table[i] == row) { - d (g_print ("c) Found %d from %d\n", i, etss->last_access)); - etss->last_access = i; + table_subset->priv->last_access = i; return i; } } @@ -107,461 +94,572 @@ etss_get_view_row (ETableSubset *etss, } static void -etss_dispose (GObject *object) +table_subset_dispose (GObject *object) { - ETableSubset *etss = E_TABLE_SUBSET (object); + ETableSubsetPrivate *priv; + + priv = E_TABLE_SUBSET_GET_PRIVATE (object); - if (etss->source) { + if (priv->table_model_pre_change_handler_id > 0) { g_signal_handler_disconnect ( - etss->source, - etss->table_model_pre_change_id); + priv->source_model, + priv->table_model_pre_change_handler_id); + priv->table_model_pre_change_handler_id = 0; + } + + if (priv->table_model_no_change_handler_id > 0) { g_signal_handler_disconnect ( - etss->source, - etss->table_model_no_change_id); + priv->source_model, + priv->table_model_no_change_handler_id); + priv->table_model_no_change_handler_id = 0; + } + + if (priv->table_model_changed_handler_id > 0) { g_signal_handler_disconnect ( - etss->source, - etss->table_model_changed_id); + priv->source_model, + priv->table_model_changed_handler_id); + priv->table_model_changed_handler_id = 0; + } + + if (priv->table_model_row_changed_handler_id > 0) { g_signal_handler_disconnect ( - etss->source, - etss->table_model_row_changed_id); + priv->source_model, + priv->table_model_row_changed_handler_id); + priv->table_model_row_changed_handler_id = 0; + } + + if (priv->table_model_cell_changed_handler_id > 0) { g_signal_handler_disconnect ( - etss->source, - etss->table_model_cell_changed_id); + priv->source_model, + priv->table_model_cell_changed_handler_id); + priv->table_model_cell_changed_handler_id = 0; + } + + if (priv->table_model_rows_inserted_handler_id > 0) { g_signal_handler_disconnect ( - etss->source, - etss->table_model_rows_inserted_id); + priv->source_model, + priv->table_model_rows_inserted_handler_id); + priv->table_model_rows_inserted_handler_id = 0; + } + + if (priv->table_model_rows_deleted_handler_id > 0) { g_signal_handler_disconnect ( - etss->source, - etss->table_model_rows_deleted_id); + priv->source_model, + priv->table_model_rows_deleted_handler_id); + priv->table_model_rows_deleted_handler_id = 0; + } - g_object_unref (etss->source); - etss->source = NULL; + g_clear_object (&priv->source_model); - etss->table_model_changed_id = 0; - etss->table_model_row_changed_id = 0; - etss->table_model_cell_changed_id = 0; - etss->table_model_rows_inserted_id = 0; - etss->table_model_rows_deleted_id = 0; - } + /* Chain up to parent's dispose() method. */ + G_OBJECT_CLASS (e_table_subset_parent_class)->dispose (object); +} + +static void +table_subset_finalize (GObject *object) +{ + ETableSubset *table_subset; + + table_subset = E_TABLE_SUBSET (object); + + g_free (table_subset->map_table); + + /* Chain up to parent's finalize() method. */ + G_OBJECT_CLASS (e_table_subset_parent_class)->finalize (object); +} + +static void +table_subset_proxy_model_pre_change_real (ETableSubset *table_subset, + ETableModel *source_model) +{ + e_table_model_pre_change (E_TABLE_MODEL (table_subset)); +} - G_OBJECT_CLASS (etss_parent_class)->dispose (object); +static void +table_subset_proxy_model_no_change_real (ETableSubset *table_subset, + ETableModel *source_model) +{ + e_table_model_no_change (E_TABLE_MODEL (table_subset)); +} + +static void +table_subset_proxy_model_changed_real (ETableSubset *table_subset, + ETableModel *source_model) +{ + e_table_model_changed (E_TABLE_MODEL (table_subset)); +} + +static void +table_subset_proxy_model_row_changed_real (ETableSubset *table_subset, + ETableModel *source_model, + gint row) +{ + gint view_row = table_subset_get_view_row (table_subset, row); + + if (view_row != -1) + e_table_model_row_changed ( + E_TABLE_MODEL (table_subset), view_row); + else + e_table_model_no_change (E_TABLE_MODEL (table_subset)); } static void -etss_finalize (GObject *object) +table_subset_proxy_model_cell_changed_real (ETableSubset *table_subset, + ETableModel *source_model, + gint col, + gint row) { - ETableSubset *etss = E_TABLE_SUBSET (object); + gint view_row = table_subset_get_view_row (table_subset, row); + + if (view_row != -1) + e_table_model_cell_changed ( + E_TABLE_MODEL (table_subset), col, view_row); + else + e_table_model_no_change (E_TABLE_MODEL (table_subset)); +} - g_free (etss->map_table); - etss->map_table = NULL; +static void +table_subset_proxy_model_rows_inserted_real (ETableSubset *table_subset, + ETableModel *source_model, + gint row, + gint count) +{ + e_table_model_no_change (E_TABLE_MODEL (table_subset)); +} - G_OBJECT_CLASS (etss_parent_class)->finalize (object); +static void +table_subset_proxy_model_rows_deleted_real (ETableSubset *table_subset, + ETableModel *source_model, + gint row, + gint count) +{ + e_table_model_no_change (E_TABLE_MODEL (table_subset)); } static gint -etss_column_count (ETableModel *etm) +table_subset_column_count (ETableModel *table_model) { - ETableSubset *etss = (ETableSubset *) etm; + ETableSubset *table_subset = (ETableSubset *) table_model; - return e_table_model_column_count (etss->source); + return e_table_model_column_count (table_subset->priv->source_model); } static gint -etss_row_count (ETableModel *etm) +table_subset_row_count (ETableModel *table_model) { - ETableSubset *etss = (ETableSubset *) etm; + ETableSubset *table_subset = (ETableSubset *) table_model; - return etss->n_map; + return table_subset->n_map; } static gpointer -etss_value_at (ETableModel *etm, - gint col, - gint row) +table_subset_value_at (ETableModel *table_model, + gint col, + gint row) { - ETableSubset *etss = (ETableSubset *) etm; + ETableSubset *table_subset = (ETableSubset *) table_model; + + g_return_val_if_fail (VALID_ROW (table_subset, row), NULL); - g_return_val_if_fail (VALID_ROW (etss, row), NULL); + table_subset->priv->last_access = row; - etss->last_access = row; - d (g_print ("g) Setting last_access to %d\n", row)); - return e_table_model_value_at (etss->source, col, MAP_ROW (etss, row)); + return e_table_model_value_at ( + table_subset->priv->source_model, + col, MAP_ROW (table_subset, row)); } static void -etss_set_value_at (ETableModel *etm, - gint col, - gint row, - gconstpointer val) +table_subset_set_value_at (ETableModel *table_model, + gint col, + gint row, + gconstpointer val) { - ETableSubset *etss = (ETableSubset *) etm; + ETableSubset *table_subset = (ETableSubset *) table_model; - g_return_if_fail (VALID_ROW (etss, row)); + g_return_if_fail (VALID_ROW (table_subset, row)); - etss->last_access = row; - d (g_print ("h) Setting last_access to %d\n", row)); - e_table_model_set_value_at (etss->source, col, MAP_ROW (etss, row), val); + table_subset->priv->last_access = row; + + e_table_model_set_value_at ( + table_subset->priv->source_model, + col, MAP_ROW (table_subset, row), val); } static gboolean -etss_is_cell_editable (ETableModel *etm, - gint col, - gint row) +table_subset_is_cell_editable (ETableModel *table_model, + gint col, + gint row) { - ETableSubset *etss = (ETableSubset *) etm; + ETableSubset *table_subset = (ETableSubset *) table_model; - g_return_val_if_fail (VALID_ROW (etss, row), FALSE); + g_return_val_if_fail (VALID_ROW (table_subset, row), FALSE); - return e_table_model_is_cell_editable (etss->source, col, MAP_ROW (etss, row)); + return e_table_model_is_cell_editable ( + table_subset->priv->source_model, + col, MAP_ROW (table_subset, row)); } static gboolean -etss_has_save_id (ETableModel *etm) +table_subset_has_save_id (ETableModel *table_model) { return TRUE; } static gchar * -etss_get_save_id (ETableModel *etm, - gint row) +table_subset_get_save_id (ETableModel *table_model, + gint row) { - ETableSubset *etss = (ETableSubset *) etm; + ETableSubset *table_subset = (ETableSubset *) table_model; - g_return_val_if_fail (VALID_ROW (etss, row), NULL); + g_return_val_if_fail (VALID_ROW (table_subset, row), NULL); - if (e_table_model_has_save_id (etss->source)) - return e_table_model_get_save_id (etss->source, MAP_ROW (etss, row)); + if (e_table_model_has_save_id (table_subset->priv->source_model)) + return e_table_model_get_save_id ( + table_subset->priv->source_model, + MAP_ROW (table_subset, row)); else - return g_strdup_printf ("%d", MAP_ROW (etss, row)); + return g_strdup_printf ("%d", MAP_ROW (table_subset, row)); } static void -etss_append_row (ETableModel *etm, - ETableModel *source, - gint row) +table_subset_append_row (ETableModel *table_model, + ETableModel *source, + gint row) { - ETableSubset *etss = (ETableSubset *) etm; - e_table_model_append_row (etss->source, source, row); + ETableSubset *table_subset = (ETableSubset *) table_model; + + e_table_model_append_row ( + table_subset->priv->source_model, source, row); } static gpointer -etss_duplicate_value (ETableModel *etm, - gint col, - gconstpointer value) +table_subset_duplicate_value (ETableModel *table_model, + gint col, + gconstpointer value) { - ETableSubset *etss = (ETableSubset *) etm; + ETableSubset *table_subset = (ETableSubset *) table_model; - return e_table_model_duplicate_value (etss->source, col, value); + return e_table_model_duplicate_value ( + table_subset->priv->source_model, col, value); } static void -etss_free_value (ETableModel *etm, - gint col, - gpointer value) +table_subset_free_value (ETableModel *table_model, + gint col, + gpointer value) { - ETableSubset *etss = (ETableSubset *) etm; + ETableSubset *table_subset = (ETableSubset *) table_model; - e_table_model_free_value (etss->source, col, value); + e_table_model_free_value ( + table_subset->priv->source_model, col, value); } static gpointer -etss_initialize_value (ETableModel *etm, - gint col) +table_subset_initialize_value (ETableModel *table_model, + gint col) { - ETableSubset *etss = (ETableSubset *) etm; + ETableSubset *table_subset = (ETableSubset *) table_model; - return e_table_model_initialize_value (etss->source, col); + return e_table_model_initialize_value ( + table_subset->priv->source_model, col); } static gboolean -etss_value_is_empty (ETableModel *etm, - gint col, - gconstpointer value) +table_subset_value_is_empty (ETableModel *table_model, + gint col, + gconstpointer value) { - ETableSubset *etss = (ETableSubset *) etm; + ETableSubset *table_subset = (ETableSubset *) table_model; - return e_table_model_value_is_empty (etss->source, col, value); + return e_table_model_value_is_empty ( + table_subset->priv->source_model, col, value); } static gchar * -etss_value_to_string (ETableModel *etm, - gint col, - gconstpointer value) +table_subset_value_to_string (ETableModel *table_model, + gint col, + gconstpointer value) { - ETableSubset *etss = (ETableSubset *) etm; + ETableSubset *table_subset = (ETableSubset *) table_model; - return e_table_model_value_to_string (etss->source, col, value); + return e_table_model_value_to_string ( + table_subset->priv->source_model, col, value); } static void -etss_class_init (ETableSubsetClass *class) -{ - ETableModelClass *table_class = E_TABLE_MODEL_CLASS (class); - GObjectClass *object_class = G_OBJECT_CLASS (class); - - object_class->dispose = etss_dispose; - object_class->finalize = etss_finalize; - - table_class->column_count = etss_column_count; - table_class->row_count = etss_row_count; - table_class->append_row = etss_append_row; - - table_class->value_at = etss_value_at; - table_class->set_value_at = etss_set_value_at; - table_class->is_cell_editable = etss_is_cell_editable; - - table_class->has_save_id = etss_has_save_id; - table_class->get_save_id = etss_get_save_id; - - table_class->duplicate_value = etss_duplicate_value; - table_class->free_value = etss_free_value; - table_class->initialize_value = etss_initialize_value; - table_class->value_is_empty = etss_value_is_empty; - table_class->value_to_string = etss_value_to_string; - - class->proxy_model_pre_change = etss_proxy_model_pre_change_real; - class->proxy_model_no_change = etss_proxy_model_no_change_real; - class->proxy_model_changed = etss_proxy_model_changed_real; - class->proxy_model_row_changed = etss_proxy_model_row_changed_real; - class->proxy_model_cell_changed = etss_proxy_model_cell_changed_real; - class->proxy_model_rows_inserted = etss_proxy_model_rows_inserted_real; - class->proxy_model_rows_deleted = etss_proxy_model_rows_deleted_real; +e_table_subset_class_init (ETableSubsetClass *class) +{ + GObjectClass *object_class; + ETableModelClass *table_class; + + g_type_class_add_private (class, sizeof (ETableSubsetPrivate)); + + object_class = G_OBJECT_CLASS (class); + object_class->dispose = table_subset_dispose; + object_class->finalize = table_subset_finalize; + + table_class = E_TABLE_MODEL_CLASS (class); + table_class->column_count = table_subset_column_count; + table_class->row_count = table_subset_row_count; + table_class->append_row = table_subset_append_row; + table_class->value_at = table_subset_value_at; + table_class->set_value_at = table_subset_set_value_at; + table_class->is_cell_editable = table_subset_is_cell_editable; + table_class->has_save_id = table_subset_has_save_id; + table_class->get_save_id = table_subset_get_save_id; + table_class->duplicate_value = table_subset_duplicate_value; + table_class->free_value = table_subset_free_value; + table_class->initialize_value = table_subset_initialize_value; + table_class->value_is_empty = table_subset_value_is_empty; + table_class->value_to_string = table_subset_value_to_string; + + class->proxy_model_pre_change = table_subset_proxy_model_pre_change_real; + class->proxy_model_no_change = table_subset_proxy_model_no_change_real; + class->proxy_model_changed = table_subset_proxy_model_changed_real; + class->proxy_model_row_changed = table_subset_proxy_model_row_changed_real; + class->proxy_model_cell_changed = table_subset_proxy_model_cell_changed_real; + class->proxy_model_rows_inserted = table_subset_proxy_model_rows_inserted_real; + class->proxy_model_rows_deleted = table_subset_proxy_model_rows_deleted_real; } static void -etss_init (ETableSubset *etss) +e_table_subset_init (ETableSubset *table_subset) { - etss->last_access = 0; + table_subset->priv = E_TABLE_SUBSET_GET_PRIVATE (table_subset); } static void -etss_proxy_model_pre_change_real (ETableSubset *etss, - ETableModel *etm) +table_subset_proxy_model_pre_change (ETableModel *source_model, + ETableSubset *table_subset) { - e_table_model_pre_change (E_TABLE_MODEL (etss)); -} + ETableSubsetClass *class; -static void -etss_proxy_model_no_change_real (ETableSubset *etss, - ETableModel *etm) -{ - e_table_model_no_change (E_TABLE_MODEL (etss)); -} + class = E_TABLE_SUBSET_GET_CLASS (table_subset); -static void -etss_proxy_model_changed_real (ETableSubset *etss, - ETableModel *etm) -{ - e_table_model_changed (E_TABLE_MODEL (etss)); + if (class->proxy_model_pre_change != NULL) + class->proxy_model_pre_change (table_subset, source_model); } static void -etss_proxy_model_row_changed_real (ETableSubset *etss, - ETableModel *etm, - gint row) +table_subset_proxy_model_no_change (ETableModel *source_model, + ETableSubset *table_subset) { - gint view_row = etss_get_view_row (etss, row); - if (view_row != -1) - e_table_model_row_changed (E_TABLE_MODEL (etss), view_row); - else - e_table_model_no_change (E_TABLE_MODEL (etss)); -} + ETableSubsetClass *class; -static void -etss_proxy_model_cell_changed_real (ETableSubset *etss, - ETableModel *etm, - gint col, - gint row) -{ - gint view_row = etss_get_view_row (etss, row); - if (view_row != -1) - e_table_model_cell_changed (E_TABLE_MODEL (etss), col, view_row); - else - e_table_model_no_change (E_TABLE_MODEL (etss)); -} + class = E_TABLE_SUBSET_GET_CLASS (table_subset); -static void -etss_proxy_model_rows_inserted_real (ETableSubset *etss, - ETableModel *etm, - gint row, - gint count) -{ - e_table_model_no_change (E_TABLE_MODEL (etss)); + if (class->proxy_model_no_change != NULL) + class->proxy_model_no_change (table_subset, source_model); } static void -etss_proxy_model_rows_deleted_real (ETableSubset *etss, - ETableModel *etm, - gint row, - gint count) +table_subset_proxy_model_changed (ETableModel *source_model, + ETableSubset *table_subset) { - e_table_model_no_change (E_TABLE_MODEL (etss)); -} + ETableSubsetClass *class; -static void -etss_proxy_model_pre_change (ETableModel *etm, - ETableSubset *etss) -{ - if (ETSS_CLASS (etss)->proxy_model_pre_change) - (ETSS_CLASS (etss)->proxy_model_pre_change) (etss, etm); -} + class = E_TABLE_SUBSET_GET_CLASS (table_subset); -static void -etss_proxy_model_no_change (ETableModel *etm, - ETableSubset *etss) -{ - if (ETSS_CLASS (etss)->proxy_model_no_change) - (ETSS_CLASS (etss)->proxy_model_no_change) (etss, etm); + if (class->proxy_model_changed != NULL) + class->proxy_model_changed (table_subset, source_model); } static void -etss_proxy_model_changed (ETableModel *etm, - ETableSubset *etss) +table_subset_proxy_model_row_changed (ETableModel *source_model, + gint row, + ETableSubset *table_subset) { - if (ETSS_CLASS (etss)->proxy_model_changed) - (ETSS_CLASS (etss)->proxy_model_changed) (etss, etm); -} + ETableSubsetClass *class; -static void -etss_proxy_model_row_changed (ETableModel *etm, - gint row, - ETableSubset *etss) -{ - if (ETSS_CLASS (etss)->proxy_model_row_changed) - (ETSS_CLASS (etss)->proxy_model_row_changed) (etss, etm, row); + class = E_TABLE_SUBSET_GET_CLASS (table_subset); + + if (class->proxy_model_row_changed != NULL) + class->proxy_model_row_changed ( + table_subset, source_model, row); } static void -etss_proxy_model_cell_changed (ETableModel *etm, - gint col, - gint row, - ETableSubset *etss) +table_subset_proxy_model_cell_changed (ETableModel *source_model, + gint col, + gint row, + ETableSubset *table_subset) { - if (ETSS_CLASS (etss)->proxy_model_cell_changed) - (ETSS_CLASS (etss)->proxy_model_cell_changed) (etss, etm, col, row); + ETableSubsetClass *class; + + class = E_TABLE_SUBSET_GET_CLASS (table_subset); + + if (class->proxy_model_cell_changed != NULL) + class->proxy_model_cell_changed ( + table_subset, source_model, col, row); } static void -etss_proxy_model_rows_inserted (ETableModel *etm, - gint row, - gint col, - ETableSubset *etss) +table_subset_proxy_model_rows_inserted (ETableModel *source_model, + gint row, + gint col, + ETableSubset *table_subset) { - if (ETSS_CLASS (etss)->proxy_model_rows_inserted) - (ETSS_CLASS (etss)->proxy_model_rows_inserted) (etss, etm, row, col); + ETableSubsetClass *class; + + class = E_TABLE_SUBSET_GET_CLASS (table_subset); + + if (class->proxy_model_rows_inserted != NULL) + class->proxy_model_rows_inserted ( + table_subset, source_model, row, col); } static void -etss_proxy_model_rows_deleted (ETableModel *etm, - gint row, - gint col, - ETableSubset *etss) +table_subset_proxy_model_rows_deleted (ETableModel *source_model, + gint row, + gint col, + ETableSubset *table_subset) { - if (ETSS_CLASS (etss)->proxy_model_rows_deleted) - (ETSS_CLASS (etss)->proxy_model_rows_deleted) (etss, etm, row, col); + ETableSubsetClass *class; + + class = E_TABLE_SUBSET_GET_CLASS (table_subset); + + if (class->proxy_model_rows_deleted != NULL) + class->proxy_model_rows_deleted ( + table_subset, source_model, row, col); } ETableModel * -e_table_subset_construct (ETableSubset *etss, - ETableModel *source, +e_table_subset_construct (ETableSubset *table_subset, + ETableModel *source_model, gint nvals) { - guint *buffer; + gulong handler_id; + guint *buffer = NULL; gint i; - if (nvals) { + if (nvals > 0) buffer = (guint *) g_malloc (sizeof (guint) * nvals); - if (buffer == NULL) - return NULL; - } else - buffer = NULL; - etss->map_table = (gint *) buffer; - etss->n_map = nvals; - etss->source = source; - g_object_ref (source); + table_subset->map_table = (gint *) buffer; + table_subset->n_map = nvals; + table_subset->priv->source_model = g_object_ref (source_model); /* Init */ for (i = 0; i < nvals; i++) - etss->map_table[i] = i; - - etss->table_model_pre_change_id = g_signal_connect ( - source, "model_pre_change", - G_CALLBACK (etss_proxy_model_pre_change), etss); - etss->table_model_no_change_id = g_signal_connect ( - source, "model_no_change", - G_CALLBACK (etss_proxy_model_no_change), etss); - etss->table_model_changed_id = g_signal_connect ( - source, "model_changed", - G_CALLBACK (etss_proxy_model_changed), etss); - etss->table_model_row_changed_id = g_signal_connect ( - source, "model_row_changed", - G_CALLBACK (etss_proxy_model_row_changed), etss); - etss->table_model_cell_changed_id = g_signal_connect ( - source, "model_cell_changed", - G_CALLBACK (etss_proxy_model_cell_changed), etss); - etss->table_model_rows_inserted_id = g_signal_connect ( - source, "model_rows_inserted", - G_CALLBACK (etss_proxy_model_rows_inserted), etss); - etss->table_model_rows_deleted_id = g_signal_connect ( - source, "model_rows_deleted", - G_CALLBACK (etss_proxy_model_rows_deleted), etss); - - return E_TABLE_MODEL (etss); + table_subset->map_table[i] = i; + + handler_id = g_signal_connect ( + source_model, "model_pre_change", + G_CALLBACK (table_subset_proxy_model_pre_change), + table_subset); + table_subset->priv->table_model_pre_change_handler_id = handler_id; + + handler_id = g_signal_connect ( + source_model, "model_no_change", + G_CALLBACK (table_subset_proxy_model_no_change), + table_subset); + table_subset->priv->table_model_no_change_handler_id = handler_id; + + handler_id = g_signal_connect ( + source_model, "model_changed", + G_CALLBACK (table_subset_proxy_model_changed), + table_subset); + table_subset->priv->table_model_changed_handler_id = handler_id; + + handler_id = g_signal_connect ( + source_model, "model_row_changed", + G_CALLBACK (table_subset_proxy_model_row_changed), + table_subset); + table_subset->priv->table_model_row_changed_handler_id = handler_id; + + handler_id = g_signal_connect ( + source_model, "model_cell_changed", + G_CALLBACK (table_subset_proxy_model_cell_changed), + table_subset); + table_subset->priv->table_model_cell_changed_handler_id = handler_id; + + handler_id = g_signal_connect ( + source_model, "model_rows_inserted", + G_CALLBACK (table_subset_proxy_model_rows_inserted), + table_subset); + table_subset->priv->table_model_rows_inserted_handler_id = handler_id; + + handler_id = g_signal_connect ( + source_model, "model_rows_deleted", + G_CALLBACK (table_subset_proxy_model_rows_deleted), + table_subset); + table_subset->priv->table_model_rows_deleted_handler_id = handler_id; + + return E_TABLE_MODEL (table_subset); } ETableModel * -e_table_subset_new (ETableModel *source, +e_table_subset_new (ETableModel *source_model, const gint nvals) { - ETableSubset *etss = g_object_new (E_TYPE_TABLE_SUBSET, NULL); + ETableSubset *table_subset; + + g_return_val_if_fail (E_IS_TABLE_MODEL (source_model), NULL); - if (e_table_subset_construct (etss, source, nvals) == NULL) { - g_object_unref (etss); + table_subset = g_object_new (E_TYPE_TABLE_SUBSET, NULL); + + if (e_table_subset_construct (table_subset, source_model, nvals) == NULL) { + g_object_unref (table_subset); return NULL; } - return (ETableModel *) etss; + return (ETableModel *) table_subset; +} + +ETableModel * +e_table_subset_get_source_model (ETableSubset *table_subset) +{ + g_return_val_if_fail (E_IS_TABLE_SUBSET (table_subset), NULL); + + return table_subset->priv->source_model; } gint -e_table_subset_model_to_view_row (ETableSubset *ets, +e_table_subset_model_to_view_row (ETableSubset *table_subset, gint model_row) { gint i; - for (i = 0; i < ets->n_map; i++) { - if (ets->map_table[i] == model_row) + + g_return_val_if_fail (E_IS_TABLE_SUBSET (table_subset), -1); + + for (i = 0; i < table_subset->n_map; i++) { + if (table_subset->map_table[i] == model_row) return i; } return -1; } gint -e_table_subset_view_to_model_row (ETableSubset *ets, +e_table_subset_view_to_model_row (ETableSubset *table_subset, gint view_row) { - if (view_row >= 0 && view_row < ets->n_map) - return ets->map_table[view_row]; + g_return_val_if_fail (E_IS_TABLE_SUBSET (table_subset), -1); + + if (view_row >= 0 && view_row < table_subset->n_map) + return table_subset->map_table[view_row]; else return -1; } ETableModel * -e_table_subset_get_toplevel (ETableSubset *table) +e_table_subset_get_toplevel (ETableSubset *table_subset) { - g_return_val_if_fail (table != NULL, NULL); - g_return_val_if_fail (E_IS_TABLE_SUBSET (table), NULL); + g_return_val_if_fail (E_IS_TABLE_SUBSET (table_subset), NULL); - if (E_IS_TABLE_SUBSET (table->source)) - return e_table_subset_get_toplevel (E_TABLE_SUBSET (table->source)); + if (E_IS_TABLE_SUBSET (table_subset->priv->source_model)) + return e_table_subset_get_toplevel ( + E_TABLE_SUBSET (table_subset->priv->source_model)); else - return table->source; + return table_subset->priv->source_model; } void -e_table_subset_print_debugging (ETableSubset *table_model) +e_table_subset_print_debugging (ETableSubset *table_subset) { gint i; - for (i = 0; i < table_model->n_map; i++) { - g_print ("%8d\n", table_model->map_table[i]); + + g_return_if_fail (E_IS_TABLE_SUBSET (table_subset)); + + for (i = 0; i < table_subset->n_map; i++) { + g_print ("%8d\n", table_subset->map_table[i]); } } diff --git a/e-util/e-table-subset.h b/e-util/e-table-subset.h index 9e8d69496d..fc954f820c 100644 --- a/e-util/e-table-subset.h +++ b/e-util/e-table-subset.h @@ -26,8 +26,8 @@ #error "Only <e-util/e-util.h> should be included directly." #endif -#ifndef _E_TABLE_SUBSET_H_ -#define _E_TABLE_SUBSET_H_ +#ifndef E_TABLE_SUBSET_H +#define E_TABLE_SUBSET_H #include <e-util/e-table-model.h> @@ -54,67 +54,66 @@ G_BEGIN_DECLS typedef struct _ETableSubset ETableSubset; typedef struct _ETableSubsetClass ETableSubsetClass; +typedef struct _ETableSubsetPrivate ETableSubsetPrivate; struct _ETableSubset { ETableModel parent; + ETableSubsetPrivate *priv; - ETableModel *source; + /* protected - subclasses modify this directly */ gint n_map; gint *map_table; - - gint last_access; - - gint table_model_pre_change_id; - gint table_model_no_change_id; - gint table_model_changed_id; - gint table_model_row_changed_id; - gint table_model_cell_changed_id; - gint table_model_rows_inserted_id; - gint table_model_rows_deleted_id; }; struct _ETableSubsetClass { ETableModelClass parent_class; - void (*proxy_model_pre_change) (ETableSubset *etss, - ETableModel *etm); - void (*proxy_model_no_change) (ETableSubset *etss, - ETableModel *etm); - void (*proxy_model_changed) (ETableSubset *etss, - ETableModel *etm); - void (*proxy_model_row_changed) (ETableSubset *etss, - ETableModel *etm, - gint row); - void (*proxy_model_cell_changed) (ETableSubset *etss, - ETableModel *etm, - gint col, - gint row); - void (*proxy_model_rows_inserted) (ETableSubset *etss, - ETableModel *etm, - gint row, - gint count); - void (*proxy_model_rows_deleted) (ETableSubset *etss, - ETableModel *etm, - gint row, - gint count); + void (*proxy_model_pre_change) + (ETableSubset *table_subset, + ETableModel *source_model); + void (*proxy_model_no_change) + (ETableSubset *table_subset, + ETableModel *source_model); + void (*proxy_model_changed) (ETableSubset *table_subset, + ETableModel *source_model); + void (*proxy_model_row_changed) + (ETableSubset *table_subset, + ETableModel *source_model, + gint row); + void (*proxy_model_cell_changed) + (ETableSubset *table_subset, + ETableModel *source_model, + gint col, + gint row); + void (*proxy_model_rows_inserted) + (ETableSubset *table_subset, + ETableModel *source_model, + gint row, + gint count); + void (*proxy_model_rows_deleted) + (ETableSubset *table_subset, + ETableModel *source_model, + gint row, + gint count); }; GType e_table_subset_get_type (void) G_GNUC_CONST; -ETableModel * e_table_subset_new (ETableModel *etm, +ETableModel * e_table_subset_new (ETableModel *source_model, gint n_vals); -ETableModel * e_table_subset_construct (ETableSubset *ets, - ETableModel *source, +ETableModel * e_table_subset_construct (ETableSubset *table_subset, + ETableModel *source_model, gint nvals); +ETableModel * e_table_subset_get_source_model (ETableSubset *table_subset); gint e_table_subset_model_to_view_row - (ETableSubset *ets, + (ETableSubset *table_subset, gint model_row); gint e_table_subset_view_to_model_row - (ETableSubset *ets, + (ETableSubset *table_subset, gint view_row); -ETableModel * e_table_subset_get_toplevel (ETableSubset *table_model); -void e_table_subset_print_debugging (ETableSubset *table_model); +ETableModel * e_table_subset_get_toplevel (ETableSubset *table_subset); +void e_table_subset_print_debugging (ETableSubset *table_subset); G_END_DECLS -#endif /* _E_TABLE_SUBSET_H_ */ +#endif /* E_TABLE_SUBSET_H */ diff --git a/e-util/e-table-without.c b/e-util/e-table-without.c index 7139ad15df..8e72747759 100644 --- a/e-util/e-table-without.c +++ b/e-util/e-table-without.c @@ -34,9 +34,7 @@ (G_TYPE_INSTANCE_GET_PRIVATE \ ((obj), E_TYPE_TABLE_WITHOUT, ETableWithoutPrivate)) -/* workaround for avoiding API breakage */ -#define etw_get_type e_table_without_get_type -G_DEFINE_TYPE (ETableWithout, etw, E_TYPE_TABLE_SUBSET) +G_DEFINE_TYPE (ETableWithout, e_table_without, E_TYPE_TABLE_SUBSET) #define INCREMENT_AMOUNT 10 @@ -61,9 +59,13 @@ check (ETableWithout *etw, gboolean ret_val; gpointer key; ETableSubset *etss = E_TABLE_SUBSET (etw); + ETableModel *source_model; + + source_model = e_table_subset_get_source_model (etss); if (etw->priv->get_key_func) - key = etw->priv->get_key_func (etss->source, model_row, etw->priv->closure); + key = etw->priv->get_key_func ( + source_model, model_row, etw->priv->closure); else key = GINT_TO_POINTER (model_row); ret_val = (g_hash_table_lookup (etw->priv->hash, key) != NULL); @@ -80,9 +82,13 @@ check_with_key (ETableWithout *etw, gboolean ret_val; gpointer key2; ETableSubset *etss = E_TABLE_SUBSET (etw); + ETableModel *source_model; + + source_model = e_table_subset_get_source_model (etss); if (etw->priv->get_key_func) - key2 = etw->priv->get_key_func (etss->source, model_row, etw->priv->closure); + key2 = etw->priv->get_key_func ( + source_model, model_row, etw->priv->closure); else key2 = GINT_TO_POINTER (model_row); if (etw->priv->compare_func) @@ -156,7 +162,7 @@ etw_dispose (GObject *object) } /* Chain up to parent's dispose() method. */ - G_OBJECT_CLASS (etw_parent_class)->dispose (object); + G_OBJECT_CLASS (e_table_without_parent_class)->dispose (object); } static void @@ -236,12 +242,12 @@ etw_proxy_model_changed (ETableSubset *etss, } etss->n_map = j; - if (E_TABLE_SUBSET_CLASS (etw_parent_class)->proxy_model_changed) - E_TABLE_SUBSET_CLASS (etw_parent_class)->proxy_model_changed (etss, etm); + if (E_TABLE_SUBSET_CLASS (e_table_without_parent_class)->proxy_model_changed) + E_TABLE_SUBSET_CLASS (e_table_without_parent_class)->proxy_model_changed (etss, etm); } static void -etw_class_init (ETableWithoutClass *class) +e_table_without_class_init (ETableWithoutClass *class) { GObjectClass *object_class; ETableSubsetClass *etss_class; @@ -258,7 +264,7 @@ etw_class_init (ETableWithoutClass *class) } static void -etw_init (ETableWithout *etw) +e_table_without_init (ETableWithout *etw) { etw->priv = E_TABLE_WITHOUT_GET_PRIVATE (etw); } @@ -363,10 +369,12 @@ e_table_without_show (ETableWithout *etw, { gint i; /* Model row */ ETableSubset *etss = E_TABLE_SUBSET (etw); + ETableModel *source_model; gint count; gpointer old_key; - count = e_table_model_row_count (etss->source); + source_model = e_table_subset_get_source_model (etss); + count = e_table_model_row_count (source_model); for (i = 0; i < count; i++) { if (check_with_key (etw, key, i)) { @@ -388,6 +396,7 @@ e_table_without_show_all (ETableWithout *etw) gint i; /* Model row */ gint row_count; ETableSubset *etss = E_TABLE_SUBSET (etw); + ETableModel *source_model; e_table_model_pre_change (E_TABLE_MODEL (etw)); @@ -399,7 +408,9 @@ e_table_without_show_all (ETableWithout *etw) etw->priv->hash = g_hash_table_new ( etw->priv->hash_func, etw->priv->compare_func); - row_count = e_table_model_row_count (E_TABLE_MODEL (etss->source)); + source_model = e_table_subset_get_source_model (etss); + row_count = e_table_model_row_count (source_model); + g_free (etss->map_table); etss->map_table = g_new (int, row_count); diff --git a/e-util/e-tree-model.h b/e-util/e-tree-model.h index 5162dab0ac..c6ed8c8799 100644 --- a/e-util/e-tree-model.h +++ b/e-util/e-tree-model.h @@ -23,7 +23,7 @@ #ifndef E_TREE_MODEL_H #define E_TREE_MODEL_H -#include <gdk-pixbuf/gdk-pixbuf.h> +#include <glib-object.h> /* Standard GObject macros */ #define E_TYPE_TREE_MODEL \ @@ -50,7 +50,7 @@ typedef gboolean (*ETreePathFunc) (ETreeModel *tree_model, gpointer data); struct _ETreeModelInterface { - GTypeInterface parent_class; + GTypeInterface parent_interface; ETreePath (*get_root) (ETreeModel *tree_model); diff --git a/e-util/e-tree-table-adapter.c b/e-util/e-tree-table-adapter.c index 89110ea5e3..2950d60a33 100644 --- a/e-util/e-tree-table-adapter.c +++ b/e-util/e-tree-table-adapter.c @@ -45,20 +45,10 @@ (G_TYPE_INSTANCE_GET_PRIVATE \ ((obj), E_TYPE_TREE_TABLE_ADAPTER, ETreeTableAdapterPrivate)) -/* workaround for avoiding API breakage */ -#define etta_get_type e_tree_table_adapter_get_type -G_DEFINE_TYPE (ETreeTableAdapter, etta, E_TYPE_TABLE_MODEL) #define d(x) #define INCREMENT_AMOUNT 100 -enum { - SORTING_CHANGED, - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL] = { 0, }; - typedef struct { ETreePath path; guint32 num_visible_children; @@ -98,7 +88,21 @@ struct _ETreeTableAdapterPrivate { gint force_expanded_state; /* use this instead of model's default if not 0; <0 ... collapse, >0 ... expand */ }; -static void etta_sort_info_changed (ETableSortInfo *sort_info, ETreeTableAdapter *etta); +static void tree_table_adapter_sort_info_changed + (ETableSortInfo *sort_info, + ETreeTableAdapter *etta); + +enum { + SORTING_CHANGED, + LAST_SIGNAL +}; + +static guint signals[LAST_SIGNAL]; + +G_DEFINE_TYPE ( + ETreeTableAdapter, + e_tree_table_adapter, + E_TYPE_TABLE_MODEL) static GNode * lookup_gnode (ETreeTableAdapter *etta, @@ -534,32 +538,7 @@ update_node (ETreeTableAdapter *etta, } static void -etta_finalize (GObject *object) -{ - ETreeTableAdapterPrivate *priv; - - priv = E_TREE_TABLE_ADAPTER_GET_PRIVATE (object); - - if (priv->resort_idle_id) { - g_source_remove (priv->resort_idle_id); - priv->resort_idle_id = 0; - } - - if (priv->root) { - kill_gnode (priv->root, E_TREE_TABLE_ADAPTER (object)); - priv->root = NULL; - } - - g_hash_table_destroy (priv->nodes); - - g_free (priv->map_table); - - /* Chain up to parent's finalize() method. */ - G_OBJECT_CLASS (etta_parent_class)->finalize (object); -} - -static void -etta_dispose (GObject *object) +tree_table_adapter_dispose (GObject *object) { ETreeTableAdapterPrivate *priv; @@ -596,11 +575,36 @@ etta_dispose (GObject *object) } /* Chain up to parent's dispose() method. */ - G_OBJECT_CLASS (etta_parent_class)->dispose (object); + G_OBJECT_CLASS (e_tree_table_adapter_parent_class)->dispose (object); +} + +static void +tree_table_adapter_finalize (GObject *object) +{ + ETreeTableAdapterPrivate *priv; + + priv = E_TREE_TABLE_ADAPTER_GET_PRIVATE (object); + + if (priv->resort_idle_id) { + g_source_remove (priv->resort_idle_id); + priv->resort_idle_id = 0; + } + + if (priv->root) { + kill_gnode (priv->root, E_TREE_TABLE_ADAPTER (object)); + priv->root = NULL; + } + + g_hash_table_destroy (priv->nodes); + + g_free (priv->map_table); + + /* Chain up to parent's finalize() method. */ + G_OBJECT_CLASS (e_tree_table_adapter_parent_class)->finalize (object); } static gint -etta_column_count (ETableModel *etm) +tree_table_adapter_column_count (ETableModel *etm) { ETreeTableAdapter *etta = (ETreeTableAdapter *) etm; @@ -608,14 +612,14 @@ etta_column_count (ETableModel *etm) } static gboolean -etta_has_save_id (ETableModel *etm) +tree_table_adapter_has_save_id (ETableModel *etm) { return TRUE; } static gchar * -etta_get_save_id (ETableModel *etm, - gint row) +tree_table_adapter_get_save_id (ETableModel *etm, + gint row) { ETreeTableAdapter *etta = (ETreeTableAdapter *) etm; @@ -623,7 +627,7 @@ etta_get_save_id (ETableModel *etm, } static gint -etta_row_count (ETableModel *etm) +tree_table_adapter_row_count (ETableModel *etm) { ETreeTableAdapter *etta = (ETreeTableAdapter *) etm; @@ -631,9 +635,9 @@ etta_row_count (ETableModel *etm) } static gpointer -etta_value_at (ETableModel *etm, - gint col, - gint row) +tree_table_adapter_value_at (ETableModel *etm, + gint col, + gint row) { ETreeTableAdapter *etta = (ETreeTableAdapter *) etm; @@ -652,33 +656,33 @@ etta_value_at (ETableModel *etm, } static void -etta_set_value_at (ETableModel *etm, - gint col, - gint row, - gconstpointer val) +tree_table_adapter_set_value_at (ETableModel *etm, + gint col, + gint row, + gconstpointer val) { g_warn_if_reached (); } static gboolean -etta_is_cell_editable (ETableModel *etm, - gint col, - gint row) +tree_table_adapter_is_cell_editable (ETableModel *etm, + gint col, + gint row) { return FALSE; } static void -etta_append_row (ETableModel *etm, - ETableModel *source, - gint row) +tree_table_adapter_append_row (ETableModel *etm, + ETableModel *source, + gint row) { } static gpointer -etta_duplicate_value (ETableModel *etm, - gint col, - gconstpointer value) +tree_table_adapter_duplicate_value (ETableModel *etm, + gint col, + gconstpointer value) { ETreeTableAdapter *etta = (ETreeTableAdapter *) etm; @@ -686,9 +690,9 @@ etta_duplicate_value (ETableModel *etm, } static void -etta_free_value (ETableModel *etm, - gint col, - gpointer value) +tree_table_adapter_free_value (ETableModel *etm, + gint col, + gpointer value) { ETreeTableAdapter *etta = (ETreeTableAdapter *) etm; @@ -696,8 +700,8 @@ etta_free_value (ETableModel *etm, } static gpointer -etta_initialize_value (ETableModel *etm, - gint col) +tree_table_adapter_initialize_value (ETableModel *etm, + gint col) { ETreeTableAdapter *etta = (ETreeTableAdapter *) etm; @@ -705,9 +709,9 @@ etta_initialize_value (ETableModel *etm, } static gboolean -etta_value_is_empty (ETableModel *etm, - gint col, - gconstpointer value) +tree_table_adapter_value_is_empty (ETableModel *etm, + gint col, + gconstpointer value) { ETreeTableAdapter *etta = (ETreeTableAdapter *) etm; @@ -715,9 +719,9 @@ etta_value_is_empty (ETableModel *etm, } static gchar * -etta_value_to_string (ETableModel *etm, - gint col, - gconstpointer value) +tree_table_adapter_value_to_string (ETableModel *etm, + gint col, + gconstpointer value) { ETreeTableAdapter *etta = (ETreeTableAdapter *) etm; @@ -725,7 +729,7 @@ etta_value_to_string (ETableModel *etm, } static void -etta_class_init (ETreeTableAdapterClass *class) +e_tree_table_adapter_class_init (ETreeTableAdapterClass *class) { GObjectClass *object_class; ETableModelClass *table_model_class; @@ -733,26 +737,26 @@ etta_class_init (ETreeTableAdapterClass *class) g_type_class_add_private (class, sizeof (ETreeTableAdapterPrivate)); object_class = G_OBJECT_CLASS (class); - object_class->dispose = etta_dispose; - object_class->finalize = etta_finalize; + object_class->dispose = tree_table_adapter_dispose; + object_class->finalize = tree_table_adapter_finalize; table_model_class = E_TABLE_MODEL_CLASS (class); - table_model_class->column_count = etta_column_count; - table_model_class->row_count = etta_row_count; - table_model_class->append_row = etta_append_row; + table_model_class->column_count = tree_table_adapter_column_count; + table_model_class->row_count = tree_table_adapter_row_count; + table_model_class->append_row = tree_table_adapter_append_row; - table_model_class->value_at = etta_value_at; - table_model_class->set_value_at = etta_set_value_at; - table_model_class->is_cell_editable = etta_is_cell_editable; + table_model_class->value_at = tree_table_adapter_value_at; + table_model_class->set_value_at = tree_table_adapter_set_value_at; + table_model_class->is_cell_editable = tree_table_adapter_is_cell_editable; - table_model_class->has_save_id = etta_has_save_id; - table_model_class->get_save_id = etta_get_save_id; + table_model_class->has_save_id = tree_table_adapter_has_save_id; + table_model_class->get_save_id = tree_table_adapter_get_save_id; - table_model_class->duplicate_value = etta_duplicate_value; - table_model_class->free_value = etta_free_value; - table_model_class->initialize_value = etta_initialize_value; - table_model_class->value_is_empty = etta_value_is_empty; - table_model_class->value_to_string = etta_value_to_string; + table_model_class->duplicate_value = tree_table_adapter_duplicate_value; + table_model_class->free_value = tree_table_adapter_free_value; + table_model_class->initialize_value = tree_table_adapter_initialize_value; + table_model_class->value_is_empty = tree_table_adapter_value_is_empty; + table_model_class->value_to_string = tree_table_adapter_value_to_string; class->sorting_changed = NULL; @@ -768,7 +772,7 @@ etta_class_init (ETreeTableAdapterClass *class) } static void -etta_init (ETreeTableAdapter *etta) +e_tree_table_adapter_init (ETreeTableAdapter *etta) { etta->priv = E_TREE_TABLE_ADAPTER_GET_PRIVATE (etta); @@ -777,15 +781,15 @@ etta_init (ETreeTableAdapter *etta) } static void -etta_proxy_pre_change (ETreeModel *etm, - ETreeTableAdapter *etta) +tree_table_adapter_proxy_pre_change (ETreeModel *etm, + ETreeTableAdapter *etta) { e_table_model_pre_change (E_TABLE_MODEL (etta)); } static void -etta_proxy_rebuilt (ETreeModel *etm, - ETreeTableAdapter *etta) +tree_table_adapter_proxy_rebuilt (ETreeModel *etm, + ETreeTableAdapter *etta) { if (!etta->priv->root) return; @@ -798,15 +802,15 @@ etta_proxy_rebuilt (ETreeModel *etm, static gboolean resort_model (ETreeTableAdapter *etta) { - etta_sort_info_changed (NULL, etta); + tree_table_adapter_sort_info_changed (NULL, etta); etta->priv->resort_idle_id = 0; return FALSE; } static void -etta_proxy_node_changed (ETreeModel *etm, - ETreePath path, - ETreeTableAdapter *etta) +tree_table_adapter_proxy_node_changed (ETreeModel *etm, + ETreePath path, + ETreeTableAdapter *etta) { update_node (etta, path); e_table_model_changed (E_TABLE_MODEL (etta)); @@ -819,9 +823,9 @@ etta_proxy_node_changed (ETreeModel *etm, } static void -etta_proxy_node_data_changed (ETreeModel *etm, - ETreePath path, - ETreeTableAdapter *etta) +tree_table_adapter_proxy_node_data_changed (ETreeModel *etm, + ETreePath path, + ETreeTableAdapter *etta) { gint row = get_row (etta, path); @@ -834,10 +838,10 @@ etta_proxy_node_data_changed (ETreeModel *etm, } static void -etta_proxy_node_inserted (ETreeModel *etm, - ETreePath parent, - ETreePath child, - ETreeTableAdapter *etta) +tree_table_adapter_proxy_node_inserted (ETreeModel *etm, + ETreePath parent, + ETreePath child, + ETreeTableAdapter *etta) { if (e_tree_model_node_is_root (etm, child)) generate_tree (etta, child); @@ -848,19 +852,19 @@ etta_proxy_node_inserted (ETreeModel *etm, } static void -etta_proxy_node_removed (ETreeModel *etm, - ETreePath parent, - ETreePath child, - gint old_position, - ETreeTableAdapter *etta) +tree_table_adapter_proxy_node_removed (ETreeModel *etm, + ETreePath parent, + ETreePath child, + gint old_position, + ETreeTableAdapter *etta) { delete_node (etta, parent, child); e_table_model_changed (E_TABLE_MODEL (etta)); } static void -etta_sort_info_changed (ETableSortInfo *sort_info, - ETreeTableAdapter *etta) +tree_table_adapter_sort_info_changed (ETableSortInfo *sort_info, + ETreeTableAdapter *etta) { if (!etta->priv->root) return; @@ -898,7 +902,8 @@ e_tree_table_adapter_construct (ETreeTableAdapter *etta, g_object_ref (sort_info); etta->priv->sort_info_changed_id = g_signal_connect ( sort_info, "sort_info_changed", - G_CALLBACK (etta_sort_info_changed), etta); + G_CALLBACK (tree_table_adapter_sort_info_changed), + etta); } etta->priv->header = header; @@ -914,22 +919,22 @@ e_tree_table_adapter_construct (ETreeTableAdapter *etta, etta->priv->pre_change_id = g_signal_connect ( source, "pre_change", - G_CALLBACK (etta_proxy_pre_change), etta); + G_CALLBACK (tree_table_adapter_proxy_pre_change), etta); etta->priv->rebuilt_id = g_signal_connect ( source, "rebuilt", - G_CALLBACK (etta_proxy_rebuilt), etta); + G_CALLBACK (tree_table_adapter_proxy_rebuilt), etta); etta->priv->node_changed_id = g_signal_connect ( source, "node_changed", - G_CALLBACK (etta_proxy_node_changed), etta); + G_CALLBACK (tree_table_adapter_proxy_node_changed), etta); etta->priv->node_data_changed_id = g_signal_connect ( source, "node_data_changed", - G_CALLBACK (etta_proxy_node_data_changed), etta); + G_CALLBACK (tree_table_adapter_proxy_node_data_changed), etta); etta->priv->node_inserted_id = g_signal_connect ( source, "node_inserted", - G_CALLBACK (etta_proxy_node_inserted), etta); + G_CALLBACK (tree_table_adapter_proxy_node_inserted), etta); etta->priv->node_removed_id = g_signal_connect ( source, "node_removed", - G_CALLBACK (etta_proxy_node_removed), etta); + G_CALLBACK (tree_table_adapter_proxy_node_removed), etta); return E_TABLE_MODEL (etta); } @@ -1309,7 +1314,8 @@ e_tree_table_adapter_set_sort_info (ETreeTableAdapter *etta, g_object_ref (sort_info); etta->priv->sort_info_changed_id = g_signal_connect ( sort_info, "sort_info_changed", - G_CALLBACK (etta_sort_info_changed), etta); + G_CALLBACK (tree_table_adapter_sort_info_changed), + etta); } if (!etta->priv->root) diff --git a/e-util/gal-define-views-model.c b/e-util/gal-define-views-model.c index 8d8dd519a5..14bdac636f 100644 --- a/e-util/gal-define-views-model.c +++ b/e-util/gal-define-views-model.c @@ -32,17 +32,17 @@ #include "gal-define-views-model.h" -G_DEFINE_TYPE ( - GalDefineViewsModel, - gal_define_views_model, - E_TYPE_TABLE_MODEL) - enum { PROP_0, PROP_EDITABLE, PROP_COLLECTION }; +G_DEFINE_TYPE ( + GalDefineViewsModel, + gal_define_views_model, + E_TYPE_TABLE_MODEL) + static void gal_define_views_model_set_property (GObject *object, guint property_id, @@ -126,6 +126,13 @@ gdvm_row_count (ETableModel *etc) return 0; } +static void +gdvm_append_row (ETableModel *etm, + ETableModel *source, + gint row) +{ +} + /* This function returns the value at a particular point in our ETableModel. */ static gpointer gdvm_value_at (ETableModel *etc, @@ -170,13 +177,6 @@ gdvm_is_cell_editable (ETableModel *etc, return GAL_DEFINE_VIEWS_MODEL (etc)->editable; } -static void -gdvm_append_row (ETableModel *etm, - ETableModel *source, - gint row) -{ -} - /* This function duplicates the value passed to it. */ static gpointer gdvm_duplicate_value (ETableModel *etc, |