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/model.h>
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,
};

4
gui/ocarina.c
View File

@ -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();
}

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)
{
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,
};

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)
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];

67
gui/view.c
View File

@ -12,30 +12,27 @@
#include <glib/gi18n.h>
#include <stdlib.h>
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)

83
include/gui/model.h
View File

@ -6,76 +6,75 @@
#include <core/queue.h>
#include <gtk/gtk.h>
#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 */

4
tests/gui/audio.c
View File

@ -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;

126
tests/gui/model.c
View File

@ -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);

2
tests/gui/playlist.c
View File

@ -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");

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 = {
.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()) {};

42
tests/gui/view.c
View File

@ -12,18 +12,18 @@
#include <tests/test.h>
#include <tests/gui.h>
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()) {};