From cdbe96c5755bd0fad13c89ec92048f0f69019d01 Mon Sep 17 00:00:00 2001 From: Anna Schumaker Date: Sat, 20 Aug 2016 10:08:36 -0400 Subject: [PATCH] gui/model: Rename "Queue Model" to "Gui Model" This is going to represent a playlist soon enough, so let's just name it something more generic in case it ever has to change again. Implements #87: Rename GuiQueueModel -> GuiModel Signed-off-by: Anna Schumaker --- gui/model.c | 276 +++++++++++++++++++++---------------------- gui/ocarina.c | 4 +- gui/playlist.c | 8 +- gui/queue.c | 2 +- gui/view.c | 67 +++++------ include/gui/model.h | 83 +++++++------ tests/gui/audio.c | 4 +- tests/gui/model.c | 126 ++++++++++---------- tests/gui/playlist.c | 2 +- tests/gui/queue.c | 10 +- tests/gui/view.c | 42 +++---- 11 files changed, 307 insertions(+), 317 deletions(-) diff --git a/gui/model.c b/gui/model.c index cdd6bf17..9add5754 100644 --- a/gui/model.c +++ b/gui/model.c @@ -7,61 +7,59 @@ #include #include -static const GTypeInfo queue_type_info; -static const GInterfaceInfo queue_tree_model; +static const GInterfaceInfo gui_tree_model; +static const GTypeInfo gui_model_type_info; static GObjectClass *parent_class = NULL; -static GuiQueueModel *queue_model = NULL; +static GuiModel *queue_model = NULL; static gchar *font_current = "bold"; static gchar *font_regular = ""; -static GType queue_columns[Q_MODEL_N_COLUMNS] = { - [Q_MODEL_TRACK_NR] = G_TYPE_UINT, - [Q_MODEL_TITLE] = G_TYPE_STRING, - [Q_MODEL_LENGTH] = G_TYPE_STRING, - [Q_MODEL_ARTIST] = G_TYPE_STRING, - [Q_MODEL_ALBUM] = G_TYPE_STRING, - [Q_MODEL_YEAR] = G_TYPE_UINT, - [Q_MODEL_GENRE] = G_TYPE_STRING, - [Q_MODEL_COUNT] = G_TYPE_UINT, - [Q_MODEL_LAST_PLAY] = G_TYPE_STRING, - [Q_MODEL_FILE_PATH] = G_TYPE_STRING, - [Q_MODEL_FONT] = G_TYPE_STRING, +static GType gui_model_columns[GUI_MODEL_N_COLUMNS] = { + [GUI_MODEL_TRACK_NR] = G_TYPE_UINT, + [GUI_MODEL_TITLE] = G_TYPE_STRING, + [GUI_MODEL_LENGTH] = G_TYPE_STRING, + [GUI_MODEL_ARTIST] = G_TYPE_STRING, + [GUI_MODEL_ALBUM] = G_TYPE_STRING, + [GUI_MODEL_YEAR] = G_TYPE_UINT, + [GUI_MODEL_GENRE] = G_TYPE_STRING, + [GUI_MODEL_COUNT] = G_TYPE_UINT, + [GUI_MODEL_LAST_PLAY] = G_TYPE_STRING, + [GUI_MODEL_FILE_PATH] = G_TYPE_STRING, + [GUI_MODEL_FONT] = G_TYPE_STRING, }; -static gboolean __queue_model_iter_nth(GuiQueueModel *model, - GtkTreeIter *iter, - gint n) +static gboolean __gui_model_iter_nth(GuiModel *model, GtkTreeIter *iter, gint n) { - if (!model->gqm_queue || n >= queue_size(model->gqm_queue)) + if (!model->gm_queue || n >= queue_size(model->gm_queue)) return FALSE; - queue_iter_set(model->gqm_queue, &model->gqm_iter, n); - iter->stamp = model->gqm_stamp; - iter->user_data = &model->gqm_iter; - iter->user_data2 = queue_iter_val(&model->gqm_iter); + queue_iter_set(model->gm_queue, &model->gm_iter, n); + iter->stamp = model->gm_stamp; + iter->user_data = &model->gm_iter; + iter->user_data2 = queue_iter_val(&model->gm_iter); return TRUE; } -static GtkTreeModelFlags _queue_model_get_flags(GtkTreeModel *model) +static GtkTreeModelFlags __gui_model_get_flags(GtkTreeModel *model) { return GTK_TREE_MODEL_LIST_ONLY; } -static gint _queue_model_get_n_columns(GtkTreeModel *model) +static gint __gui_model_get_n_columns(GtkTreeModel *model) { - return Q_MODEL_N_COLUMNS; + return GUI_MODEL_N_COLUMNS; } -static GType _queue_model_get_column_type(GtkTreeModel *model, gint index) +static GType __gui_model_get_column_type(GtkTreeModel *model, gint index) { - g_return_val_if_fail(index >= 0 && index < Q_MODEL_N_COLUMNS, + g_return_val_if_fail(index >= 0 && index < GUI_MODEL_N_COLUMNS, G_TYPE_INVALID); - return queue_columns[index]; + return gui_model_columns[index]; } -static gboolean _queue_model_get_iter(GtkTreeModel *model, GtkTreeIter *iter, - GtkTreePath *path) +static gboolean __gui_model_get_iter(GtkTreeModel *model, GtkTreeIter *iter, + GtkTreePath *path) { gint *indices, depth; @@ -69,10 +67,10 @@ static gboolean _queue_model_get_iter(GtkTreeModel *model, GtkTreeIter *iter, indices = gtk_tree_path_get_indices_with_depth(path, &depth); g_assert(depth == 1); - return __queue_model_iter_nth(GUI_QUEUE_MODEL(model), iter, indices[0]); + return __gui_model_iter_nth(GUI_MODEL(model), iter, indices[0]); } -static GtkTreePath *_queue_model_get_path(GtkTreeModel *model, GtkTreeIter *iter) +static GtkTreePath *__gui_model_get_path(GtkTreeModel *model, GtkTreeIter *iter) { struct queue_iter *q_it; GtkTreePath *path; @@ -87,233 +85,229 @@ static GtkTreePath *_queue_model_get_path(GtkTreeModel *model, GtkTreeIter *iter return path; } -static void _queue_model_get_value(GtkTreeModel *model, GtkTreeIter *iter, - gint column, GValue *value) +static void __gui_model_get_value(GtkTreeModel *model, GtkTreeIter *iter, + gint column, GValue *value) { struct track *track = iter->user_data2; gchar *str; g_return_if_fail(iter != NULL); g_return_if_fail(iter->user_data2 != NULL); - g_return_if_fail(column < Q_MODEL_N_COLUMNS); + g_return_if_fail(column < GUI_MODEL_N_COLUMNS); - g_value_init(value, queue_columns[column]); + g_value_init(value, gui_model_columns[column]); switch (column) { - case Q_MODEL_TRACK_NR: + case GUI_MODEL_TRACK_NR: g_value_set_uint(value, track->tr_track); break; - case Q_MODEL_TITLE: + case GUI_MODEL_TITLE: g_value_set_static_string(value, track->tr_title); break; - case Q_MODEL_LENGTH: + case GUI_MODEL_LENGTH: g_value_take_string(value, string_sec2str(track->tr_length)); break; - case Q_MODEL_ARTIST: + case GUI_MODEL_ARTIST: g_value_set_static_string(value, track->tr_album->al_artist->ar_name); break; - case Q_MODEL_ALBUM: + case GUI_MODEL_ALBUM: g_value_set_static_string(value, track->tr_album->al_name); break; - case Q_MODEL_YEAR: + case GUI_MODEL_YEAR: g_value_set_uint(value, track->tr_album->al_year); break; - case Q_MODEL_GENRE: + case GUI_MODEL_GENRE: g_value_set_static_string(value, track->tr_album->al_genre->ge_name); break; - case Q_MODEL_COUNT: + case GUI_MODEL_COUNT: g_value_set_uint(value, track->tr_count); break; - case Q_MODEL_LAST_PLAY: + case GUI_MODEL_LAST_PLAY: g_value_take_string(value, track_last_play(track)); break; - case Q_MODEL_FILE_PATH: + case GUI_MODEL_FILE_PATH: str = track_path(track); g_value_take_string(value, g_markup_escape_text(str, -1)); g_free(str); break; - case Q_MODEL_FONT: + case GUI_MODEL_FONT: str = (track == audio_cur_track()) ? font_current : font_regular; g_value_set_static_string(value, str); break; } } -static gboolean _queue_model_iter_next(GtkTreeModel *model, GtkTreeIter *iter) +static gboolean __gui_model_iter_next(GtkTreeModel *model, GtkTreeIter *iter) { - GuiQueueModel *gqm = GUI_QUEUE_MODEL(model); + GuiModel *gqm = GUI_MODEL(model); g_return_val_if_fail(iter != NULL, FALSE); g_return_val_if_fail(iter->user_data, FALSE); g_return_val_if_fail(iter->user_data2, FALSE); - queue_iter_next(&gqm->gqm_iter); - if (gqm->gqm_iter.it_iter == NULL) + queue_iter_next(&gqm->gm_iter); + if (gqm->gm_iter.it_iter == NULL) return FALSE; - iter->stamp = gqm->gqm_stamp; - iter->user_data = &gqm->gqm_iter; - iter->user_data2 = queue_iter_val(&gqm->gqm_iter); + iter->stamp = gqm->gm_stamp; + iter->user_data = &gqm->gm_iter; + iter->user_data2 = queue_iter_val(&gqm->gm_iter); return TRUE; } -static gboolean _queue_model_iter_children(GtkTreeModel *model, - GtkTreeIter *iter, - GtkTreeIter *parent) +static gboolean __gui_model_iter_children(GtkTreeModel *model, GtkTreeIter *iter, + GtkTreeIter *parent) { if (parent) return FALSE; - return __queue_model_iter_nth(GUI_QUEUE_MODEL(model), iter, 0); + return __gui_model_iter_nth(GUI_MODEL(model), iter, 0); } -static gboolean _queue_model_iter_has_child(GtkTreeModel *model, - GtkTreeIter *iter) +static gboolean __gui_model_iter_has_child(GtkTreeModel *model, GtkTreeIter *iter) { return FALSE; } -static gint _queue_model_iter_n_children(GtkTreeModel *model, - GtkTreeIter *iter) +static gint __gui_model_iter_n_children(GtkTreeModel *model, GtkTreeIter *iter) { - if (iter != NULL || !queue_model->gqm_queue) + if (iter != NULL || !queue_model->gm_queue) return 0; - return queue_size(GUI_QUEUE_MODEL(model)->gqm_queue); + return queue_size(GUI_MODEL(model)->gm_queue); } -static gboolean _queue_model_iter_nth_child(GtkTreeModel *model, - GtkTreeIter *iter, - GtkTreeIter *parent, - gint n) +static gboolean __gui_model_iter_nth_child(GtkTreeModel *model, + GtkTreeIter *iter, + GtkTreeIter *parent, + gint n) { if (parent) return FALSE; - return __queue_model_iter_nth(GUI_QUEUE_MODEL(model), iter, n); + return __gui_model_iter_nth(GUI_MODEL(model), iter, n); } -static gboolean _queue_model_iter_parent(GtkTreeModel *model, - GtkTreeIter *iter, - GtkTreeIter *child) +static gboolean __gui_model_iter_parent(GtkTreeModel *model, GtkTreeIter *iter, + GtkTreeIter *child) { return FALSE; } -static void _queue_model_init(GuiQueueModel *model) +static void __gui_model_init(GuiModel *model) { - model->gqm_stamp = g_random_int(); + model->gm_stamp = g_random_int(); } -static void _queue_model_finalize(GObject *object) +static void __gui_model_finalize(GObject *object) { parent_class->finalize(object); } -static void _queue_model_class_init(GuiQueueModelClass *class) +static void __gui_model_class_init(GuiModelClass *class) { GObjectClass *object_class; parent_class = g_type_class_peek_parent(class); object_class = (GObjectClass *)class; - object_class->finalize = _queue_model_finalize; + object_class->finalize = __gui_model_finalize; } -static void _queue_tree_model_init(GtkTreeModelIface *iface) +static void __gui_tree_model_init(GtkTreeModelIface *iface) { - iface->get_flags = _queue_model_get_flags; - iface->get_n_columns = _queue_model_get_n_columns; - iface->get_column_type = _queue_model_get_column_type; - iface->get_iter = _queue_model_get_iter; - iface->get_path = _queue_model_get_path; - iface->get_value = _queue_model_get_value; - iface->iter_next = _queue_model_iter_next; - iface->iter_children = _queue_model_iter_children; - iface->iter_has_child = _queue_model_iter_has_child; - iface->iter_n_children = _queue_model_iter_n_children; - iface->iter_nth_child = _queue_model_iter_nth_child; - iface->iter_parent = _queue_model_iter_parent; + iface->get_flags = __gui_model_get_flags; + iface->get_n_columns = __gui_model_get_n_columns; + iface->get_column_type = __gui_model_get_column_type; + iface->get_iter = __gui_model_get_iter; + iface->get_path = __gui_model_get_path; + iface->get_value = __gui_model_get_value; + iface->iter_next = __gui_model_iter_next; + iface->iter_children = __gui_model_iter_children; + iface->iter_has_child = __gui_model_iter_has_child; + iface->iter_n_children = __gui_model_iter_n_children; + iface->iter_nth_child = __gui_model_iter_nth_child; + iface->iter_parent = __gui_model_iter_parent; } -static void __gui_queue_model_set_runtime(void) +static void __gui_model_set_runtime(void) { gchar *len = NULL; - if (queue_model->gqm_queue) - len = string_sec2str_long(queue_model->gqm_queue->q_length); + if (queue_model->gm_queue) + len = string_sec2str_long(queue_model->gm_queue->q_length); gtk_label_set_text(GTK_LABEL(gui_builder_widget("o_runtime")), len); g_free(len); } -void gui_queue_model_init(void) +void gui_model_init(void) { - queue_model = g_object_new(GUI_QUEUE_MODEL_TYPE, NULL); + queue_model = g_object_new(GUI_MODEL_TYPE, NULL); g_assert(queue_model != NULL); - queue_model->gqm_queue = NULL; + queue_model->gm_queue = NULL; } -void gui_queue_model_deinit(void) +void gui_model_deinit(void) { g_object_unref(queue_model); queue_model = NULL; } -GuiQueueModel *gui_queue_model_get(void) +GuiModel *gui_model_get(void) { return queue_model; } -GType gui_queue_model_get_type() +GType gui_model_get_type() { - static GType queue_type = 0; + static GType gui_model_type = 0; - if (queue_type == 0) { - queue_type = g_type_register_static(G_TYPE_OBJECT, - "GuiQueueModel", - &queue_type_info, - (GTypeFlags)0); - g_type_add_interface_static(queue_type, + if (gui_model_type == 0) { + gui_model_type = g_type_register_static(G_TYPE_OBJECT, + "GuiModel", + &gui_model_type_info, + (GTypeFlags)0); + g_type_add_interface_static(gui_model_type, GTK_TYPE_TREE_MODEL, - &queue_tree_model); + &gui_tree_model); } - return queue_type; + return gui_model_type; } -void gui_queue_model_add(struct queue *queue, unsigned int row) +void gui_model_add(struct queue *queue, unsigned int row) { GtkTreePath *path; GtkTreeIter iter; - if (!queue_model || queue != queue_model->gqm_queue) + if (!queue_model || queue != queue_model->gm_queue) return; path = gtk_tree_path_new_from_indices(row, -1); - _queue_model_get_iter(GTK_TREE_MODEL(queue_model), &iter, path); + __gui_model_get_iter(GTK_TREE_MODEL(queue_model), &iter, path); gtk_tree_model_row_inserted(GTK_TREE_MODEL(queue_model), path, &iter); - __gui_queue_model_set_runtime(); + __gui_model_set_runtime(); gtk_tree_path_free(path); } -void gui_queue_model_remove(struct queue *queue, unsigned int row) +void gui_model_remove(struct queue *queue, unsigned int row) { GtkTreePath *path; - if (queue != queue_model->gqm_queue) + if (queue != queue_model->gm_queue) return; path = gtk_tree_path_new_from_indices(row, -1); gtk_tree_model_row_deleted(GTK_TREE_MODEL(queue_model), path); - __gui_queue_model_set_runtime(); + __gui_model_set_runtime(); gtk_tree_path_free(path); } -void gui_queue_model_clear(struct queue *queue, unsigned int n) +void gui_model_clear(struct queue *queue, unsigned int n) { GtkTreePath *path; unsigned int i; - if (queue != queue_model->gqm_queue) + if (queue != queue_model->gm_queue) return; path = gtk_tree_path_new_from_indices(n - 1, -1); @@ -322,67 +316,67 @@ void gui_queue_model_clear(struct queue *queue, unsigned int n) gtk_tree_path_prev(path); } - __gui_queue_model_set_runtime(); + __gui_model_set_runtime(); gtk_tree_path_free(path); } -void gui_queue_model_update(struct queue *queue, unsigned int row) +void gui_model_update(struct queue *queue, unsigned int row) { GtkTreePath *path; GtkTreeIter iter; - if (queue != queue_model->gqm_queue) + if (queue != queue_model->gm_queue) return; path = gtk_tree_path_new_from_indices(row, -1); - _queue_model_get_iter(GTK_TREE_MODEL(queue_model), &iter, path); + __gui_model_get_iter(GTK_TREE_MODEL(queue_model), &iter, path); gtk_tree_model_row_changed(GTK_TREE_MODEL(queue_model), path, &iter); - __gui_queue_model_set_runtime(); + __gui_model_set_runtime(); gtk_tree_path_free(path); } -void gui_queue_model_set_queue(struct queue *queue) +void gui_model_set_queue(struct queue *queue) { - struct queue *cur = queue_model->gqm_queue; + struct queue *cur = queue_model->gm_queue; if (cur) - gui_queue_model_clear(cur, queue_size(cur)); + gui_model_clear(cur, queue_size(cur)); - queue_model->gqm_queue = queue; - __gui_queue_model_set_runtime(); + queue_model->gm_queue = queue; + __gui_model_set_runtime(); if (queue && queue_size(queue) > 0) - gui_queue_model_add(queue, 0); + gui_model_add(queue, 0); } -struct queue *gui_queue_model_get_queue(void) +struct queue *gui_model_get_queue(void) { - return queue_model->gqm_queue; + return queue_model->gm_queue; } -struct track * gui_queue_model_path_get_track(GtkTreePath *path) +struct track * gui_model_path_get_track(GtkTreePath *path) { GtkTreeIter iter; - _queue_model_get_iter(GTK_TREE_MODEL(queue_model), &iter, path); - return gui_queue_model_iter_get_track(&iter); + __gui_model_get_iter(GTK_TREE_MODEL(queue_model), &iter, path); + return gui_model_iter_get_track(&iter); } -static const GTypeInfo queue_type_info = { - .class_size = sizeof(GuiQueueModelClass), +static const GTypeInfo gui_model_type_info = { + .class_size = sizeof(GuiModelClass), .base_init = NULL, .base_finalize = NULL, - .class_init = (GClassInitFunc)_queue_model_class_init, + .class_init = (GClassInitFunc)__gui_model_class_init, .class_finalize = NULL, .class_data = NULL, - .instance_size = sizeof(GuiQueueModel), + .instance_size = sizeof(GuiModel), .n_preallocs = 0, - .instance_init = (GInstanceInitFunc)_queue_model_init, + .instance_init = (GInstanceInitFunc)__gui_model_init, }; -static const GInterfaceInfo queue_tree_model = { - .interface_init = (GInterfaceInitFunc)_queue_tree_model_init, +static const GInterfaceInfo gui_tree_model = { + .interface_init = (GInterfaceInitFunc)__gui_tree_model_init, .interface_finalize = NULL, .interface_data = NULL, }; diff --git a/gui/ocarina.c b/gui/ocarina.c index ca838831..a617d7f5 100644 --- a/gui/ocarina.c +++ b/gui/ocarina.c @@ -102,7 +102,7 @@ static void __ocarina_startup(GApplication *application, gpointer data) gui_builder_init(ui); core_init(&startup_argc, &startup_argv, &init_data); gui_window_init(icon); - gui_queue_model_init(); + gui_model_init(); gui_view_init(); gui_queue_init(); gui_sidebar_init(); @@ -121,7 +121,7 @@ static void __ocarina_shutdown(GApplication *application, gpointer data) gui_idle_disable(); core_deinit(); - gui_queue_model_deinit(); + gui_model_deinit(); gui_window_deinit(); gui_builder_deinit(); } diff --git a/gui/playlist.c b/gui/playlist.c index b8bd0c22..fecb87b6 100644 --- a/gui/playlist.c +++ b/gui/playlist.c @@ -259,19 +259,19 @@ static void *__playlist_init(struct queue *queue, void *data) static void __playlist_added(struct queue *queue, unsigned int row) { - gui_queue_model_add(queue, row); + gui_model_add(queue, row); __playlist_update_sizes(queue); } static void __playlist_removed(struct queue *queue, unsigned int row) { - gui_queue_model_remove(queue, row); + gui_model_remove(queue, row); __playlist_update_sizes(queue); } static void __playlist_cleared(struct queue *queue, unsigned int n) { - gui_queue_model_clear(queue, n); + gui_model_clear(queue, n); __playlist_update_sizes(queue); } @@ -481,5 +481,5 @@ struct queue_ops playlist_ops = { .qop_erase = __playlist_erase, .qop_removed = __playlist_removed, .qop_cleared = __playlist_cleared, - .qop_updated = gui_queue_model_update, + .qop_updated = gui_model_update, }; diff --git a/gui/queue.c b/gui/queue.c index ed90867b..b4733016 100644 --- a/gui/queue.c +++ b/gui/queue.c @@ -54,7 +54,7 @@ static gboolean __queue_visible_func(GtkTreeModel *model, GtkTreeIter *iter, if (!gq_queue || !gq_queue->gq_search) return TRUE; - track = gui_queue_model_iter_get_track(iter); + track = gui_model_iter_get_track(iter); for (i = 0; gq_queue->gq_search[i]; i++) { token = gq_queue->gq_search[i]; diff --git a/gui/view.c b/gui/view.c index 3fe992c1..2161d4a9 100644 --- a/gui/view.c +++ b/gui/view.c @@ -12,30 +12,27 @@ #include #include -static const gchar *QUEUE_SETTINGS[Q_MODEL_N_COLUMNS] = { - [Q_MODEL_TRACK_NR] = "gui.queue.track", - [Q_MODEL_TITLE] = "gui.queue.title", - [Q_MODEL_LENGTH] = "gui.queue.length", - [Q_MODEL_ARTIST] = "gui.queue.artist", - [Q_MODEL_ALBUM] = "gui.queue.album", - [Q_MODEL_YEAR] = "gui.queue.year", - [Q_MODEL_GENRE] = "gui.queue.genre", - [Q_MODEL_COUNT] = "gui.queue.count", - [Q_MODEL_LAST_PLAY] = NULL, - [Q_MODEL_FILE_PATH] = NULL, - [Q_MODEL_FONT] = NULL, +static const gchar *QUEUE_SETTINGS[GUI_MODEL_N_COLUMNS] = { + [GUI_MODEL_TRACK_NR] = "gui.queue.track", + [GUI_MODEL_TITLE] = "gui.queue.title", + [GUI_MODEL_LENGTH] = "gui.queue.length", + [GUI_MODEL_ARTIST] = "gui.queue.artist", + [GUI_MODEL_ALBUM] = "gui.queue.album", + [GUI_MODEL_YEAR] = "gui.queue.year", + [GUI_MODEL_GENRE] = "gui.queue.genre", + [GUI_MODEL_COUNT] = "gui.queue.count", }; -static const enum compare_t QUEUE_SORT[Q_MODEL_N_COLUMNS] = { - [Q_MODEL_TRACK_NR] = COMPARE_TRACK, - [Q_MODEL_TITLE] = COMPARE_TITLE, - [Q_MODEL_LENGTH] = COMPARE_LENGTH, - [Q_MODEL_ARTIST] = COMPARE_ARTIST, - [Q_MODEL_ALBUM] = COMPARE_ALBUM, - [Q_MODEL_YEAR] = COMPARE_YEAR, - [Q_MODEL_GENRE] = COMPARE_GENRE, - [Q_MODEL_COUNT] = COMPARE_COUNT, - [Q_MODEL_LAST_PLAY] = COMPARE_PLAYED, +static const enum compare_t QUEUE_SORT[GUI_MODEL_N_COLUMNS] = { + [GUI_MODEL_TRACK_NR] = COMPARE_TRACK, + [GUI_MODEL_TITLE] = COMPARE_TITLE, + [GUI_MODEL_LENGTH] = COMPARE_LENGTH, + [GUI_MODEL_ARTIST] = COMPARE_ARTIST, + [GUI_MODEL_ALBUM] = COMPARE_ALBUM, + [GUI_MODEL_YEAR] = COMPARE_YEAR, + [GUI_MODEL_GENRE] = COMPARE_GENRE, + [GUI_MODEL_COUNT] = COMPARE_COUNT, + [GUI_MODEL_LAST_PLAY] = COMPARE_PLAYED, }; static GtkTreeView *view_treeview = NULL; @@ -51,7 +48,7 @@ static inline GtkTreePath *__view_filter_convert_path(GtkTreePath *orig) static struct track *__view_filter_get_track(GtkTreePath *orig) { GtkTreePath *real = __view_filter_convert_path(orig); - struct track *track = gui_queue_model_path_get_track(real); + struct track *track = gui_model_path_get_track(real); gtk_tree_path_free(real); return track; @@ -71,14 +68,14 @@ static unsigned int __view_get_column_index(GtkTreeViewColumn *col) unsigned int i; if (!view_treeview) - return Q_MODEL_N_COLUMNS; + return GUI_MODEL_N_COLUMNS; - for (i = 0; i < Q_MODEL_N_COLUMNS; i++) { + for (i = 0; i < GUI_MODEL_N_COLUMNS; i++) { if (col == gtk_tree_view_get_column(view_treeview, i)) return i; } - return Q_MODEL_N_COLUMNS; + return GUI_MODEL_N_COLUMNS; } static inline void __view_display_sorting(gchar *text) @@ -98,7 +95,7 @@ static int __view_dec_sort(gpointer data) static void __view_set_column_sort_indicator(GtkTreeViewColumn *col, unsigned int index) { - struct queue *queue = gui_queue_model_get_queue(); + struct queue *queue = gui_model_get_queue(); GSList *cur = queue ? queue->q_sort : NULL; unsigned int order = GTK_SORT_ASCENDING; bool show = false; @@ -126,7 +123,7 @@ static void __view_set_sort_indicators() { GtkTreeViewColumn *col; - for (unsigned int i = 0; i < Q_MODEL_N_COLUMNS; i++) { + for (unsigned int i = 0; i < GUI_MODEL_N_COLUMNS; i++) { col = gtk_tree_view_get_column(view_treeview, i); if (col) __view_set_column_sort_indicator(col, i); @@ -138,7 +135,7 @@ void __view_row_activated(GtkTreeView *treeview, GtkTreePath *path, { view_no_scroll = true; audio_load(__view_filter_get_track(path)); - queue_selected(gui_queue_model_get_queue(), + queue_selected(gui_model_get_queue(), gtk_tree_path_get_indices(path)[0]); view_no_scroll = false; } @@ -153,7 +150,7 @@ void __view_column_resized(GtkTreeViewColumn *col, GParamSpec *pspec, void __view_column_clicked(GtkTreeViewColumn *col, gpointer data) { - struct queue *queue = gui_queue_model_get_queue(); + struct queue *queue = gui_model_get_queue(); unsigned int index = __view_get_column_index(col); bool reset = view_sort_count == 0; gchar *text; @@ -193,7 +190,7 @@ static void __view_add_to_playlist(GtkTreeModel *model, GtkTreePath *path, static void __view_delete_selection(GtkTreeSelection *selection) { - struct queue *queue = gui_queue_model_get_queue(); + struct queue *queue = gui_model_get_queue(); GList *rows = gtk_tree_selection_get_selected_rows(selection, NULL); GList *cur = g_list_reverse(rows); @@ -408,9 +405,9 @@ void gui_view_init() view_treeview = GTK_TREE_VIEW(gui_builder_widget("o_treeview")); view_filter = GTK_TREE_MODEL_FILTER(gtk_tree_model_filter_new( - GTK_TREE_MODEL(gui_queue_model_get()), NULL)); + GTK_TREE_MODEL(gui_model_get()), NULL)); - for (i = 0; i < Q_MODEL_N_COLUMNS; i++) { + for (i = 0; i < GUI_MODEL_N_COLUMNS; i++) { col = gtk_tree_view_get_column(view_treeview, i); pos = settings_get(QUEUE_SETTINGS[i]); if (col && pos > 0) @@ -427,7 +424,7 @@ GtkTreeModelFilter *gui_view_get_filter(void) void gui_view_set_queue(struct queue *queue) { - gui_queue_model_set_queue(queue); + gui_model_set_queue(queue); view_sort_count = 0; __view_display_sorting(""); @@ -438,7 +435,7 @@ void gui_view_set_queue(struct queue *queue) void gui_view_scroll() { - struct queue *queue = gui_queue_model_get_queue(); + struct queue *queue = gui_model_get_queue(); GtkTreePath *real, *path; if (!queue || (int)queue->q_cur.it_pos < 0 || view_no_scroll) diff --git a/include/gui/model.h b/include/gui/model.h index dad48b72..f5690ddd 100644 --- a/include/gui/model.h +++ b/include/gui/model.h @@ -6,76 +6,75 @@ #include #include -#define GUI_QUEUE_MODEL_TYPE (gui_queue_model_get_type()) -#define GUI_QUEUE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), \ - GUI_QUEUE_MODEL_TYPE, GuiQueueModel)) +#define GUI_MODEL_TYPE (gui_model_get_type()) +#define GUI_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), \ + GUI_MODEL_TYPE, GuiModel)) -enum queue_model_columns { - Q_MODEL_TRACK_NR, - Q_MODEL_TITLE, - Q_MODEL_LENGTH, - Q_MODEL_ARTIST, - Q_MODEL_ALBUM, - Q_MODEL_YEAR, - Q_MODEL_GENRE, - Q_MODEL_COUNT, - Q_MODEL_LAST_PLAY, - Q_MODEL_FILE_PATH, - Q_MODEL_FONT, - Q_MODEL_N_COLUMNS, +enum gui_model_columns { + GUI_MODEL_TRACK_NR, + GUI_MODEL_TITLE, + GUI_MODEL_LENGTH, + GUI_MODEL_ARTIST, + GUI_MODEL_ALBUM, + GUI_MODEL_YEAR, + GUI_MODEL_GENRE, + GUI_MODEL_COUNT, + GUI_MODEL_LAST_PLAY, + GUI_MODEL_FILE_PATH, + GUI_MODEL_FONT, + GUI_MODEL_N_COLUMNS, }; -typedef struct _gui_queue_model GuiQueueModel; -typedef struct _gui_queue_model_class GuiQueueModelClass; +struct gui_model { + GObject gm_parent; /* This MUST be the first member. */ + gint gm_stamp; /* This is used to check iter validity. */ -struct _gui_queue_model { - GObject gqm_parent; /* This MUST be the first member. */ - gint gqm_stamp; /* This is used to check iter validity. */ - - struct queue *gqm_queue; /* The model's associated queue. */ - struct queue_iter gqm_iter; /* The current _q_iter. */ + struct queue *gm_queue; /* The model's associated queue. */ + struct queue_iter gm_iter; /* The current _q_iter. */ }; +typedef struct gui_model GuiModel; -struct _gui_queue_model_class { + +struct gui_model_class { GObjectClass parent_class; }; +typedef struct gui_model_class GuiModelClass; -/* Called to initialize the GuiQueueModel */ -void gui_queue_model_init(void); +/* Called to initialize the GuiModel */ +void gui_model_init(void); -/* Called to deinitialize the GuiQueueModel */ -void gui_queue_model_deinit(void); +/* Called to deinitialize the GuiModel */ +void gui_model_deinit(void); -/* Called to get the GuiQueueModel */ -GuiQueueModel *gui_queue_model_get(void); +/* Called to get the GuiModel */ +GuiModel *gui_model_get(void); -/* Called to find the GType of the GuiQueueModel */ -GType gui_queue_model_get_type(); +/* Called to find the GType of the GuiModel */ +GType gui_model_get_type(); /* Called to add a row to the model */ -void gui_queue_model_add(struct queue *, unsigned int); +void gui_model_add(struct queue *, unsigned int); /* Called to remove a row from the model */ -void gui_queue_model_remove(struct queue *, unsigned int); +void gui_model_remove(struct queue *, unsigned int); /* Called to remove all rows from the model */ -void gui_queue_model_clear(struct queue *, unsigned int); +void gui_model_clear(struct queue *, unsigned int); /* Called to update a row in the model */ -void gui_queue_model_update(struct queue *, unsigned int); +void gui_model_update(struct queue *, unsigned int); /* Called to change the queue represented by the model. */ -void gui_queue_model_set_queue(struct queue *); +void gui_model_set_queue(struct queue *); /* Called to get the queue currently attached to the model. */ -struct queue *gui_queue_model_get_queue(void); +struct queue *gui_model_get_queue(void); /* Called to convert a GtkTreeIter into a struct track */ -static inline -struct track *gui_queue_model_iter_get_track(GtkTreeIter *iter) +static inline struct track *gui_model_iter_get_track(GtkTreeIter *iter) { g_return_val_if_fail(iter != NULL, NULL); g_return_val_if_fail(iter->user_data2 != NULL, NULL); @@ -83,6 +82,6 @@ struct track *gui_queue_model_iter_get_track(GtkTreeIter *iter) } /* Called to convert a GtkTreePath into a struct track */ -struct track *gui_queue_model_path_get_track(GtkTreePath *); +struct track *gui_model_path_get_track(GtkTreePath *); #endif /* OCARINA_GUI_MODEL_H */ diff --git a/tests/gui/audio.c b/tests/gui/audio.c index 044628e6..aad23f8e 100644 --- a/tests/gui/audio.c +++ b/tests/gui/audio.c @@ -134,7 +134,7 @@ int main(int argc, char **argv) gtk_init(&argc, NULL); gui_builder_init("share/ocarina/ocarina.ui"); - gui_queue_model_init(); + gui_model_init(); core_init(&argc, NULL, &init_data); playlist_new(PL_LIBRARY, "tests/Music/Hyrule Symphony"); while (idle_run_task()) {}; @@ -144,7 +144,7 @@ int main(int argc, char **argv) ret = g_test_run(); gui_window_deinit(); - gui_queue_model_deinit(); + gui_model_deinit(); gui_builder_deinit(); core_deinit(); return ret; diff --git a/tests/gui/model.c b/tests/gui/model.c index c2197cb3..b713c5aa 100644 --- a/tests/gui/model.c +++ b/tests/gui/model.c @@ -35,11 +35,11 @@ void test_on_config_pause(int count) {} struct queue_ops test_ops = { .qop_init = test_queue_init, .qop_deinit = test_queue_deinit, - .qop_added = gui_queue_model_add, - .qop_removed = gui_queue_model_remove, - .qop_cleared = gui_queue_model_clear, + .qop_added = gui_model_add, + .qop_removed = gui_model_remove, + .qop_cleared = gui_model_clear, .qop_save = test_queue_save, - .qop_updated = gui_queue_model_update, + .qop_updated = gui_model_update, }; struct audio_ops test_audio_ops = { @@ -56,45 +56,45 @@ struct core_init_data init_data = { static void test_init() { GtkTreeModel *treemodel; - GuiQueueModel *model; + GuiModel *model; GType type; - gui_queue_model_init(); - model = gui_queue_model_get(); - g_assert_null(gui_queue_model_get_queue()); - gui_queue_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection")); + gui_model_init(); + model = gui_model_get(); + g_assert_null(gui_model_get_queue()); + gui_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection")); g_assert_nonnull(model); g_assert_true(GTK_IS_TREE_MODEL(model)); - g_assert(gui_queue_model_get_queue() == playlist_get_queue(PL_SYSTEM, "Collection")); + g_assert(gui_model_get_queue() == playlist_get_queue(PL_SYSTEM, "Collection")); treemodel = GTK_TREE_MODEL(model); g_assert_cmpuint(gtk_tree_model_get_flags(treemodel), ==, GTK_TREE_MODEL_LIST_ONLY); g_assert_cmpuint(gtk_tree_model_get_n_columns(treemodel), ==, 11); - type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_TRACK_NR); + type = gtk_tree_model_get_column_type(treemodel, GUI_MODEL_TRACK_NR); g_assert_cmpuint(type, ==, G_TYPE_UINT); - type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_TITLE); + type = gtk_tree_model_get_column_type(treemodel, GUI_MODEL_TITLE); g_assert_cmpuint(type, ==, G_TYPE_STRING); - type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_LENGTH); + type = gtk_tree_model_get_column_type(treemodel, GUI_MODEL_LENGTH); g_assert_cmpuint(type, ==, G_TYPE_STRING); - type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_ARTIST); + type = gtk_tree_model_get_column_type(treemodel, GUI_MODEL_ARTIST); g_assert_cmpuint(type, ==, G_TYPE_STRING); - type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_ALBUM); + type = gtk_tree_model_get_column_type(treemodel, GUI_MODEL_ALBUM); g_assert_cmpuint(type, ==, G_TYPE_STRING); - type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_YEAR); + type = gtk_tree_model_get_column_type(treemodel, GUI_MODEL_YEAR); g_assert_cmpuint(type, ==, G_TYPE_UINT); - type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_GENRE); + type = gtk_tree_model_get_column_type(treemodel, GUI_MODEL_GENRE); g_assert_cmpuint(type, ==, G_TYPE_STRING); - type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_COUNT); + type = gtk_tree_model_get_column_type(treemodel, GUI_MODEL_COUNT); g_assert_cmpuint(type, ==, G_TYPE_UINT); - type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_LAST_PLAY); + type = gtk_tree_model_get_column_type(treemodel, GUI_MODEL_LAST_PLAY); g_assert_cmpuint(type, ==, G_TYPE_STRING); - type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_FILE_PATH); + type = gtk_tree_model_get_column_type(treemodel, GUI_MODEL_FILE_PATH); g_assert_cmpuint(type, ==, G_TYPE_STRING); - type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_FONT); + type = gtk_tree_model_get_column_type(treemodel, GUI_MODEL_FONT); g_assert_cmpuint(type, ==, G_TYPE_STRING); - gui_queue_model_deinit(); + gui_model_deinit(); g_assert_false(G_IS_OBJECT(model)); } @@ -105,40 +105,40 @@ static void __test_empty_subprocess() GValue value; GType type; - gui_queue_model_init(); - model = GTK_TREE_MODEL(gui_queue_model_get()); - gui_queue_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection")); + gui_model_init(); + model = GTK_TREE_MODEL(gui_model_get()); + gui_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection")); memset(&value, 0, sizeof(GValue)); g_assert_false(gtk_tree_model_get_iter_first(model, &iter)); g_assert_null(gtk_tree_model_get_path(model, &iter)); - g_assert_null(gui_queue_model_iter_get_track(&iter)); + g_assert_null(gui_model_iter_get_track(&iter)); /* These will all trigger assertion failures ... sorry */ - gtk_tree_model_get_value(model, &iter, Q_MODEL_TRACK_NR, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_TRACK_NR, &value); g_assert_false(G_IS_VALUE(&value)); - gtk_tree_model_get_value(model, &iter, Q_MODEL_TITLE, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_TITLE, &value); g_assert_false(G_IS_VALUE(&value)); - gtk_tree_model_get_value(model, &iter, Q_MODEL_LENGTH, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_LENGTH, &value); g_assert_false(G_IS_VALUE(&value)); - gtk_tree_model_get_value(model, &iter, Q_MODEL_ARTIST, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_ARTIST, &value); g_assert_false(G_IS_VALUE(&value)); - gtk_tree_model_get_value(model, &iter, Q_MODEL_ALBUM, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_ALBUM, &value); g_assert_false(G_IS_VALUE(&value)); - gtk_tree_model_get_value(model, &iter, Q_MODEL_YEAR, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_YEAR, &value); g_assert_false(G_IS_VALUE(&value)); - gtk_tree_model_get_value(model, &iter, Q_MODEL_GENRE, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_GENRE, &value); g_assert_false(G_IS_VALUE(&value)); - gtk_tree_model_get_value(model, &iter, Q_MODEL_COUNT, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_COUNT, &value); g_assert_false(G_IS_VALUE(&value)); - gtk_tree_model_get_value(model, &iter, Q_MODEL_LAST_PLAY, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_LAST_PLAY, &value); g_assert_false(G_IS_VALUE(&value)); - gtk_tree_model_get_value(model, &iter, Q_MODEL_FILE_PATH, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_FILE_PATH, &value); g_assert_false(G_IS_VALUE(&value)); - gtk_tree_model_get_value(model, &iter, Q_MODEL_FONT, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_FONT, &value); g_assert_false(G_IS_VALUE(&value)); - type = gtk_tree_model_get_column_type(model, Q_MODEL_N_COLUMNS); + type = gtk_tree_model_get_column_type(model, GUI_MODEL_N_COLUMNS); g_assert_cmpuint(type, ==, G_TYPE_INVALID); g_assert_false(gtk_tree_model_iter_next(model, &iter)); @@ -149,7 +149,7 @@ static void __test_empty_subprocess() g_assert_false(gtk_tree_model_iter_nth_child(model, &iter, NULL, 3)); g_assert_false(gtk_tree_model_iter_parent(model, &iter, &iter)); - gui_queue_model_deinit(); + gui_model_deinit(); } static void test_empty() @@ -173,9 +173,9 @@ static void test_model() GtkLabel *label; GValue value; - model = GTK_TREE_MODEL(gui_queue_model_get()); + model = GTK_TREE_MODEL(gui_model_get()); label = GTK_LABEL(gui_builder_widget("o_runtime")); - gui_queue_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection")); + gui_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection")); g_assert_cmpstr(gtk_label_get_text(label), ==, ""); memset(&value, 0, sizeof(GValue)); @@ -199,85 +199,85 @@ static void test_model() /* ... and test again */ g_assert_true(gtk_tree_model_get_iter_first(model, &iter)); - track = gui_queue_model_iter_get_track(&iter); + track = gui_model_iter_get_track(&iter); g_assert_cmpuint(track->tr_track, ==, 1); audio_load(track); path = gtk_tree_model_get_path(model, &iter); g_assert_nonnull(path); g_assert_cmpuint(gtk_tree_path_get_indices(path)[0], ==, 0); - g_assert(gui_queue_model_path_get_track(path) == track); + g_assert(gui_model_path_get_track(path) == track); gtk_tree_path_free(path); - gtk_tree_model_get_value(model, &iter, Q_MODEL_TRACK_NR, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_TRACK_NR, &value); g_assert_cmpuint(g_value_get_uint(&value), ==, track->tr_track); g_value_unset(&value); - gtk_tree_model_get_value(model, &iter, Q_MODEL_TITLE, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_TITLE, &value); g_assert_cmpstr(g_value_get_string(&value), ==, "Title Theme"); g_value_unset(&value); - gtk_tree_model_get_value(model, &iter, Q_MODEL_LENGTH, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_LENGTH, &value); g_assert_cmpstr(g_value_get_string(&value), ==, "4:03"); g_value_unset(&value); - gtk_tree_model_get_value(model, &iter, Q_MODEL_ARTIST, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_ARTIST, &value); g_assert_cmpstr(g_value_get_string(&value), ==, "Koji Kondo"); g_value_unset(&value); - gtk_tree_model_get_value(model, &iter, Q_MODEL_ALBUM, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_ALBUM, &value); g_assert_cmpstr(g_value_get_string(&value), ==, "Hyrule Symphony"); g_value_unset(&value); - gtk_tree_model_get_value(model, &iter, Q_MODEL_YEAR, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_YEAR, &value); g_assert_cmpuint(g_value_get_uint(&value), ==, 1998); g_value_unset(&value); - gtk_tree_model_get_value(model, &iter, Q_MODEL_GENRE, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_GENRE, &value); g_assert_cmpstr(g_value_get_string(&value), ==, "Game"); g_value_unset(&value); - gtk_tree_model_get_value(model, &iter, Q_MODEL_COUNT, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_COUNT, &value); g_assert_cmpuint(g_value_get_uint(&value), ==, 0); g_value_unset(&value); - gtk_tree_model_get_value(model, &iter, Q_MODEL_LAST_PLAY, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_LAST_PLAY, &value); g_assert_cmpstr(g_value_get_string(&value), ==, "Never"); g_value_unset(&value); - gtk_tree_model_get_value(model, &iter, Q_MODEL_FILE_PATH, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_FILE_PATH, &value); g_assert_cmpstr(g_value_get_string(&value), ==, "tests/Music/Hyrule Symphony/01 - Title Theme.ogg"); g_value_unset(&value); - gtk_tree_model_get_value(model, &iter, Q_MODEL_FONT, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_FONT, &value); g_assert_cmpstr(g_value_get_string(&value), ==, "bold"); g_value_unset(&value); g_assert_true(gtk_tree_model_iter_next(model, &iter)); - track = gui_queue_model_iter_get_track(&iter); + track = gui_model_iter_get_track(&iter); g_assert_cmpuint(track->tr_track, ==, 2); - gtk_tree_model_get_value(model, &iter, Q_MODEL_FONT, &value); + gtk_tree_model_get_value(model, &iter, GUI_MODEL_FONT, &value); g_assert_cmpstr(g_value_get_string(&value), ==, ""); g_value_unset(&value); g_assert_true(gtk_tree_model_iter_children(model, &iter, NULL)); - track = gui_queue_model_iter_get_track(&iter); + track = gui_model_iter_get_track(&iter); g_assert_cmpuint(track->tr_track, ==, 1); g_assert_false(gtk_tree_model_iter_has_child(model, &iter)); g_assert_cmpuint(gtk_tree_model_iter_n_children(model, &iter), ==, 0); g_assert_cmpuint(gtk_tree_model_iter_n_children(model, NULL), ==, 13); - gui_queue_model_set_queue(playlist_get_queue(PL_SYSTEM, "Favorites")); + gui_model_set_queue(playlist_get_queue(PL_SYSTEM, "Favorites")); g_assert_cmpuint(count_delete, ==, 13); g_assert_cmpuint(count_insert, ==, 14); g_assert_cmpuint(gtk_tree_model_iter_n_children(model, NULL), ==, 3); g_assert_cmpstr(gtk_label_get_text(label), ==, "10 minutes, 46 seconds"); - gui_queue_model_set_queue(NULL); + gui_model_set_queue(NULL); g_assert_cmpuint(count_delete, ==, 16); g_assert_cmpuint(count_insert, ==, 14); g_assert_cmpuint(gtk_tree_model_iter_n_children(model, NULL), ==, 0); g_assert_cmpstr(gtk_label_get_text(label), ==, ""); - gui_queue_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection")); + gui_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection")); g_assert_cmpuint(count_delete, ==, 16); g_assert_cmpuint(count_insert, ==, 15); g_assert_cmpstr(gtk_label_get_text(label), ==, "42 minutes, 45 seconds"); g_assert_true(gtk_tree_model_iter_nth_child(model, &iter, NULL, 3)); - track = gui_queue_model_iter_get_track(&iter); + track = gui_model_iter_get_track(&iter); g_assert_cmpuint(track->tr_track, ==, 4); g_assert_false(gtk_tree_model_iter_parent(model, &iter, &iter)); @@ -287,7 +287,7 @@ static void test_model() g_assert_cmpuint(count_delete, ==, 29); core_deinit(); - gui_queue_model_deinit(); + gui_model_deinit(); } int main(int argc, char **argv) @@ -295,7 +295,7 @@ int main(int argc, char **argv) gtk_init(&argc, NULL); core_init(&argc, NULL, &init_data); gui_builder_init("share/ocarina/ocarina.ui"); - gui_queue_model_init(); + gui_model_init(); while (idle_run_task()) {}; g_test_init(&argc, &argv, NULL); diff --git a/tests/gui/playlist.c b/tests/gui/playlist.c index 95aad1b5..786aaaa8 100644 --- a/tests/gui/playlist.c +++ b/tests/gui/playlist.c @@ -106,7 +106,7 @@ int main(int argc, char **argv) gtk_init(&argc, NULL); gui_builder_init("share/ocarina/ocarina.ui"); core_init(&argc, NULL, &init_data); - gui_queue_model_init(); + gui_model_init(); gui_view_init(); gui_playlist_init(); playlist_new(PL_LIBRARY, "tests/Music/Hyrule Symphony"); diff --git a/tests/gui/queue.c b/tests/gui/queue.c index bfb5292d..2146765b 100644 --- a/tests/gui/queue.c +++ b/tests/gui/queue.c @@ -19,11 +19,11 @@ static void test_queue_save(struct queue *queue, unsigned int row) {} static struct queue_ops test_ops = { .qop_init = test_queue_init, .qop_deinit = gui_queue_free, - .qop_cleared = gui_queue_model_clear, - .qop_added = gui_queue_model_add, - .qop_removed = gui_queue_model_remove, + .qop_cleared = gui_model_clear, + .qop_added = gui_model_add, + .qop_removed = gui_model_remove, .qop_save = test_queue_save, - .qop_updated = gui_queue_model_update, + .qop_updated = gui_model_update, }; struct core_init_data init_data = { @@ -126,7 +126,7 @@ int main(int argc, char **argv) gtk_init(&argc, NULL); gui_builder_init("share/ocarina/ocarina.ui"); core_init(&argc, NULL, &init_data); - gui_queue_model_init(); + gui_model_init(); gui_view_init(); gui_queue_init(); while (idle_run_task()) {}; diff --git a/tests/gui/view.c b/tests/gui/view.c index 06109364..b7d98fff 100644 --- a/tests/gui/view.c +++ b/tests/gui/view.c @@ -12,18 +12,18 @@ #include #include -const gchar *QUEUE_SETTINGS[Q_MODEL_N_COLUMNS] = { - [Q_MODEL_TRACK_NR] = "gui.queue.track", - [Q_MODEL_TITLE] = "gui.queue.title", - [Q_MODEL_LENGTH] = "gui.queue.length", - [Q_MODEL_ARTIST] = "gui.queue.artist", - [Q_MODEL_ALBUM] = "gui.queue.album", - [Q_MODEL_YEAR] = "gui.queue.year", - [Q_MODEL_GENRE] = "gui.queue.genre", - [Q_MODEL_COUNT] = "gui.queue.count", - [Q_MODEL_LAST_PLAY] = "gui.queue.played", - [Q_MODEL_FILE_PATH] = "gui.queue.filepath", - [Q_MODEL_FONT] = "gui.queue.font", +const gchar *QUEUE_SETTINGS[GUI_MODEL_N_COLUMNS] = { + [GUI_MODEL_TRACK_NR] = "gui.queue.track", + [GUI_MODEL_TITLE] = "gui.queue.title", + [GUI_MODEL_LENGTH] = "gui.queue.length", + [GUI_MODEL_ARTIST] = "gui.queue.artist", + [GUI_MODEL_ALBUM] = "gui.queue.album", + [GUI_MODEL_YEAR] = "gui.queue.year", + [GUI_MODEL_GENRE] = "gui.queue.genre", + [GUI_MODEL_COUNT] = "gui.queue.count", + [GUI_MODEL_LAST_PLAY] = "gui.queue.played", + [GUI_MODEL_FILE_PATH] = "gui.queue.filepath", + [GUI_MODEL_FONT] = "gui.queue.font", }; unsigned int load_count = 0; @@ -53,24 +53,24 @@ static void test_treeview() playlist_new(PL_LIBRARY, "tests/Music/Hyrule Symphony"); while (idle_run_task() == true) {} - gui_queue_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection")); + gui_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection")); filter = GTK_TREE_MODEL(gui_view_get_filter()); treeview = GTK_TREE_VIEW(gui_builder_widget("o_treeview")); - for (i = 0; i < Q_MODEL_N_COLUMNS; i++) + for (i = 0; i < GUI_MODEL_N_COLUMNS; i++) g_assert_false(settings_has(QUEUE_SETTINGS[i])); - for (i = 0; i < Q_MODEL_N_COLUMNS; i++) { - if (i == Q_MODEL_FILE_PATH || i == Q_MODEL_FONT) + for (i = 0; i < GUI_MODEL_N_COLUMNS; i++) { + if (i == GUI_MODEL_FILE_PATH || i == GUI_MODEL_FONT) continue; col = gtk_tree_view_get_column(treeview, i); gtk_tree_view_column_set_fixed_width(col, (i + 2) * 10); } gui_test_main_loop(); - for (i = 0; i < Q_MODEL_N_COLUMNS; i++) { - bool has = (i < Q_MODEL_LAST_PLAY); + for (i = 0; i < GUI_MODEL_N_COLUMNS; i++) { + bool has = (i < GUI_MODEL_LAST_PLAY); g_assert(settings_has(QUEUE_SETTINGS[i]) == has); /* The "Played" column gets any remaining space. */ if (has) @@ -80,11 +80,11 @@ static void test_treeview() g_assert_false(settings_has("gui.queue.filepath")); g_assert_cmpuint(settings_get("gui.queue.filepath"), ==, 0); - for (i = 0; i < Q_MODEL_LAST_PLAY; i++) + for (i = 0; i < GUI_MODEL_LAST_PLAY; i++) settings_set(QUEUE_SETTINGS[i], 42); gui_view_init(); - for (i = 0; i < Q_MODEL_LAST_PLAY; i++) { + for (i = 0; i < GUI_MODEL_LAST_PLAY; i++) { col = gtk_tree_view_get_column(treeview, i); g_assert_cmpuint(gtk_tree_view_column_get_fixed_width(col), ==, 42); } @@ -107,7 +107,7 @@ int main(int argc, char **argv) gtk_init(&argc, NULL); core_init(&argc, NULL, &init_data); gui_builder_init("share/ocarina/ocarina.ui"); - gui_queue_model_init(); + gui_model_init(); gui_view_init(); gui_test_init(); while (idle_run_task()) {};