From 033865ef093ed89334685a7ff7fefdbfe08cfbe4 Mon Sep 17 00:00:00 2001 From: jrl Date: Sat, 13 May 2006 14:00:36 +0000 Subject: [PATCH] 2006-05-13 James Livingston * rhythmdb/rhythmdb-query-model.c: (rhythmdb_query_model_class_init), (rhythmdb_query_model_set_property), (rhythmdb_query_model_get_property), (rhythmdb_query_model_finalize), (rhythmdb_query_model_new), (rhythmdb_query_model_insert_into_main_list), (rhythmdb_query_model_insert_into_limited_list), (rhythmdb_query_model_do_reorder), (rhythmdb_query_model_set_sort_order), (_reverse_sorting_func), (rhythmdb_query_model_location_sort_func), (rhythmdb_query_model_title_sort_func), (rhythmdb_query_model_album_sort_func), (rhythmdb_query_model_artist_sort_func), (rhythmdb_query_model_genre_sort_func), (rhythmdb_query_model_track_sort_func), (rhythmdb_query_model_double_ceiling_sort_func), (rhythmdb_query_model_ulong_sort_func), (rhythmdb_query_model_date_sort_func), (rhythmdb_query_model_string_sort_func): * rhythmdb/rhythmdb-query-model.h: Make the sorting data be a gpointer instead of a RhythmDBPropType (which can be put in a gpointer). Add a "data destroy" property. Fixed bug 341543. * bindings/python/rhythmdb.defs: * bindings/python/rhythmdb.override: bind rhythmdb_query_model_new and rhythmdb_query_model_set_sorting_order * rhythmdb/rhythmdb-property-model.c: (rhythmdb_property_model_drag_data_get): * sources/rb-import-errors-source.c: (rb_import_errors_source_constructor): * sources/rb-missing-files-source.c: (rb_missing_files_source_constructor): * widgets/rb-entry-view.c: (rb_entry_view_append_column), (rb_entry_view_append_column_custom), (rb_entry_view_resort_model): * widgets/rb-entry-view.h: adapt to the above change. --- ChangeLog | 39 ++++++++ bindings/python/rhythmdb.defs | 4 +- bindings/python/rhythmdb.override | 119 ++++++++++++++++++++++ rhythmdb/rhythmdb-property-model.c | 6 +- rhythmdb/rhythmdb-query-model.c | 195 +++++++++++++++++++++++++------------ rhythmdb/rhythmdb-query-model.h | 26 ++--- sources/rb-import-errors-source.c | 2 +- sources/rb-missing-files-source.c | 2 +- widgets/rb-entry-view.c | 11 ++- widgets/rb-entry-view.h | 2 +- 10 files changed, 320 insertions(+), 86 deletions(-) diff --git a/ChangeLog b/ChangeLog index 356922aa..466125cc 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,42 @@ +2006-05-13 James Livingston + + * rhythmdb/rhythmdb-query-model.c: + (rhythmdb_query_model_class_init), + (rhythmdb_query_model_set_property), + (rhythmdb_query_model_get_property), + (rhythmdb_query_model_finalize), (rhythmdb_query_model_new), + (rhythmdb_query_model_insert_into_main_list), + (rhythmdb_query_model_insert_into_limited_list), + (rhythmdb_query_model_do_reorder), + (rhythmdb_query_model_set_sort_order), (_reverse_sorting_func), + (rhythmdb_query_model_location_sort_func), + (rhythmdb_query_model_title_sort_func), + (rhythmdb_query_model_album_sort_func), + (rhythmdb_query_model_artist_sort_func), + (rhythmdb_query_model_genre_sort_func), + (rhythmdb_query_model_track_sort_func), + (rhythmdb_query_model_double_ceiling_sort_func), + (rhythmdb_query_model_ulong_sort_func), + (rhythmdb_query_model_date_sort_func), + (rhythmdb_query_model_string_sort_func): + * rhythmdb/rhythmdb-query-model.h: Make the sorting data be a gpointer + instead of a RhythmDBPropType (which can be put in a gpointer). Add a + "data destroy" property. Fixed bug 341543. + + * bindings/python/rhythmdb.defs: + * bindings/python/rhythmdb.override: bind rhythmdb_query_model_new and + rhythmdb_query_model_set_sorting_order + + * rhythmdb/rhythmdb-property-model.c: + (rhythmdb_property_model_drag_data_get): + * sources/rb-import-errors-source.c: + (rb_import_errors_source_constructor): + * sources/rb-missing-files-source.c: + (rb_missing_files_source_constructor): + * widgets/rb-entry-view.c: (rb_entry_view_append_column), + (rb_entry_view_append_column_custom), (rb_entry_view_resort_model): + * widgets/rb-entry-view.h: adapt to the above change. + 2006-05-13 Jonathan Matthew * rhythmdb/rhythmdb-tree.c: (rhythmdb_tree_parser_end_element), diff --git a/bindings/python/rhythmdb.defs b/bindings/python/rhythmdb.defs index ae50bfff..416bf26d 100644 --- a/bindings/python/rhythmdb.defs +++ b/bindings/python/rhythmdb.defs @@ -639,7 +639,7 @@ (parameters '("RhythmDBQuery*" "query") '("GCompareDataFunc" "sort_func") - '("RhythmDBPropType" "sort_prop_id") + '("gpointer" "sort_data") '("gboolean" "sort_reverse") ) ) @@ -764,7 +764,7 @@ (return-type "none") (parameters '("GCompareDataFunc" "sort_func") - '("RhythmDBPropType" "sort_prop_id") + '("gpointer" "sort_data") '("gboolean" "sort_reverse") ) ) diff --git a/bindings/python/rhythmdb.override b/bindings/python/rhythmdb.override index 1caa830c..c0300e1b 100644 --- a/bindings/python/rhythmdb.override +++ b/bindings/python/rhythmdb.override @@ -18,6 +18,45 @@ void pyrhythmdb_add_constants (PyObject *module, const gchar *strip_prefix); #define RHYTHMDB_TYPE_RHYTHMDB RHYTHMDB_TYPE #define RHYTHMDB_RHYTHMDB(o) RHYTHMDB(o) + +/* query model sorting stuff */ +typedef struct { + PyObject *func; + PyObject *data; +} PyRhythmDBQueryModelSortData; + +static void +_rhythmdb_query_model_sort_data_free (PyRhythmDBQueryModelSortData *data) +{ + Py_DECREF (data->func); + Py_DECREF (data->data); + g_free (data); +} + +static int +_rhythmdb_query_model_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, PyRhythmDBQueryModelSortData *data) +{ + PyObject *args; + PyObject *py_result; + PyObject *py_a, *py_b; + int result; + + py_a = pyg_pointer_new (RHYTHMDB_TYPE_ENTRY, a); + py_b = pyg_pointer_new (RHYTHMDB_TYPE_ENTRY, b); + if (data->data) + args = Py_BuildValue ("(OOO)", py_a, py_b, data->data); + else + args = Py_BuildValue ("(O)", py_a, py_b); + + py_result = PyEval_CallObject (data->func, args); + result = PyInt_AsLong (py_result); + + Py_DECREF (args); + Py_DECREF (py_result); + return result; +} +/* end query model sorting stuff */ + %% modulename rhythmdb %% @@ -252,3 +291,83 @@ _wrap_rhythmdb_entry_foreach (PyGObject *self, PyObject *args, PyObject *kwargs) Py_INCREF(Py_None); return Py_None; } +%% +override rhythmdb_query_model_new kwargs + +static PyObject* +_wrap_rhythmdb_query_model_new (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = {"query", "func", "reverse", NULL}; + PyObject *py_query; + int reverse; + PyRhythmDBQueryModelSortData *data; + RhythmDBQueryModel *query_model; + + data = g_new0 (PyRhythmDBQueryModelSortData, 1); + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOi|O:RhythmDB.query_model_new", kwlist, + &py_query, &data->func, &reverse, &data->data)) { + g_free (data); + return NULL; + } + + /* verify arguments' integrity */ + if (!PyCallable_Check (data->func)) { + PyErr_SetString (PyExc_TypeError, "func must be callable"); + g_free (data); + return NULL; + } + + if (!pyg_boxed_check(py_query, RHYTHMDB_TYPE_QUERY)) { + PyErr_SetString(PyExc_TypeError, "query should be a RhythmDBQuery"); + g_free (data); + return NULL; + } + + Py_INCREF (data->func); + Py_INCREF (data->data); + + query_model = rhythmdb_query_model_new (RHYTHMDB (self->obj), pyg_boxed_get (py_query, RhythmDBQuery), + (GCompareDataFunc) _rhythmdb_query_model_sort_func, + data, (GDestroyNotify) _rhythmdb_query_model_sort_data_free, + (reverse != 0)); + + return pygobject_new (G_OBJECT (query_model)); +} +%% +override rhythmdb_query_model_set_sort_order kwargs + +static PyObject* +_wrap_rhythmdb_query_model_set_sort_order (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = {"func", "reverse", NULL}; + int reverse; + PyRhythmDBQueryModelSortData *data; + RhythmDBQueryModel *query_model; + + data = g_new0 (PyRhythmDBQueryModelSortData, 1); + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi|O:RhythmDB.query_model_set_sort_order", kwlist, + &data->func, &reverse, &data->data)) { + g_free (data); + return NULL; + } + + /* verify arguments' integrity */ + if (!PyCallable_Check (data->func)) { + PyErr_SetString (PyExc_TypeError, "func must be callable"); + g_free (data); + return NULL; + } + + Py_INCREF (data->func); + Py_INCREF (data->data); + + rhythmdb_query_model_set_sort_order (RHYTHMDB (self->obj), + (GCompareDataFunc) _rhythmdb_query_model_sort_func, + data, (GDestroyNotify) _rhythmdb_query_model_sort_data_free, + (reverse != 0)); + + Py_INCREF(Py_None); + return Py_None; +} diff --git a/rhythmdb/rhythmdb-property-model.c b/rhythmdb/rhythmdb-property-model.c index 9d1057cf..b964924d 100644 --- a/rhythmdb/rhythmdb-property-model.c +++ b/rhythmdb/rhythmdb-property-model.c @@ -948,7 +948,7 @@ rhythmdb_property_model_drag_data_get (RbTreeDragSource *dragsource, struct QueryModelCbStruct tmp; GtkTreePath *path; GCompareDataFunc sort_func = NULL; - RhythmDBPropType sort_prop_id; + gpointer sort_data; gboolean sort_reverse; query_model = rhythmdb_query_model_new_empty (db); @@ -957,11 +957,11 @@ rhythmdb_property_model_drag_data_get (RbTreeDragSource *dragsource, */ g_object_get (G_OBJECT (model->priv->query_model), "sort-func", &sort_func, - "sort-prop", &sort_prop_id, + "sort-data", &sort_data, "sort-reverse", &sort_reverse, NULL); rhythmdb_query_model_set_sort_order (RHYTHMDB_QUERY_MODEL (query_model), - sort_func, sort_prop_id, sort_reverse); + sort_func, GUINT_TO_POINTER (sort_data), NULL, sort_reverse); rb_debug ("getting drag data as uri list"); /* check if first selected row is 'All' */ diff --git a/rhythmdb/rhythmdb-query-model.c b/rhythmdb/rhythmdb-query-model.c index 3fbf5f08..aa951f4a 100644 --- a/rhythmdb/rhythmdb-query-model.c +++ b/rhythmdb/rhythmdb-query-model.c @@ -36,6 +36,12 @@ #include "rb-marshal.h" #include "rb-util.h" +struct ReverseSortData +{ + GCompareDataFunc func; + gpointer data; +}; + static void rhythmdb_query_model_query_results_init (RhythmDBQueryResultsIface *iface); static void rhythmdb_query_model_tree_model_init (GtkTreeModelIface *iface); static void rhythmdb_query_model_drag_source_init (RbTreeDragSourceIface *iface); @@ -151,7 +157,7 @@ static void rhythmdb_query_model_base_entry_removed (RhythmDBQueryModel *base_mo RhythmDBQueryModel *model); static int rhythmdb_query_model_child_index_to_base_index (RhythmDBQueryModel *model, int index); -static gint _reverse_sorting_func (gpointer a, gpointer b, RhythmDBQueryModel *model); +static gint _reverse_sorting_func (gpointer a, gpointer b, struct ReverseSortData *model); static gboolean rhythmdb_query_model_within_limit (RhythmDBQueryModel *model, RhythmDBEntry *entry); @@ -189,7 +195,8 @@ struct RhythmDBQueryModelPrivate RhythmDBQueryModel *base_model; GCompareDataFunc sort_func; - RhythmDBPropType sort_prop_id; + gpointer sort_data; + GDestroyNotify sort_data_destroy; gboolean sort_reverse; GPtrArray *query, *original_query; @@ -221,7 +228,8 @@ enum PROP_RHYTHMDB, PROP_QUERY, PROP_SORT_FUNC, - PROP_SORT_PROP_ID, + PROP_SORT_DATA, + PROP_SORT_DATA_DESTROY, PROP_SORT_REVERSE, PROP_LIMIT_TYPE, PROP_LIMIT_VALUE, @@ -277,12 +285,17 @@ rhythmdb_query_model_class_init (RhythmDBQueryModelClass *klass) "Sort function", G_PARAM_READWRITE)); g_object_class_install_property (object_class, - PROP_SORT_PROP_ID, - g_param_spec_int ("sort-prop", - "SortProp", - "Sort property ID", - 0, RHYTHMDB_NUM_PROPERTIES, 0, - G_PARAM_READWRITE)); + PROP_SORT_DATA, + g_param_spec_pointer ("sort-data", + "Sort data", + "Sort data", + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_SORT_DATA_DESTROY, + g_param_spec_pointer ("sort-data-destroy", + "Sort data destroy", + "Sort data destroy function", + G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_SORT_REVERSE, g_param_spec_boolean ("sort-reverse", @@ -421,8 +434,13 @@ rhythmdb_query_model_set_property (GObject *object, case PROP_SORT_FUNC: model->priv->sort_func = g_value_get_pointer (value); break; - case PROP_SORT_PROP_ID: - model->priv->sort_prop_id = g_value_get_int (value); + case PROP_SORT_DATA: + if (model->priv->sort_data_destroy && model->priv->sort_data) + model->priv->sort_data_destroy (model->priv->sort_data); + model->priv->sort_data = g_value_get_pointer (value); + break; + case PROP_SORT_DATA_DESTROY: + model->priv->sort_data_destroy = g_value_get_pointer (value); break; case PROP_SORT_REVERSE: model->priv->sort_reverse = g_value_get_boolean (value); @@ -538,8 +556,11 @@ rhythmdb_query_model_get_property (GObject *object, case PROP_SORT_FUNC: g_value_set_pointer (value, model->priv->sort_func); break; - case PROP_SORT_PROP_ID: - g_value_set_int (value, model->priv->sort_prop_id); + case PROP_SORT_DATA: + g_value_set_pointer (value, model->priv->sort_data); + break; + case PROP_SORT_DATA_DESTROY: + g_value_set_pointer (value, model->priv->sort_data_destroy); break; case PROP_SORT_REVERSE: g_value_set_boolean (value, model->priv->sort_reverse); @@ -674,6 +695,9 @@ rhythmdb_query_model_finalize (GObject *object) if (model->priv->original_query) rhythmdb_query_free (model->priv->original_query); + if (model->priv->sort_data_destroy && model->priv->sort_data) + model->priv->sort_data_destroy (model->priv->sort_data); + if (model->priv->limit_value) g_value_array_free (model->priv->limit_value); @@ -683,13 +707,15 @@ rhythmdb_query_model_finalize (GObject *object) RhythmDBQueryModel * rhythmdb_query_model_new (RhythmDB *db, GPtrArray *query, GCompareDataFunc sort_func, - RhythmDBPropType sort_prop_id, + gpointer sort_data, + GDestroyNotify sort_data_destroy, gboolean sort_reverse) { RhythmDBQueryModel *model = g_object_new (RHYTHMDB_TYPE_QUERY_MODEL, "db", db, "query", query, "sort-func", sort_func, - "sort-prop", sort_prop_id, + "sort-data", sort_data, + "sort-data-destroy", sort_data_destroy, "sort-reverse", sort_reverse, NULL); @@ -924,17 +950,26 @@ static void rhythmdb_query_model_insert_into_main_list (RhythmDBQueryModel *model, RhythmDBEntry *entry, gint index) { GSequencePtr ptr; - GCompareDataFunc sort_func = model->priv->sort_func; - rhythmdb_entry_ref (model->priv->db, entry); - if (sort_func) { - if (model->priv->sort_reverse) + if (model->priv->sort_func) { + GCompareDataFunc sort_func; + gpointer sort_data; + struct ReverseSortData reverse_data; + + if (model->priv->sort_reverse) { sort_func = (GCompareDataFunc) _reverse_sorting_func; + sort_data = &reverse_data; + reverse_data.func = model->priv->sort_func; + reverse_data.data = model->priv->sort_data; + } else { + sort_func = model->priv->sort_func; + sort_data = model->priv->sort_data; + } ptr = g_sequence_insert_sorted (model->priv->entries, entry, sort_func, - model); + sort_data); } else { if (index == -1) { ptr = g_sequence_get_end_ptr (model->priv->entries); @@ -956,17 +991,27 @@ static void rhythmdb_query_model_insert_into_limited_list (RhythmDBQueryModel *model, RhythmDBEntry *entry) { GSequencePtr ptr; - GCompareDataFunc sort_func = model->priv->sort_func; rhythmdb_entry_ref (model->priv->db, entry); - if (sort_func) { - if (model->priv->sort_reverse) + if (model->priv->sort_func) { + GCompareDataFunc sort_func; + gpointer sort_data; + struct ReverseSortData reverse_data; + + if (model->priv->sort_reverse) { sort_func = (GCompareDataFunc) _reverse_sorting_func; + sort_data = &reverse_data; + reverse_data.func = model->priv->sort_func; + reverse_data.data = model->priv->sort_data; + } else { + sort_func = model->priv->sort_func; + sort_data = model->priv->sort_data; + } ptr = g_sequence_insert_sorted (model->priv->limited_entries, entry, sort_func, - model); + sort_data); } else { ptr = g_sequence_get_end_ptr (model->priv->limited_entries); g_sequence_insert (ptr, entry); @@ -1108,18 +1153,28 @@ rhythmdb_query_model_do_reorder (RhythmDBQueryModel *model, RhythmDBEntry *entry int old_pos, new_pos; GtkTreePath *path; GtkTreeIter iter; - GCompareDataFunc sort_func = model->priv->sort_func; + GCompareDataFunc sort_func; + gpointer sort_data; + struct ReverseSortData reverse_data; - if (sort_func == NULL) + if (model->priv->sort_func == NULL) return FALSE; - if (model->priv->sort_reverse) + + if (model->priv->sort_reverse) { sort_func = (GCompareDataFunc) _reverse_sorting_func; + sort_data = &reverse_data; + reverse_data.func = model->priv->sort_func; + reverse_data.data = model->priv->sort_data; + } else { + sort_func = model->priv->sort_func; + sort_data = model->priv->sort_data; + } ptr = g_sequence_get_begin_ptr (model->priv->limited_entries); if (ptr != NULL && !g_sequence_ptr_is_end (ptr)) { RhythmDBEntry *first_limited = g_sequence_ptr_get_data (ptr); - int cmp = (sort_func) (entry, first_limited, model); + int cmp = (sort_func) (entry, first_limited, sort_data); if (cmp > 0) { /* the entry belongs in the limited list, so we don't need a re-order */ @@ -1145,7 +1200,7 @@ rhythmdb_query_model_do_reorder (RhythmDBQueryModel *model, RhythmDBEntry *entry ptr = g_sequence_insert_sorted (model->priv->entries, entry, sort_func, - model); + sort_data); new_pos = g_sequence_ptr_get_position (ptr); g_hash_table_insert (model->priv->reverse_map, entry, ptr); @@ -1851,15 +1906,18 @@ apply_updated_entry_sequence (RhythmDBQueryModel *model, GSequence *new_entries) void rhythmdb_query_model_set_sort_order (RhythmDBQueryModel *model, GCompareDataFunc sort_func, - RhythmDBPropType sort_prop_id, + gpointer sort_data, + GDestroyNotify sort_data_destroy, gboolean sort_reverse) { GSequence *new_entries; GSequencePtr ptr; int length, i; + struct ReverseSortData reverse_data; if ((model->priv->sort_func == sort_func) && - (model->priv->sort_prop_id == sort_prop_id) && + (model->priv->sort_data == sort_data) && + (model->priv->sort_data_destroy == sort_data_destroy) && (model->priv->sort_reverse == sort_reverse)) return; @@ -1868,12 +1926,20 @@ rhythmdb_query_model_set_sort_order (RhythmDBQueryModel *model, if (model->priv->sort_func == NULL) g_assert (g_sequence_get_length (model->priv->limited_entries) == 0); + if (model->priv->sort_data_destroy && model->priv->sort_data) + model->priv->sort_data_destroy (model->priv->sort_data); + model->priv->sort_func = sort_func; - model->priv->sort_prop_id = sort_prop_id; + model->priv->sort_data = sort_data; + model->priv->sort_data_destroy = sort_data_destroy; model->priv->sort_reverse = sort_reverse; - if (sort_reverse) + if (model->priv->sort_reverse) { + reverse_data.func = sort_func; + reverse_data.data = sort_data; sort_func = (GCompareDataFunc) _reverse_sorting_func; + sort_data = &reverse_data; + } /* create the new sorted entry sequence */ length = g_sequence_get_length (model->priv->entries); @@ -1885,7 +1951,7 @@ rhythmdb_query_model_set_sort_order (RhythmDBQueryModel *model, g_sequence_insert_sorted (new_entries, entry, sort_func, - model); + sort_data); ptr = g_sequence_ptr_next (ptr); } @@ -2130,14 +2196,14 @@ rhythmdb_query_model_reapply_query (RhythmDBQueryModel *model, gboolean filter) static gint _reverse_sorting_func (gpointer a, gpointer b, - RhythmDBQueryModel *model) + struct ReverseSortData *reverse_data) { - return - model->priv->sort_func (a, b, model); + return - reverse_data->func (a, b, reverse_data->data); } gint rhythmdb_query_model_location_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model) + gpointer data) { const char *a_val; const char *b_val; @@ -2158,7 +2224,7 @@ rhythmdb_query_model_location_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, gint rhythmdb_query_model_title_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model) + gpointer data) { const char *a_val; const char *b_val; @@ -2181,12 +2247,12 @@ rhythmdb_query_model_title_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, if (ret != 0) return ret; else - return rhythmdb_query_model_location_sort_func (a, b, model); + return rhythmdb_query_model_location_sort_func (a, b, data); } gint rhythmdb_query_model_album_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model) + gpointer data) { const char *a_val; const char *b_val; @@ -2235,13 +2301,13 @@ rhythmdb_query_model_album_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, } else if (b_val == NULL) return 1; else - return rhythmdb_query_model_location_sort_func (a, b, model); + return rhythmdb_query_model_location_sort_func (a, b, data); } gint rhythmdb_query_model_artist_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model) + gpointer data) { const char *a_val; const char *b_val; @@ -2263,12 +2329,12 @@ rhythmdb_query_model_artist_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, if (ret != 0) return ret; else - return rhythmdb_query_model_album_sort_func (a, b, model); + return rhythmdb_query_model_album_sort_func (a, b, data); } gint rhythmdb_query_model_genre_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model) + gpointer data) { const char *a_val; const char *b_val; @@ -2290,51 +2356,56 @@ rhythmdb_query_model_genre_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, if (ret != 0) return ret; else - return rhythmdb_query_model_artist_sort_func (a, b, model); + return rhythmdb_query_model_artist_sort_func (a, b, data); } gint rhythmdb_query_model_track_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model) + gpointer data) { - return rhythmdb_query_model_album_sort_func (a, b, model); + return rhythmdb_query_model_album_sort_func (a, b, data); } gint rhythmdb_query_model_double_ceiling_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model) + gpointer data) { gdouble a_val, b_val; + RhythmDBPropType prop_id; - a_val = ceil (rhythmdb_entry_get_double (a, model->priv->sort_prop_id)); - b_val = ceil (rhythmdb_entry_get_double (b, model->priv->sort_prop_id)); + prop_id = (RhythmDBPropType) GPOINTER_TO_INT (data); + + a_val = ceil (rhythmdb_entry_get_double (a, prop_id)); + b_val = ceil (rhythmdb_entry_get_double (b, prop_id)); if (a_val != b_val) return (a_val > b_val ? 1 : -1); else - return rhythmdb_query_model_location_sort_func (a, b, model); + return rhythmdb_query_model_location_sort_func (a, b, data); } gint rhythmdb_query_model_ulong_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model) + gpointer data) { gulong a_val, b_val; + RhythmDBPropType prop_id; - a_val = rhythmdb_entry_get_ulong (a, model->priv->sort_prop_id); - b_val = rhythmdb_entry_get_ulong (b, model->priv->sort_prop_id); + prop_id = (RhythmDBPropType) GPOINTER_TO_INT (data); + a_val = rhythmdb_entry_get_ulong (a, prop_id); + b_val = rhythmdb_entry_get_ulong (b, prop_id); if (a_val != b_val) return (a_val > b_val ? 1 : -1); else - return rhythmdb_query_model_location_sort_func (a, b, model); + return rhythmdb_query_model_location_sort_func (a, b, data); } gint rhythmdb_query_model_date_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model) + gpointer data) { gulong a_val, b_val; @@ -2349,19 +2420,21 @@ rhythmdb_query_model_date_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, else if (a_val < b_val) return -1; else - return rhythmdb_query_model_album_sort_func (a, b, model); + return rhythmdb_query_model_album_sort_func (a, b, data); } gint rhythmdb_query_model_string_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model) + gpointer data) { const char *a_val; const char *b_val; gint ret; + RhythmDBPropType prop_id; - a_val = rhythmdb_entry_get_string (a, model->priv->sort_prop_id); - b_val = rhythmdb_entry_get_string (b, model->priv->sort_prop_id); + prop_id = (RhythmDBPropType) GPOINTER_TO_INT (data); + a_val = rhythmdb_entry_get_string (a, prop_id); + b_val = rhythmdb_entry_get_string (b, prop_id); if (a_val == NULL) { if (b_val == NULL) @@ -2376,7 +2449,7 @@ rhythmdb_query_model_string_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, if (ret != 0) return ret; else - return rhythmdb_query_model_location_sort_func (a, b, model); + return rhythmdb_query_model_location_sort_func (a, b, data); } static gboolean diff --git a/rhythmdb/rhythmdb-query-model.h b/rhythmdb/rhythmdb-query-model.h index 1ea2a0a8..9be7f9c7 100644 --- a/rhythmdb/rhythmdb-query-model.h +++ b/rhythmdb/rhythmdb-query-model.h @@ -84,7 +84,8 @@ GType rhythmdb_query_model_get_type (void); RhythmDBQueryModel * rhythmdb_query_model_new (RhythmDB *db, GPtrArray *query, GCompareDataFunc sort_func, - RhythmDBPropType sort_prop_id, + gpointer sort_data, + GDestroyNotify sort_data_destroy, gboolean sort_reverse); RhythmDBQueryModel * rhythmdb_query_model_new_empty (RhythmDB *db); @@ -117,40 +118,41 @@ char * rhythmdb_query_model_compute_status_normal (RhythmDBQueryModel *model); void rhythmdb_query_model_set_sort_order (RhythmDBQueryModel *model, GCompareDataFunc sort_func, - RhythmDBPropType sort_prop_id, + gpointer sort_data, + GDestroyNotify sort_data_destroy, gboolean sort_reverse); void rhythmdb_query_model_reapply_query (RhythmDBQueryModel *model, gboolean filter); gint rhythmdb_query_model_location_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model); + gpointer data); gint rhythmdb_query_model_string_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model); + gpointer data); gint rhythmdb_query_model_title_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model); + gpointer data); gint rhythmdb_query_model_album_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model); + gpointer data); gint rhythmdb_query_model_artist_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model); + gpointer data); gint rhythmdb_query_model_genre_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model); + gpointer data); gint rhythmdb_query_model_track_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model); + gpointer data); gint rhythmdb_query_model_double_ceiling_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model); + gpointer data); gint rhythmdb_query_model_ulong_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model); + gpointer data); gint rhythmdb_query_model_date_sort_func (RhythmDBEntry *a, RhythmDBEntry *b, - RhythmDBQueryModel *model); + gpointer data); G_END_DECLS #endif /* __RHYTHMDB_QUERY_MODEL_H */ diff --git a/sources/rb-import-errors-source.c b/sources/rb-import-errors-source.c index fbc92dda..b0ed529c 100644 --- a/sources/rb-import-errors-source.c +++ b/sources/rb-import-errors-source.c @@ -135,7 +135,7 @@ rb_import_errors_source_constructor (GType type, guint n_construct_properties, RHYTHMDB_QUERY_END); source->priv->model = rhythmdb_query_model_new (source->priv->db, query, (GCompareDataFunc) rhythmdb_query_model_string_sort_func, - RHYTHMDB_PROP_LOCATION, FALSE); + GUINT_TO_POINTER (RHYTHMDB_PROP_LOCATION), NULL, FALSE); _rb_source_hide_when_empty (RB_SOURCE (source), source->priv->model); g_ptr_array_free (query, TRUE); diff --git a/sources/rb-missing-files-source.c b/sources/rb-missing-files-source.c index 6ef56105..3e1848c3 100644 --- a/sources/rb-missing-files-source.c +++ b/sources/rb-missing-files-source.c @@ -171,7 +171,7 @@ rb_missing_files_source_constructor (GType type, guint n_construct_properties, TRUE, RHYTHMDB_QUERY_END); source->priv->model = rhythmdb_query_model_new (source->priv->db, query, - NULL, 0, FALSE); + NULL, NULL, NULL, FALSE); g_ptr_array_free (query, TRUE); g_object_set (G_OBJECT (source->priv->model), "show-hidden", TRUE, NULL); diff --git a/widgets/rb-entry-view.c b/widgets/rb-entry-view.c index 1a480c56..b435021d 100644 --- a/widgets/rb-entry-view.c +++ b/widgets/rb-entry-view.c @@ -51,7 +51,7 @@ static const GtkTargetEntry rb_entry_view_drag_types[] = {{ "text/uri-list", 0, struct RBEntryViewColumnSortData { GCompareDataFunc func; - RhythmDBPropType prop_id; + gpointer data; }; static void rb_entry_view_class_init (RBEntryViewClass *klass); @@ -1147,7 +1147,7 @@ rb_entry_view_append_column (RBEntryView *view, RBEntryViewColumn coltype, gbool g_hash_table_insert (view->priv->propid_column_map, GINT_TO_POINTER (propid), column); - rb_entry_view_append_column_custom (view, column, title, key, sort_func, sort_propid); + rb_entry_view_append_column_custom (view, column, title, key, sort_func, GINT_TO_POINTER (sort_propid)); } void @@ -1156,7 +1156,7 @@ rb_entry_view_append_column_custom (RBEntryView *view, const char *title, const char *key, GCompareDataFunc sort_func, - RhythmDBPropType sort_prop_id) + gpointer data) { struct RBEntryViewColumnSortData *sortdata; @@ -1177,7 +1177,7 @@ rb_entry_view_append_column_custom (RBEntryView *view, if (sort_func != NULL) { sortdata = g_new (struct RBEntryViewColumnSortData, 1); sortdata->func = (GCompareDataFunc) sort_func; - sortdata->prop_id = sort_prop_id; + sortdata->data = data; g_hash_table_insert (view->priv->column_sort_data_map, column, sortdata); } g_hash_table_insert (view->priv->column_key_map, g_strdup (key), column); @@ -1922,7 +1922,8 @@ rb_entry_view_resort_model (RBEntryView *view) rhythmdb_query_model_set_sort_order (view->priv->model, sort_data->func, - sort_data->prop_id, + sort_data->data, + NULL, (view->priv->sorting_order == GTK_SORT_DESCENDING)); } diff --git a/widgets/rb-entry-view.h b/widgets/rb-entry-view.h index fae5ce9d..05c577ee 100644 --- a/widgets/rb-entry-view.h +++ b/widgets/rb-entry-view.h @@ -108,7 +108,7 @@ void rb_entry_view_append_column (RBEntryView *view, void rb_entry_view_append_column_custom (RBEntryView *view, GtkTreeViewColumn *column, const char *title, const char *key, GCompareDataFunc sort_func, - RhythmDBPropType sort_propid); + gpointer data); void rb_entry_view_set_columns_clickable (RBEntryView *view, gboolean clickable); -- 2.11.4.GIT