commit b7c9145bde1fb59feb7196478ddba4441cf01f15
Author: phantomjinx <[email protected]>
Date: Wed Aug 31 21:40:54 2011 +0100
Support for clarity detecting track additions
* album_model.*
* Changes to API adding functions for getting the index of an album item
given an album item or track.
* Include the album item index in the album_model_foreach function,
avoiding the need to the canvas to refind the index which is a potential
bottle neck.
* clarity_canvas
* Remove the threading as serves little purpose.
* Modifications supporting canvas add album item function
* clarity_widget
* callback for track added completed
plugins/clarity/album_model.c | 76 +++++++++++++++++++++++++-------
plugins/clarity/album_model.h | 20 +++++++-
plugins/clarity/clarity_canvas.c | 90 ++++++++++++++++++-------------------
plugins/clarity/clarity_canvas.h | 2 +
plugins/clarity/clarity_widget.c | 32 +++++++++++++-
5 files changed, 153 insertions(+), 67 deletions(-)
---
diff --git a/plugins/clarity/album_model.c b/plugins/clarity/album_model.c
index 6db251c..f495118 100644
--- a/plugins/clarity/album_model.c
+++ b/plugins/clarity/album_model.c
@@ -45,10 +45,14 @@ struct _AlbumModelPrivate {
GList *album_key_list;
};
-static gchar *_create_key(Track *track) {
+static gchar *_create_key(gchar *artist, gchar *album) {
+ return g_strconcat(artist, "_", album, NULL);
+}
+
+static gchar *_create_key_from_track(Track *track) {
g_return_val_if_fail(track, "");
- return g_strconcat(track->artist, "_", track->album, NULL);
+ return _create_key(track->artist, track->album);
}
static void _add_track_to_album_item(AlbumItem *item, Track *track) {
@@ -118,11 +122,14 @@ void _index_album_item(AlbumModelPrivate *priv, gchar
*album_key, AlbumItem *ite
}
}
-static void _insert_track(AlbumModelPrivate *priv, Track *track) {
+/**
+ * Return true if a new album item was created. Otherwise false.
+ */
+static gboolean _insert_track(AlbumModelPrivate *priv, Track *track) {
AlbumItem *item;
gchar *album_key;
- album_key = _create_key(track);
+ album_key = _create_key_from_track(track);
/* Check whether an album item has already been created in connection
* with the track's artist and album
*/
@@ -131,13 +138,14 @@ static void _insert_track(AlbumModelPrivate *priv, Track
*track) {
// Create new album item
item = _create_album_item(track);
_index_album_item(priv, album_key, item);
+ return TRUE;
}
- else {
- /* Album Item found in the album hash so prepend the
- * track to the start of the track list */
- g_free(album_key);
- _add_track_to_album_item(item, track);
- }
+
+ /* Album Item found in the album hash so prepend the
+ * track to the start of the track list */
+ g_free(album_key);
+ _add_track_to_album_item(item, track);
+ return FALSE;
}
/**
@@ -245,24 +253,34 @@ void album_model_add_tracks(AlbumModel *model, GList
*tracks) {
}
}
-void album_model_foreach (AlbumModel *model, GFunc func, gpointer user_data) {
+gboolean album_model_add_track(AlbumModel *model, Track *track) {
+ g_return_val_if_fail(model, -1);
+ g_return_val_if_fail(track, -1);
+
+ AlbumModelPrivate *priv = ALBUM_MODEL_GET_PRIVATE(model);
+ return _insert_track(priv, track);
+}
+
+void album_model_foreach (AlbumModel *model, AMFunc func, gpointer user_data) {
g_return_if_fail(model);
g_return_if_fail(func);
AlbumModelPrivate *priv = ALBUM_MODEL_GET_PRIVATE (model);
GList *iter = priv->album_key_list;
+ gint i = 0;
while(iter) {
gchar *key = iter->data;
AlbumItem *item = g_hash_table_lookup(priv->album_hash, key);
- (* func) (item, user_data);
+ (* func) (item, i, user_data);
iter = iter->next;
+ i++;
}
}
-AlbumItem *album_model_get_item(AlbumModel *model, gint index) {
+AlbumItem *album_model_get_item_with_index(AlbumModel *model, gint index) {
g_return_val_if_fail(model, NULL);
AlbumModelPrivate *priv = ALBUM_MODEL_GET_PRIVATE (model);
@@ -271,18 +289,44 @@ AlbumItem *album_model_get_item(AlbumModel *model, gint
index) {
return g_hash_table_lookup(priv->album_hash, key);
}
-gint album_model_get_index(AlbumModel *model, Track *track) {
- g_return_val_if_fail(model, -1);
+AlbumItem *album_model_get_item_with_track(AlbumModel *model, Track *track) {
+ g_return_val_if_fail(model, NULL);
AlbumModelPrivate *priv = ALBUM_MODEL_GET_PRIVATE (model);
- gchar *trk_key = _create_key(track);
+ gchar *album_key = _create_key_from_track(track);
+ return g_hash_table_lookup(priv->album_hash, album_key);
+}
+
+static gint _get_index(AlbumModelPrivate *priv, gchar *trk_key) {
GList *key_list = priv->album_key_list;
GList *key = g_list_find_custom(key_list, trk_key, (GCompareFunc)
_compare_album_item_keys);
g_return_val_if_fail (key, -1);
gint index = g_list_position(key_list, key);
+
+ return index;
+}
+
+gint album_model_get_index_with_album_item(AlbumModel *model, AlbumItem *item)
{
+ g_return_val_if_fail(model, -1);
+ AlbumModelPrivate *priv = ALBUM_MODEL_GET_PRIVATE (model);
+
+ gchar *trk_key = _create_key(item->artist, item->albumname);
+ gint index = _get_index(priv, trk_key);
+ g_free(trk_key);
+
+ return index;
+}
+
+gint album_model_get_index_with_track(AlbumModel *model, Track *track) {
+ g_return_val_if_fail(model, -1);
+
+ AlbumModelPrivate *priv = ALBUM_MODEL_GET_PRIVATE (model);
+
+ gchar *trk_key = _create_key_from_track(track);
+ gint index = _get_index(priv, trk_key);
g_free(trk_key);
return index;
diff --git a/plugins/clarity/album_model.h b/plugins/clarity/album_model.h
index 2314f8f..5ce900b 100644
--- a/plugins/clarity/album_model.h
+++ b/plugins/clarity/album_model.h
@@ -45,6 +45,8 @@ typedef struct {
} AlbumItem;
+typedef void (*AMFunc) (gpointer value, gint index, gpointer user_data);
+
GType album_model_get_type (void);
#define ALBUM_TYPE_MODEL (album_model_get_type ())
@@ -83,15 +85,27 @@ void album_model_destroy(AlbumModel *model);
void album_model_clear(AlbumModel *model);
-void album_model_foreach(AlbumModel *model, GFunc func, gpointer user_data);
+void album_model_foreach(AlbumModel *model, AMFunc func, gpointer user_data);
void album_model_resort(AlbumModel *model, GList *tracks);
void album_model_add_tracks(AlbumModel *model, GList *tracks);
-AlbumItem *album_model_get_item(AlbumModel *model, gint index);
+/**
+ * Add a single track to the album model.
+ *
+ * @return gboolean: whether a new album model was
+ * created.
+ */
+gboolean album_model_add_track(AlbumModel *model, Track *track);
+
+AlbumItem *album_model_get_item_with_index(AlbumModel *model, gint index);
+
+AlbumItem *album_model_get_item_with_track(AlbumModel *model, Track *track);
+
+gint album_model_get_index_with_album_item(AlbumModel *model, AlbumItem *item);
-gint album_model_get_index(AlbumModel *model, Track *track);
+gint album_model_get_index_with_track(AlbumModel *model, Track *track);
gint album_model_get_size(AlbumModel *model);
diff --git a/plugins/clarity/clarity_canvas.c b/plugins/clarity/clarity_canvas.c
index fbce129..837822c 100644
--- a/plugins/clarity/clarity_canvas.c
+++ b/plugins/clarity/clarity_canvas.c
@@ -106,7 +106,7 @@ static gboolean _preview_cover_cb(GtkWidget *widget,
GdkEvent *event, gpointer u
if (!priv->model)
return TRUE;
- AlbumItem *item = album_model_get_item(priv->model, priv->curr_index);
+ AlbumItem *item = album_model_get_item_with_index(priv->model,
priv->curr_index);
GtkWidget *dialog = clarity_preview_new(item);
@@ -353,8 +353,6 @@ static void _update_text(ClarityCanvasPrivate *priv) {
clutter_text_set_text(CLUTTER_TEXT(priv->title_text), title);
clutter_text_set_text(CLUTTER_TEXT(priv->artist_text), artist);
- g_warning("%s",
clutter_text_get_font_name(CLUTTER_TEXT(priv->title_text)));
-
g_free(title);
g_free(artist);
@@ -379,26 +377,24 @@ static void _display_clarity_cover(ClarityCover *ccover,
gint index) {
clutter_timeline_start (timeline);
}
-static gboolean _set_loading_complete(gpointer data) {
- ClarityCanvasPrivate *priv = (ClarityCanvasPrivate *) data;
- priv->loading_complete = TRUE;
- _update_text(priv);
- return FALSE;
-}
+static void _set_loading_complete(ClarityCanvasPrivate *priv, gboolean value) {
+ priv->loading_complete = value;
-static gboolean _create_cover_idle(gpointer data) {
+ if (value) {
+ _update_text(priv);
+ }
+
+ g_warning("Loading complete = %d", priv->loading_complete);
+}
- AlbumItem *album_item = (AlbumItem *) data;
- GObject *gobject = album_item->data;
+static gboolean _create_cover_actors(ClarityCanvasPrivate *priv, AlbumItem
*album_item, gint index) {
+ g_return_val_if_fail(priv, FALSE);
- g_return_val_if_fail(CLARITY_IS_CANVAS(gobject), FALSE);
- ClarityCanvas *ccanvas = CLARITY_CANVAS(gobject);
- ClarityCanvasPrivate *priv = CLARITY_CANVAS_GET_PRIVATE(ccanvas);
+ _set_loading_complete(priv, FALSE);
- gint index = g_list_length(priv->covers);
ClarityCover *ccover = clarity_cover_new();
clutter_actor_set_opacity(CLUTTER_ACTOR(ccover), 0);
- priv->covers = g_list_append(priv->covers, ccover);
+ priv->covers = g_list_insert(priv->covers, ccover, index);
clutter_container_add_actor(
CLUTTER_CONTAINER(priv->container),
@@ -406,15 +402,12 @@ static gboolean _create_cover_idle(gpointer data) {
clarity_cover_set_album_item(ccover, album_item);
- //TEXT
- //FIXME
-// temp.filename = filename;
-// temp.filetype = filetype;
-
- //FIXME
- // Confirm whether this does improve performance
- if(index > 20)
+ if((priv->curr_index + VISIBLE_ITEMS < index) ||
+ (priv->curr_index - VISIBLE_ITEMS > index)) {
+ g_warning("Not creating anything more");
+ _set_loading_complete(priv, TRUE);
return FALSE;
+ }
gint pos = _calculate_index_distance(index);
float scale = _calculate_index_scale(index);
@@ -446,25 +439,24 @@ static gboolean _create_cover_idle(gpointer data) {
_display_clarity_cover(ccover, index);
+ _set_loading_complete(priv, TRUE);
+
return FALSE;
}
-void _init_album_item(gpointer data, gpointer user_data) {
- AlbumItem *item = (AlbumItem *) data;
+void _init_album_item(gpointer value, gint index, gpointer user_data) {
+ AlbumItem *item = (AlbumItem *) value;
ClarityCanvas *cc = CLARITY_CANVAS(user_data);
-
- gdk_threads_enter();
+ ClarityCanvasPrivate *priv = CLARITY_CANVAS_GET_PRIVATE(cc);
Track *track = g_list_nth_data(item->tracks, 0);
item->albumart = _get_track_image(track);
item->data = cc;
- g_idle_add_full(G_PRIORITY_LOW, _create_cover_idle, item, NULL);
-
- gdk_threads_leave();
+ _create_cover_actors(priv, item, index);
}
-static gpointer _init_album_model_threaded(gpointer data) {
+static gpointer _init_album_model(gpointer data) {
g_return_val_if_fail(CLARITY_IS_CANVAS(data), NULL);
ClarityCanvas *cc = CLARITY_CANVAS(data);
@@ -473,8 +465,6 @@ static gpointer _init_album_model_threaded(gpointer data) {
album_model_foreach(model, _init_album_item, cc);
- g_idle_add_full(G_PRIORITY_LOW, _set_loading_complete, priv, NULL);
-
return NULL;
}
@@ -487,13 +477,8 @@ void clarity_canvas_init_album_model(ClarityCanvas *self,
AlbumModel *model) {
ClarityCanvasPrivate *priv = CLARITY_CANVAS_GET_PRIVATE(self);
priv->model = model;
- priv->loading_complete = FALSE;
- g_thread_create_full(_init_album_model_threaded, self, /* user data */
- 0, /* stack size */
- FALSE, /* joinable */
- TRUE, /* bound */
- G_THREAD_PRIORITY_LOW, NULL);
+ _init_album_model(self);
}
@@ -569,6 +554,9 @@ static void _restore_z_order(ClarityCanvasPrivate *priv) {
}
static void _move(ClarityCanvasPrivate *priv, enum DIRECTION direction, gint
increment) {
+
+ _set_loading_complete(priv, FALSE);
+
/* Stop any animation */
clutter_timeline_stop(priv->timeline);
@@ -583,8 +571,9 @@ static void _move(ClarityCanvasPrivate *priv, enum
DIRECTION direction, gint inc
priv->curr_index += ((direction * -1) * increment);
- _update_text(priv);
_restore_z_order(priv);
+
+ _set_loading_complete(priv, TRUE);
}
void clarity_canvas_move_left(ClarityCanvas *self, gint increment) {
@@ -594,8 +583,6 @@ void clarity_canvas_move_left(ClarityCanvas *self, gint
increment) {
if(priv->curr_index == g_list_length(priv->covers) - 1)
return;
- priv->loading_complete = FALSE;
-
_move(priv, MOVE_LEFT, increment);
}
@@ -606,8 +593,6 @@ void clarity_canvas_move_right(ClarityCanvas *self, gint
increment) {
if(priv->curr_index == 0)
return;
- priv->loading_complete = FALSE;
-
_move(priv, MOVE_RIGHT, increment);
}
@@ -624,3 +609,16 @@ gboolean clarity_canvas_is_loading(ClarityCanvas *self) {
return !priv->loading_complete;
}
+void clarity_canvas_add_album_item(ClarityCanvas *self, AlbumItem *item) {
+ g_return_if_fail(self);
+ g_return_if_fail(item);
+
+ ClarityCanvasPrivate *priv = CLARITY_CANVAS_GET_PRIVATE(self);
+ gint index = album_model_get_index_with_album_item(priv->model, item);
+
+ _set_loading_complete(priv, FALSE);
+
+ _init_album_item(item, index, self);
+
+ _set_loading_complete(priv, TRUE);
+}
diff --git a/plugins/clarity/clarity_canvas.h b/plugins/clarity/clarity_canvas.h
index 346c8de..4b20e8d 100644
--- a/plugins/clarity/clarity_canvas.h
+++ b/plugins/clarity/clarity_canvas.h
@@ -88,6 +88,8 @@ gint clarity_canvas_get_current_index(ClarityCanvas *self);
gboolean clarity_canvas_is_loading(ClarityCanvas *self);
+void clarity_canvas_add_album_item(ClarityCanvas *self, AlbumItem *item);
+
G_END_DECLS
#endif /* CLARITY_CANVAS_H_ */
diff --git a/plugins/clarity/clarity_widget.c b/plugins/clarity/clarity_widget.c
index 03c9e7d..ea96e8e 100644
--- a/plugins/clarity/clarity_widget.c
+++ b/plugins/clarity/clarity_widget.c
@@ -434,12 +434,40 @@ void clarity_widget_tracks_selected_cb(GtkPodApp *app,
gpointer tks, gpointer da
if (clarity_canvas_is_loading(ccanvas))
return;
- gint album_index = album_model_get_index(priv->album_model, tracks->data);
+ gint album_index = album_model_get_index_with_track(priv->album_model,
tracks->data);
gtk_range_set_value(GTK_RANGE (priv->cdslider), album_index);
}
+void clarity_widget_track_added_cb(GtkPodApp *app, gpointer tk, gpointer data)
{
+ g_return_if_fail(CLARITY_IS_WIDGET(data));
+
+ ClarityWidget *cw = CLARITY_WIDGET(data);
+ ClarityWidgetPrivate *priv = CLARITY_WIDGET_GET_PRIVATE(cw);
+ Track *track = tk;
+
+
+ if (!track)
+ return;
+
+ GList *current_tracks = cw->current_playlist->members;
+ if (!g_list_find(current_tracks, track)) {
+ // Track not added to this playlist
+ return;
+ }
+
+ ClarityCanvas *ccanvas = CLARITY_CANVAS(priv->draw_area);
+
+ if (clarity_canvas_is_loading(ccanvas))
+ return;
+
+ if (album_model_add_track(priv->album_model, track)) {
+ AlbumItem *item = album_model_get_item_with_track(priv->album_model,
track);
+ clarity_canvas_add_album_item(CLARITY_CANVAS(priv->draw_area), item);
+ _init_slider_range(priv);
+ }
+}
+
void clarity_widget_track_removed_cb(GtkPodApp *app, gpointer tk, gpointer
data) {}
void clarity_widget_track_updated_cb(GtkPodApp *app, gpointer tk, gpointer
data) {}
-void clarity_widget_track_added_cb(GtkPodApp *app, gpointer tk, gpointer data)
{}
------------------------------------------------------------------------------
Special Offer -- Download ArcSight Logger for FREE!
Finally, a world-class log management solution at an even better
price-free! And you'll get a free "Love Thy Logs" t-shirt when you
download Logger. Secure your free ArcSight Logger TODAY!
http://p.sf.net/sfu/arcsisghtdev2dev
_______________________________________________
gtkpod-cvs2 mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/gtkpod-cvs2
