anna
/
ocarina
1
0
Fork 0
Code Issues 7 Pull Requests Releases Wiki Activity

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 <Anna@NoWheyCreamery.com>
This commit is contained in:
Anna Schumaker 2016-08-20 10:08:36 -04:00
parent 453f176d63
commit cdbe96c575
11 changed files with 307 additions and 317 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

276
gui/model.c
View File

@ -7,61 +7,59 @@
#include <gui/builder.h> #include <gui/builder.h>
#include <gui/model.h> #include <gui/model.h>
static const GTypeInfo queue_type_info; static const GInterfaceInfo gui_tree_model;
static const GInterfaceInfo queue_tree_model; static const GTypeInfo gui_model_type_info;
static GObjectClass *parent_class = NULL; static GObjectClass *parent_class = NULL;
static GuiQueueModel *queue_model = NULL; static GuiModel *queue_model = NULL;
static gchar *font_current = "bold"; static gchar *font_current = "bold";
static gchar *font_regular = ""; static gchar *font_regular = "";
static GType queue_columns[Q_MODEL_N_COLUMNS] = { static GType gui_model_columns[GUI_MODEL_N_COLUMNS] = {
[Q_MODEL_TRACK_NR] = G_TYPE_UINT, [GUI_MODEL_TRACK_NR] = G_TYPE_UINT,
[Q_MODEL_TITLE] = G_TYPE_STRING, [GUI_MODEL_TITLE] = G_TYPE_STRING,
[Q_MODEL_LENGTH] = G_TYPE_STRING, [GUI_MODEL_LENGTH] = G_TYPE_STRING,
[Q_MODEL_ARTIST] = G_TYPE_STRING, [GUI_MODEL_ARTIST] = G_TYPE_STRING,
[Q_MODEL_ALBUM] = G_TYPE_STRING, [GUI_MODEL_ALBUM] = G_TYPE_STRING,
[Q_MODEL_YEAR] = G_TYPE_UINT, [GUI_MODEL_YEAR] = G_TYPE_UINT,
[Q_MODEL_GENRE] = G_TYPE_STRING, [GUI_MODEL_GENRE] = G_TYPE_STRING,
[Q_MODEL_COUNT] = G_TYPE_UINT, [GUI_MODEL_COUNT] = G_TYPE_UINT,
[Q_MODEL_LAST_PLAY] = G_TYPE_STRING, [GUI_MODEL_LAST_PLAY] = G_TYPE_STRING,
[Q_MODEL_FILE_PATH] = G_TYPE_STRING, [GUI_MODEL_FILE_PATH] = G_TYPE_STRING,
[Q_MODEL_FONT] = G_TYPE_STRING, [GUI_MODEL_FONT] = G_TYPE_STRING,
}; };
static gboolean __queue_model_iter_nth(GuiQueueModel *model, static gboolean __gui_model_iter_nth(GuiModel *model, GtkTreeIter *iter, gint n)
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; return FALSE;
queue_iter_set(model->gqm_queue, &model->gqm_iter, n); queue_iter_set(model->gm_queue, &model->gm_iter, n);
iter->stamp = model->gqm_stamp; iter->stamp = model->gm_stamp;
iter->user_data = &model->gqm_iter; iter->user_data = &model->gm_iter;
iter->user_data2 = queue_iter_val(&model->gqm_iter); iter->user_data2 = queue_iter_val(&model->gm_iter);
return TRUE; return TRUE;
} }
static GtkTreeModelFlags _queue_model_get_flags(GtkTreeModel *model) static GtkTreeModelFlags __gui_model_get_flags(GtkTreeModel *model)
{ {
return GTK_TREE_MODEL_LIST_ONLY; 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); G_TYPE_INVALID);
return queue_columns[index]; return gui_model_columns[index];
} }
static gboolean _queue_model_get_iter(GtkTreeModel *model, GtkTreeIter *iter, static gboolean __gui_model_get_iter(GtkTreeModel *model, GtkTreeIter *iter,
GtkTreePath *path) GtkTreePath *path)
{ {
gint *indices, depth; 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); indices = gtk_tree_path_get_indices_with_depth(path, &depth);
g_assert(depth == 1); 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; struct queue_iter *q_it;
GtkTreePath *path; GtkTreePath *path;
@ -87,233 +85,229 @@ static GtkTreePath *_queue_model_get_path(GtkTreeModel *model, GtkTreeIter *iter
return path; return path;
} }
static void _queue_model_get_value(GtkTreeModel *model, GtkTreeIter *iter, static void __gui_model_get_value(GtkTreeModel *model, GtkTreeIter *iter,
gint column, GValue *value) gint column, GValue *value)
{ {
struct track *track = iter->user_data2; struct track *track = iter->user_data2;
gchar *str; gchar *str;
g_return_if_fail(iter != NULL); g_return_if_fail(iter != NULL);
g_return_if_fail(iter->user_data2 != 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) { switch (column) {
case Q_MODEL_TRACK_NR: case GUI_MODEL_TRACK_NR:
g_value_set_uint(value, track->tr_track); g_value_set_uint(value, track->tr_track);
break; break;
case Q_MODEL_TITLE: case GUI_MODEL_TITLE:
g_value_set_static_string(value, track->tr_title); g_value_set_static_string(value, track->tr_title);
break; break;
case Q_MODEL_LENGTH: case GUI_MODEL_LENGTH:
g_value_take_string(value, string_sec2str(track->tr_length)); g_value_take_string(value, string_sec2str(track->tr_length));
break; break;
case Q_MODEL_ARTIST: case GUI_MODEL_ARTIST:
g_value_set_static_string(value, track->tr_album->al_artist->ar_name); g_value_set_static_string(value, track->tr_album->al_artist->ar_name);
break; break;
case Q_MODEL_ALBUM: case GUI_MODEL_ALBUM:
g_value_set_static_string(value, track->tr_album->al_name); g_value_set_static_string(value, track->tr_album->al_name);
break; break;
case Q_MODEL_YEAR: case GUI_MODEL_YEAR:
g_value_set_uint(value, track->tr_album->al_year); g_value_set_uint(value, track->tr_album->al_year);
break; break;
case Q_MODEL_GENRE: case GUI_MODEL_GENRE:
g_value_set_static_string(value, track->tr_album->al_genre->ge_name); g_value_set_static_string(value, track->tr_album->al_genre->ge_name);
break; break;
case Q_MODEL_COUNT: case GUI_MODEL_COUNT:
g_value_set_uint(value, track->tr_count); g_value_set_uint(value, track->tr_count);
break; break;
case Q_MODEL_LAST_PLAY: case GUI_MODEL_LAST_PLAY:
g_value_take_string(value, track_last_play(track)); g_value_take_string(value, track_last_play(track));
break; break;
case Q_MODEL_FILE_PATH: case GUI_MODEL_FILE_PATH:
str = track_path(track); str = track_path(track);
g_value_take_string(value, g_markup_escape_text(str, -1)); g_value_take_string(value, g_markup_escape_text(str, -1));
g_free(str); g_free(str);
break; break;
case Q_MODEL_FONT: case GUI_MODEL_FONT:
str = (track == audio_cur_track()) ? font_current : font_regular; str = (track == audio_cur_track()) ? font_current : font_regular;
g_value_set_static_string(value, str); g_value_set_static_string(value, str);
break; 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 != NULL, FALSE);
g_return_val_if_fail(iter->user_data, FALSE); g_return_val_if_fail(iter->user_data, FALSE);
g_return_val_if_fail(iter->user_data2, FALSE); g_return_val_if_fail(iter->user_data2, FALSE);
queue_iter_next(&gqm->gqm_iter); queue_iter_next(&gqm->gm_iter);
if (gqm->gqm_iter.it_iter == NULL) if (gqm->gm_iter.it_iter == NULL)
return FALSE; return FALSE;
iter->stamp = gqm->gqm_stamp; iter->stamp = gqm->gm_stamp;
iter->user_data = &gqm->gqm_iter; iter->user_data = &gqm->gm_iter;
iter->user_data2 = queue_iter_val(&gqm->gqm_iter); iter->user_data2 = queue_iter_val(&gqm->gm_iter);
return TRUE; return TRUE;
} }
static gboolean _queue_model_iter_children(GtkTreeModel *model, static gboolean __gui_model_iter_children(GtkTreeModel *model, GtkTreeIter *iter,
GtkTreeIter *iter, GtkTreeIter *parent)
GtkTreeIter *parent)
{ {
if (parent) if (parent)
return FALSE; 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, static gboolean __gui_model_iter_has_child(GtkTreeModel *model, GtkTreeIter *iter)
GtkTreeIter *iter)
{ {
return FALSE; return FALSE;
} }
static gint _queue_model_iter_n_children(GtkTreeModel *model, static gint __gui_model_iter_n_children(GtkTreeModel *model, GtkTreeIter *iter)
GtkTreeIter *iter)
{ {
if (iter != NULL || !queue_model->gqm_queue) if (iter != NULL || !queue_model->gm_queue)
return 0; 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, static gboolean __gui_model_iter_nth_child(GtkTreeModel *model,
GtkTreeIter *iter, GtkTreeIter *iter,
GtkTreeIter *parent, GtkTreeIter *parent,
gint n) gint n)
{ {
if (parent) if (parent)
return FALSE; 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, static gboolean __gui_model_iter_parent(GtkTreeModel *model, GtkTreeIter *iter,
GtkTreeIter *iter, GtkTreeIter *child)
GtkTreeIter *child)
{ {
return FALSE; 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); parent_class->finalize(object);
} }
static void _queue_model_class_init(GuiQueueModelClass *class) static void __gui_model_class_init(GuiModelClass *class)
{ {
GObjectClass *object_class; GObjectClass *object_class;
parent_class = g_type_class_peek_parent(class); parent_class = g_type_class_peek_parent(class);
object_class = (GObjectClass *)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_flags = __gui_model_get_flags;
iface->get_n_columns = _queue_model_get_n_columns; iface->get_n_columns = __gui_model_get_n_columns;
iface->get_column_type = _queue_model_get_column_type; iface->get_column_type = __gui_model_get_column_type;
iface->get_iter = _queue_model_get_iter; iface->get_iter = __gui_model_get_iter;
iface->get_path = _queue_model_get_path; iface->get_path = __gui_model_get_path;
iface->get_value = _queue_model_get_value; iface->get_value = __gui_model_get_value;
iface->iter_next = _queue_model_iter_next; iface->iter_next = __gui_model_iter_next;
iface->iter_children = _queue_model_iter_children; iface->iter_children = __gui_model_iter_children;
iface->iter_has_child = _queue_model_iter_has_child; iface->iter_has_child = __gui_model_iter_has_child;
iface->iter_n_children = _queue_model_iter_n_children; iface->iter_n_children = __gui_model_iter_n_children;
iface->iter_nth_child = _queue_model_iter_nth_child; iface->iter_nth_child = __gui_model_iter_nth_child;
iface->iter_parent = _queue_model_iter_parent; 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; gchar *len = NULL;
if (queue_model->gqm_queue) if (queue_model->gm_queue)
len = string_sec2str_long(queue_model->gqm_queue->q_length); len = string_sec2str_long(queue_model->gm_queue->q_length);
gtk_label_set_text(GTK_LABEL(gui_builder_widget("o_runtime")), len); gtk_label_set_text(GTK_LABEL(gui_builder_widget("o_runtime")), len);
g_free(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); 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); g_object_unref(queue_model);
queue_model = NULL; queue_model = NULL;
} }
GuiQueueModel *gui_queue_model_get(void) GuiModel *gui_model_get(void)
{ {
return queue_model; 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) { if (gui_model_type == 0) {
queue_type = g_type_register_static(G_TYPE_OBJECT, gui_model_type = g_type_register_static(G_TYPE_OBJECT,
"GuiQueueModel", "GuiModel",
&queue_type_info, &gui_model_type_info,
(GTypeFlags)0); (GTypeFlags)0);
g_type_add_interface_static(queue_type, g_type_add_interface_static(gui_model_type,
GTK_TYPE_TREE_MODEL, 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; GtkTreePath *path;
GtkTreeIter iter; GtkTreeIter iter;
if (!queue_model || queue != queue_model->gqm_queue) if (!queue_model || queue != queue_model->gm_queue)
return; return;
path = gtk_tree_path_new_from_indices(row, -1); 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); 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); 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; GtkTreePath *path;
if (queue != queue_model->gqm_queue) if (queue != queue_model->gm_queue)
return; return;
path = gtk_tree_path_new_from_indices(row, -1); path = gtk_tree_path_new_from_indices(row, -1);
gtk_tree_model_row_deleted(GTK_TREE_MODEL(queue_model), path); 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); 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; GtkTreePath *path;
unsigned int i; unsigned int i;
if (queue != queue_model->gqm_queue) if (queue != queue_model->gm_queue)
return; return;
path = gtk_tree_path_new_from_indices(n - 1, -1); 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); gtk_tree_path_prev(path);
} }
__gui_queue_model_set_runtime(); __gui_model_set_runtime();
gtk_tree_path_free(path); 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; GtkTreePath *path;
GtkTreeIter iter; GtkTreeIter iter;
if (queue != queue_model->gqm_queue) if (queue != queue_model->gm_queue)
return; return;
path = gtk_tree_path_new_from_indices(row, -1); 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); 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); 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) if (cur)
gui_queue_model_clear(cur, queue_size(cur)); gui_model_clear(cur, queue_size(cur));
queue_model->gqm_queue = queue; queue_model->gm_queue = queue;
__gui_queue_model_set_runtime(); __gui_model_set_runtime();
if (queue && queue_size(queue) > 0) 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; GtkTreeIter iter;
_queue_model_get_iter(GTK_TREE_MODEL(queue_model), &iter, path); __gui_model_get_iter(GTK_TREE_MODEL(queue_model), &iter, path);
return gui_queue_model_iter_get_track(&iter); return gui_model_iter_get_track(&iter);
} }
static const GTypeInfo queue_type_info = { static const GTypeInfo gui_model_type_info = {
.class_size = sizeof(GuiQueueModelClass), .class_size = sizeof(GuiModelClass),
.base_init = NULL, .base_init = NULL,
.base_finalize = NULL, .base_finalize = NULL,
.class_init = (GClassInitFunc)_queue_model_class_init, .class_init = (GClassInitFunc)__gui_model_class_init,
.class_finalize = NULL, .class_finalize = NULL,
.class_data = NULL, .class_data = NULL,
.instance_size = sizeof(GuiQueueModel), .instance_size = sizeof(GuiModel),
.n_preallocs = 0, .n_preallocs = 0,
.instance_init = (GInstanceInitFunc)_queue_model_init, .instance_init = (GInstanceInitFunc)__gui_model_init,
}; };
static const GInterfaceInfo queue_tree_model = { static const GInterfaceInfo gui_tree_model = {
.interface_init = (GInterfaceInitFunc)_queue_tree_model_init, .interface_init = (GInterfaceInitFunc)__gui_tree_model_init,
.interface_finalize = NULL, .interface_finalize = NULL,
.interface_data = NULL, .interface_data = NULL,
}; };

4
gui/ocarina.c
View File

@ -102,7 +102,7 @@ static void __ocarina_startup(GApplication *application, gpointer data)
gui_builder_init(ui); gui_builder_init(ui);
core_init(&startup_argc, &startup_argv, &init_data); core_init(&startup_argc, &startup_argv, &init_data);
gui_window_init(icon); gui_window_init(icon);
gui_queue_model_init(); gui_model_init();
gui_view_init(); gui_view_init();
gui_queue_init(); gui_queue_init();
gui_sidebar_init(); gui_sidebar_init();
@ -121,7 +121,7 @@ static void __ocarina_shutdown(GApplication *application, gpointer data)
gui_idle_disable(); gui_idle_disable();
core_deinit(); core_deinit();
gui_queue_model_deinit(); gui_model_deinit();
gui_window_deinit(); gui_window_deinit();
gui_builder_deinit(); gui_builder_deinit();
} }

8
gui/playlist.c
View File

@ -259,19 +259,19 @@ static void *__playlist_init(struct queue *queue, void *data)
static void __playlist_added(struct queue *queue, unsigned int row) 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); __playlist_update_sizes(queue);
} }
static void __playlist_removed(struct queue *queue, unsigned int row) 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); __playlist_update_sizes(queue);
} }
static void __playlist_cleared(struct queue *queue, unsigned int n) 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); __playlist_update_sizes(queue);
} }
@ -481,5 +481,5 @@ struct queue_ops playlist_ops = {
.qop_erase = __playlist_erase, .qop_erase = __playlist_erase,
.qop_removed = __playlist_removed, .qop_removed = __playlist_removed,
.qop_cleared = __playlist_cleared, .qop_cleared = __playlist_cleared,
.qop_updated = gui_queue_model_update, .qop_updated = gui_model_update,
}; };

2
gui/queue.c
View File

@ -54,7 +54,7 @@ static gboolean __queue_visible_func(GtkTreeModel *model, GtkTreeIter *iter,
if (!gq_queue || !gq_queue->gq_search) if (!gq_queue || !gq_queue->gq_search)
return TRUE; 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++) { for (i = 0; gq_queue->gq_search[i]; i++) {
token = gq_queue->gq_search[i]; token = gq_queue->gq_search[i];

67
gui/view.c
View File

@ -12,30 +12,27 @@
#include <glib/gi18n.h> #include <glib/gi18n.h>
#include <stdlib.h> #include <stdlib.h>
static const gchar *QUEUE_SETTINGS[Q_MODEL_N_COLUMNS] = { static const gchar *QUEUE_SETTINGS[GUI_MODEL_N_COLUMNS] = {
[Q_MODEL_TRACK_NR] = "gui.queue.track", [GUI_MODEL_TRACK_NR] = "gui.queue.track",
[Q_MODEL_TITLE] = "gui.queue.title", [GUI_MODEL_TITLE] = "gui.queue.title",
[Q_MODEL_LENGTH] = "gui.queue.length", [GUI_MODEL_LENGTH] = "gui.queue.length",
[Q_MODEL_ARTIST] = "gui.queue.artist", [GUI_MODEL_ARTIST] = "gui.queue.artist",
[Q_MODEL_ALBUM] = "gui.queue.album", [GUI_MODEL_ALBUM] = "gui.queue.album",
[Q_MODEL_YEAR] = "gui.queue.year", [GUI_MODEL_YEAR] = "gui.queue.year",
[Q_MODEL_GENRE] = "gui.queue.genre", [GUI_MODEL_GENRE] = "gui.queue.genre",
[Q_MODEL_COUNT] = "gui.queue.count", [GUI_MODEL_COUNT] = "gui.queue.count",
[Q_MODEL_LAST_PLAY] = NULL,
[Q_MODEL_FILE_PATH] = NULL,
[Q_MODEL_FONT] = NULL,
}; };
static const enum compare_t QUEUE_SORT[Q_MODEL_N_COLUMNS] = { static const enum compare_t QUEUE_SORT[GUI_MODEL_N_COLUMNS] = {
[Q_MODEL_TRACK_NR] = COMPARE_TRACK, [GUI_MODEL_TRACK_NR] = COMPARE_TRACK,
[Q_MODEL_TITLE] = COMPARE_TITLE, [GUI_MODEL_TITLE] = COMPARE_TITLE,
[Q_MODEL_LENGTH] = COMPARE_LENGTH, [GUI_MODEL_LENGTH] = COMPARE_LENGTH,
[Q_MODEL_ARTIST] = COMPARE_ARTIST, [GUI_MODEL_ARTIST] = COMPARE_ARTIST,
[Q_MODEL_ALBUM] = COMPARE_ALBUM, [GUI_MODEL_ALBUM] = COMPARE_ALBUM,
[Q_MODEL_YEAR] = COMPARE_YEAR, [GUI_MODEL_YEAR] = COMPARE_YEAR,
[Q_MODEL_GENRE] = COMPARE_GENRE, [GUI_MODEL_GENRE] = COMPARE_GENRE,
[Q_MODEL_COUNT] = COMPARE_COUNT, [GUI_MODEL_COUNT] = COMPARE_COUNT,
[Q_MODEL_LAST_PLAY] = COMPARE_PLAYED, [GUI_MODEL_LAST_PLAY] = COMPARE_PLAYED,
}; };
static GtkTreeView *view_treeview = NULL; 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) static struct track *__view_filter_get_track(GtkTreePath *orig)
{ {
GtkTreePath *real = __view_filter_convert_path(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); gtk_tree_path_free(real);
return track; return track;
@ -71,14 +68,14 @@ static unsigned int __view_get_column_index(GtkTreeViewColumn *col)
unsigned int i; unsigned int i;
if (!view_treeview) 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)) if (col == gtk_tree_view_get_column(view_treeview, i))
return i; return i;
} }
return Q_MODEL_N_COLUMNS; return GUI_MODEL_N_COLUMNS;
} }
static inline void __view_display_sorting(gchar *text) 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, static void __view_set_column_sort_indicator(GtkTreeViewColumn *col,
unsigned int index) 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; GSList *cur = queue ? queue->q_sort : NULL;
unsigned int order = GTK_SORT_ASCENDING; unsigned int order = GTK_SORT_ASCENDING;
bool show = false; bool show = false;
@ -126,7 +123,7 @@ static void __view_set_sort_indicators()
{ {
GtkTreeViewColumn *col; 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); col = gtk_tree_view_get_column(view_treeview, i);
if (col) if (col)
__view_set_column_sort_indicator(col, i); __view_set_column_sort_indicator(col, i);
@ -138,7 +135,7 @@ void __view_row_activated(GtkTreeView *treeview, GtkTreePath *path,
{ {
view_no_scroll = true; view_no_scroll = true;
audio_load(__view_filter_get_track(path)); 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]); gtk_tree_path_get_indices(path)[0]);
view_no_scroll = false; view_no_scroll = false;
} }
@ -153,7 +150,7 @@ void __view_column_resized(GtkTreeViewColumn *col, GParamSpec *pspec,
void __view_column_clicked(GtkTreeViewColumn *col, gpointer data) 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); unsigned int index = __view_get_column_index(col);
bool reset = view_sort_count == 0; bool reset = view_sort_count == 0;
gchar *text; gchar *text;
@ -193,7 +190,7 @@ static void __view_add_to_playlist(GtkTreeModel *model, GtkTreePath *path,
static void __view_delete_selection(GtkTreeSelection *selection) 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 *rows = gtk_tree_selection_get_selected_rows(selection, NULL);
GList *cur = g_list_reverse(rows); 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_treeview = GTK_TREE_VIEW(gui_builder_widget("o_treeview"));
view_filter = GTK_TREE_MODEL_FILTER(gtk_tree_model_filter_new( 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); col = gtk_tree_view_get_column(view_treeview, i);
pos = settings_get(QUEUE_SETTINGS[i]); pos = settings_get(QUEUE_SETTINGS[i]);
if (col && pos > 0) if (col && pos > 0)
@ -427,7 +424,7 @@ GtkTreeModelFilter *gui_view_get_filter(void)
void gui_view_set_queue(struct queue *queue) void gui_view_set_queue(struct queue *queue)
{ {
gui_queue_model_set_queue(queue); gui_model_set_queue(queue);
view_sort_count = 0; view_sort_count = 0;
__view_display_sorting(""); __view_display_sorting("");
@ -438,7 +435,7 @@ void gui_view_set_queue(struct queue *queue)
void gui_view_scroll() void gui_view_scroll()
{ {
struct queue *queue = gui_queue_model_get_queue(); struct queue *queue = gui_model_get_queue();
GtkTreePath *real, *path; GtkTreePath *real, *path;
if (!queue || (int)queue->q_cur.it_pos < 0 || view_no_scroll) if (!queue || (int)queue->q_cur.it_pos < 0 || view_no_scroll)

83
include/gui/model.h
View File

@ -6,76 +6,75 @@
#include <core/queue.h> #include <core/queue.h>
#include <gtk/gtk.h> #include <gtk/gtk.h>
#define GUI_QUEUE_MODEL_TYPE (gui_queue_model_get_type()) #define GUI_MODEL_TYPE (gui_model_get_type())
#define GUI_QUEUE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), \ #define GUI_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), \
GUI_QUEUE_MODEL_TYPE, GuiQueueModel)) GUI_MODEL_TYPE, GuiModel))
enum queue_model_columns { enum gui_model_columns {
Q_MODEL_TRACK_NR, GUI_MODEL_TRACK_NR,
Q_MODEL_TITLE, GUI_MODEL_TITLE,
Q_MODEL_LENGTH, GUI_MODEL_LENGTH,
Q_MODEL_ARTIST, GUI_MODEL_ARTIST,
Q_MODEL_ALBUM, GUI_MODEL_ALBUM,
Q_MODEL_YEAR, GUI_MODEL_YEAR,
Q_MODEL_GENRE, GUI_MODEL_GENRE,
Q_MODEL_COUNT, GUI_MODEL_COUNT,
Q_MODEL_LAST_PLAY, GUI_MODEL_LAST_PLAY,
Q_MODEL_FILE_PATH, GUI_MODEL_FILE_PATH,
Q_MODEL_FONT, GUI_MODEL_FONT,
Q_MODEL_N_COLUMNS, GUI_MODEL_N_COLUMNS,
}; };
typedef struct _gui_queue_model GuiQueueModel; struct gui_model {
typedef struct _gui_queue_model_class GuiQueueModelClass; GObject gm_parent; /* This MUST be the first member. */
gint gm_stamp; /* This is used to check iter validity. */
struct _gui_queue_model { struct queue *gm_queue; /* The model's associated queue. */
GObject gqm_parent; /* This MUST be the first member. */ struct queue_iter gm_iter; /* The current _q_iter. */
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. */
}; };
typedef struct gui_model GuiModel;
struct _gui_queue_model_class {
struct gui_model_class {
GObjectClass parent_class; GObjectClass parent_class;
}; };
typedef struct gui_model_class GuiModelClass;
/* Called to initialize the GuiQueueModel */ /* Called to initialize the GuiModel */
void gui_queue_model_init(void); void gui_model_init(void);
/* Called to deinitialize the GuiQueueModel */ /* Called to deinitialize the GuiModel */
void gui_queue_model_deinit(void); void gui_model_deinit(void);
/* Called to get the GuiQueueModel */ /* Called to get the GuiModel */
GuiQueueModel *gui_queue_model_get(void); GuiModel *gui_model_get(void);
/* Called to find the GType of the GuiQueueModel */ /* Called to find the GType of the GuiModel */
GType gui_queue_model_get_type(); GType gui_model_get_type();
/* Called to add a row to the model */ /* 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 */ /* 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 */ /* 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 */ /* 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. */ /* 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. */ /* 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 */ /* Called to convert a GtkTreeIter into a struct track */
static inline static inline struct track *gui_model_iter_get_track(GtkTreeIter *iter)
struct track *gui_queue_model_iter_get_track(GtkTreeIter *iter)
{ {
g_return_val_if_fail(iter != NULL, NULL); g_return_val_if_fail(iter != NULL, NULL);
g_return_val_if_fail(iter->user_data2 != 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 */ /* 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 */ #endif /* OCARINA_GUI_MODEL_H */

4
tests/gui/audio.c
View File

@ -134,7 +134,7 @@ int main(int argc, char **argv)
gtk_init(&argc, NULL); gtk_init(&argc, NULL);
gui_builder_init("share/ocarina/ocarina.ui"); gui_builder_init("share/ocarina/ocarina.ui");
gui_queue_model_init(); gui_model_init();
core_init(&argc, NULL, &init_data); core_init(&argc, NULL, &init_data);
playlist_new(PL_LIBRARY, "tests/Music/Hyrule Symphony"); playlist_new(PL_LIBRARY, "tests/Music/Hyrule Symphony");
while (idle_run_task()) {}; while (idle_run_task()) {};
@ -144,7 +144,7 @@ int main(int argc, char **argv)
ret = g_test_run(); ret = g_test_run();
gui_window_deinit(); gui_window_deinit();
gui_queue_model_deinit(); gui_model_deinit();
gui_builder_deinit(); gui_builder_deinit();
core_deinit(); core_deinit();
return ret; return ret;

126
tests/gui/model.c
View File

@ -35,11 +35,11 @@ void test_on_config_pause(int count) {}
struct queue_ops test_ops = { struct queue_ops test_ops = {
.qop_init = test_queue_init, .qop_init = test_queue_init,
.qop_deinit = test_queue_deinit, .qop_deinit = test_queue_deinit,
.qop_added = gui_queue_model_add, .qop_added = gui_model_add,
.qop_removed = gui_queue_model_remove, .qop_removed = gui_model_remove,
.qop_cleared = gui_queue_model_clear, .qop_cleared = gui_model_clear,
.qop_save = test_queue_save, .qop_save = test_queue_save,
.qop_updated = gui_queue_model_update, .qop_updated = gui_model_update,
}; };
struct audio_ops test_audio_ops = { struct audio_ops test_audio_ops = {
@ -56,45 +56,45 @@ struct core_init_data init_data = {
static void test_init() static void test_init()
{ {
GtkTreeModel *treemodel; GtkTreeModel *treemodel;
GuiQueueModel *model; GuiModel *model;
GType type; GType type;
gui_queue_model_init(); gui_model_init();
model = gui_queue_model_get(); model = gui_model_get();
g_assert_null(gui_queue_model_get_queue()); g_assert_null(gui_model_get_queue());
gui_queue_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection")); gui_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection"));
g_assert_nonnull(model); g_assert_nonnull(model);
g_assert_true(GTK_IS_TREE_MODEL(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); 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_flags(treemodel), ==, GTK_TREE_MODEL_LIST_ONLY);
g_assert_cmpuint(gtk_tree_model_get_n_columns(treemodel), ==, 11); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); g_assert_cmpuint(type, ==, G_TYPE_STRING);
gui_queue_model_deinit(); gui_model_deinit();
g_assert_false(G_IS_OBJECT(model)); g_assert_false(G_IS_OBJECT(model));
} }
@ -105,40 +105,40 @@ static void __test_empty_subprocess()
GValue value; GValue value;
GType type; GType type;
gui_queue_model_init(); gui_model_init();
model = GTK_TREE_MODEL(gui_queue_model_get()); model = GTK_TREE_MODEL(gui_model_get());
gui_queue_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection")); gui_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection"));
memset(&value, 0, sizeof(GValue)); memset(&value, 0, sizeof(GValue));
g_assert_false(gtk_tree_model_get_iter_first(model, &iter)); g_assert_false(gtk_tree_model_get_iter_first(model, &iter));
g_assert_null(gtk_tree_model_get_path(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 */ /* 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)); 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)); 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)); 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)); 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)); 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)); 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)); 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)); 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)); 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)); 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)); 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_cmpuint(type, ==, G_TYPE_INVALID);
g_assert_false(gtk_tree_model_iter_next(model, &iter)); 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_nth_child(model, &iter, NULL, 3));
g_assert_false(gtk_tree_model_iter_parent(model, &iter, &iter)); g_assert_false(gtk_tree_model_iter_parent(model, &iter, &iter));
gui_queue_model_deinit(); gui_model_deinit();
} }
static void test_empty() static void test_empty()
@ -173,9 +173,9 @@ static void test_model()
GtkLabel *label; GtkLabel *label;
GValue value; 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")); 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), ==, ""); g_assert_cmpstr(gtk_label_get_text(label), ==, "");
memset(&value, 0, sizeof(GValue)); memset(&value, 0, sizeof(GValue));
@ -199,85 +199,85 @@ static void test_model()
/* ... and test again */ /* ... and test again */
g_assert_true(gtk_tree_model_get_iter_first(model, &iter)); 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); g_assert_cmpuint(track->tr_track, ==, 1);
audio_load(track); audio_load(track);
path = gtk_tree_model_get_path(model, &iter); path = gtk_tree_model_get_path(model, &iter);
g_assert_nonnull(path); g_assert_nonnull(path);
g_assert_cmpuint(gtk_tree_path_get_indices(path)[0], ==, 0); 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_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_assert_cmpuint(g_value_get_uint(&value), ==, track->tr_track);
g_value_unset(&value); 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_assert_cmpstr(g_value_get_string(&value), ==, "Title Theme");
g_value_unset(&value); 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_assert_cmpstr(g_value_get_string(&value), ==, "4:03");
g_value_unset(&value); 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_assert_cmpstr(g_value_get_string(&value), ==, "Koji Kondo");
g_value_unset(&value); 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_assert_cmpstr(g_value_get_string(&value), ==, "Hyrule Symphony");
g_value_unset(&value); 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_assert_cmpuint(g_value_get_uint(&value), ==, 1998);
g_value_unset(&value); 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_assert_cmpstr(g_value_get_string(&value), ==, "Game");
g_value_unset(&value); 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_assert_cmpuint(g_value_get_uint(&value), ==, 0);
g_value_unset(&value); 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_assert_cmpstr(g_value_get_string(&value), ==, "Never");
g_value_unset(&value); 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), ==, g_assert_cmpstr(g_value_get_string(&value), ==,
"tests/Music/Hyrule Symphony/01 - Title Theme.ogg"); "tests/Music/Hyrule Symphony/01 - Title Theme.ogg");
g_value_unset(&value); 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_assert_cmpstr(g_value_get_string(&value), ==, "bold");
g_value_unset(&value); g_value_unset(&value);
g_assert_true(gtk_tree_model_iter_next(model, &iter)); 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); 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_assert_cmpstr(g_value_get_string(&value), ==, "");
g_value_unset(&value); g_value_unset(&value);
g_assert_true(gtk_tree_model_iter_children(model, &iter, NULL)); 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_cmpuint(track->tr_track, ==, 1);
g_assert_false(gtk_tree_model_iter_has_child(model, &iter)); 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, &iter), ==, 0);
g_assert_cmpuint(gtk_tree_model_iter_n_children(model, NULL), ==, 13); 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_delete, ==, 13);
g_assert_cmpuint(count_insert, ==, 14); g_assert_cmpuint(count_insert, ==, 14);
g_assert_cmpuint(gtk_tree_model_iter_n_children(model, NULL), ==, 3); g_assert_cmpuint(gtk_tree_model_iter_n_children(model, NULL), ==, 3);
g_assert_cmpstr(gtk_label_get_text(label), ==, "10 minutes, 46 seconds"); 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_delete, ==, 16);
g_assert_cmpuint(count_insert, ==, 14); g_assert_cmpuint(count_insert, ==, 14);
g_assert_cmpuint(gtk_tree_model_iter_n_children(model, NULL), ==, 0); g_assert_cmpuint(gtk_tree_model_iter_n_children(model, NULL), ==, 0);
g_assert_cmpstr(gtk_label_get_text(label), ==, ""); 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_delete, ==, 16);
g_assert_cmpuint(count_insert, ==, 15); g_assert_cmpuint(count_insert, ==, 15);
g_assert_cmpstr(gtk_label_get_text(label), ==, "42 minutes, 45 seconds"); 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)); 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_cmpuint(track->tr_track, ==, 4);
g_assert_false(gtk_tree_model_iter_parent(model, &iter, &iter)); 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); g_assert_cmpuint(count_delete, ==, 29);
core_deinit(); core_deinit();
gui_queue_model_deinit(); gui_model_deinit();
} }
int main(int argc, char **argv) int main(int argc, char **argv)
@ -295,7 +295,7 @@ int main(int argc, char **argv)
gtk_init(&argc, NULL); gtk_init(&argc, NULL);
core_init(&argc, NULL, &init_data); core_init(&argc, NULL, &init_data);
gui_builder_init("share/ocarina/ocarina.ui"); gui_builder_init("share/ocarina/ocarina.ui");
gui_queue_model_init(); gui_model_init();
while (idle_run_task()) {}; while (idle_run_task()) {};
g_test_init(&argc, &argv, NULL); g_test_init(&argc, &argv, NULL);

2
tests/gui/playlist.c
View File

@ -106,7 +106,7 @@ int main(int argc, char **argv)
gtk_init(&argc, NULL); gtk_init(&argc, NULL);
gui_builder_init("share/ocarina/ocarina.ui"); gui_builder_init("share/ocarina/ocarina.ui");
core_init(&argc, NULL, &init_data); core_init(&argc, NULL, &init_data);
gui_queue_model_init(); gui_model_init();
gui_view_init(); gui_view_init();
gui_playlist_init(); gui_playlist_init();
playlist_new(PL_LIBRARY, "tests/Music/Hyrule Symphony"); playlist_new(PL_LIBRARY, "tests/Music/Hyrule Symphony");

10
tests/gui/queue.c
View File

@ -19,11 +19,11 @@ static void test_queue_save(struct queue *queue, unsigned int row) {}
static struct queue_ops test_ops = { static struct queue_ops test_ops = {
.qop_init = test_queue_init, .qop_init = test_queue_init,
.qop_deinit = gui_queue_free, .qop_deinit = gui_queue_free,
.qop_cleared = gui_queue_model_clear, .qop_cleared = gui_model_clear,
.qop_added = gui_queue_model_add, .qop_added = gui_model_add,
.qop_removed = gui_queue_model_remove, .qop_removed = gui_model_remove,
.qop_save = test_queue_save, .qop_save = test_queue_save,
.qop_updated = gui_queue_model_update, .qop_updated = gui_model_update,
}; };
struct core_init_data init_data = { struct core_init_data init_data = {
@ -126,7 +126,7 @@ int main(int argc, char **argv)
gtk_init(&argc, NULL); gtk_init(&argc, NULL);
gui_builder_init("share/ocarina/ocarina.ui"); gui_builder_init("share/ocarina/ocarina.ui");
core_init(&argc, NULL, &init_data); core_init(&argc, NULL, &init_data);
gui_queue_model_init(); gui_model_init();
gui_view_init(); gui_view_init();
gui_queue_init(); gui_queue_init();
while (idle_run_task()) {}; while (idle_run_task()) {};

42
tests/gui/view.c
View File

@ -12,18 +12,18 @@
#include <tests/test.h> #include <tests/test.h>
#include <tests/gui.h> #include <tests/gui.h>
const gchar *QUEUE_SETTINGS[Q_MODEL_N_COLUMNS] = { const gchar *QUEUE_SETTINGS[GUI_MODEL_N_COLUMNS] = {
[Q_MODEL_TRACK_NR] = "gui.queue.track", [GUI_MODEL_TRACK_NR] = "gui.queue.track",
[Q_MODEL_TITLE] = "gui.queue.title", [GUI_MODEL_TITLE] = "gui.queue.title",
[Q_MODEL_LENGTH] = "gui.queue.length", [GUI_MODEL_LENGTH] = "gui.queue.length",
[Q_MODEL_ARTIST] = "gui.queue.artist", [GUI_MODEL_ARTIST] = "gui.queue.artist",
[Q_MODEL_ALBUM] = "gui.queue.album", [GUI_MODEL_ALBUM] = "gui.queue.album",
[Q_MODEL_YEAR] = "gui.queue.year", [GUI_MODEL_YEAR] = "gui.queue.year",
[Q_MODEL_GENRE] = "gui.queue.genre", [GUI_MODEL_GENRE] = "gui.queue.genre",
[Q_MODEL_COUNT] = "gui.queue.count", [GUI_MODEL_COUNT] = "gui.queue.count",
[Q_MODEL_LAST_PLAY] = "gui.queue.played", [GUI_MODEL_LAST_PLAY] = "gui.queue.played",
[Q_MODEL_FILE_PATH] = "gui.queue.filepath", [GUI_MODEL_FILE_PATH] = "gui.queue.filepath",
[Q_MODEL_FONT] = "gui.queue.font", [GUI_MODEL_FONT] = "gui.queue.font",
}; };
unsigned int load_count = 0; unsigned int load_count = 0;
@ -53,24 +53,24 @@ static void test_treeview()
playlist_new(PL_LIBRARY, "tests/Music/Hyrule Symphony"); playlist_new(PL_LIBRARY, "tests/Music/Hyrule Symphony");
while (idle_run_task() == true) {} 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()); filter = GTK_TREE_MODEL(gui_view_get_filter());
treeview = GTK_TREE_VIEW(gui_builder_widget("o_treeview")); 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])); g_assert_false(settings_has(QUEUE_SETTINGS[i]));
for (i = 0; i < Q_MODEL_N_COLUMNS; i++) { for (i = 0; i < GUI_MODEL_N_COLUMNS; i++) {
if (i == Q_MODEL_FILE_PATH || i == Q_MODEL_FONT) if (i == GUI_MODEL_FILE_PATH || i == GUI_MODEL_FONT)
continue; continue;
col = gtk_tree_view_get_column(treeview, i); col = gtk_tree_view_get_column(treeview, i);
gtk_tree_view_column_set_fixed_width(col, (i + 2) * 10); gtk_tree_view_column_set_fixed_width(col, (i + 2) * 10);
} }
gui_test_main_loop(); gui_test_main_loop();
for (i = 0; i < Q_MODEL_N_COLUMNS; i++) { for (i = 0; i < GUI_MODEL_N_COLUMNS; i++) {
bool has = (i < Q_MODEL_LAST_PLAY); bool has = (i < GUI_MODEL_LAST_PLAY);
g_assert(settings_has(QUEUE_SETTINGS[i]) == has); g_assert(settings_has(QUEUE_SETTINGS[i]) == has);
/* The "Played" column gets any remaining space. */ /* The "Played" column gets any remaining space. */
if (has) if (has)
@ -80,11 +80,11 @@ static void test_treeview()
g_assert_false(settings_has("gui.queue.filepath")); g_assert_false(settings_has("gui.queue.filepath"));
g_assert_cmpuint(settings_get("gui.queue.filepath"), ==, 0); 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); settings_set(QUEUE_SETTINGS[i], 42);
gui_view_init(); 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); col = gtk_tree_view_get_column(treeview, i);
g_assert_cmpuint(gtk_tree_view_column_get_fixed_width(col), ==, 42); 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); gtk_init(&argc, NULL);
core_init(&argc, NULL, &init_data); core_init(&argc, NULL, &init_data);
gui_builder_init("share/ocarina/ocarina.ui"); gui_builder_init("share/ocarina/ocarina.ui");
gui_queue_model_init(); gui_model_init();
gui_view_init(); gui_view_init();
gui_test_init(); gui_test_init();
while (idle_run_task()) {}; while (idle_run_task()) {};