static void
impl_finalize (GObject *object)
{
RBTrackTransferBatch *batch = RB_TRACK_TRANSFER_BATCH (object);
rb_list_deep_free (batch->priv->media_types);
rb_list_destroy_free (batch->priv->entries, (GDestroyNotify) rhythmdb_entry_unref);
rb_list_destroy_free (batch->priv->done_entries, (GDestroyNotify) rhythmdb_entry_unref);
rhythmdb_entry_unref (batch->priv->current);
G_OBJECT_CLASS (rb_track_transfer_batch_parent_class)->finalize (object);
}
static void
playlist_row_inserted_cb (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
RBCdRecorderPlugin *pi)
{
RhythmDBEntry *entry = rhythmdb_query_model_iter_to_entry (RHYTHMDB_QUERY_MODEL (model), iter);
playlist_entries_changed (model, entry, pi);
rhythmdb_entry_unref (entry);
}
static gboolean
is_playing_entry (RBNotificationPlugin *plugin, RhythmDBEntry *entry)
{
RhythmDBEntry *playing;
playing = rb_shell_player_get_playing_entry (plugin->shell_player);
if (playing == NULL) {
return FALSE;
}
rhythmdb_entry_unref (playing);
return (entry == playing);
}
static void
rb_static_playlist_source_row_inserted (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
RBStaticPlaylistSource *source)
{
RhythmDBEntry *entry;
gtk_tree_model_get (model, iter, 0, &entry, -1);
rb_static_playlist_source_add_entry (source, entry, -1);
rhythmdb_entry_unref (entry);
}
static gboolean
_remove_entry_cb (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
RhythmDBPropertyModel *propmodel)
{
RhythmDBEntry *entry;
entry = rhythmdb_query_model_iter_to_entry (RHYTHMDB_QUERY_MODEL (model), iter);
rhythmdb_property_model_entry_removed_cb (RHYTHMDB_QUERY_MODEL (model),
entry,
propmodel);
rhythmdb_entry_unref (entry);
return FALSE;
}
static void
rhythmdb_property_model_row_inserted_cb (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
RhythmDBPropertyModel *propmodel)
{
RhythmDBEntry *entry;
entry = rhythmdb_query_model_iter_to_entry (RHYTHMDB_QUERY_MODEL (model), iter);
rhythmdb_property_model_insert (propmodel, entry);
rhythmdb_property_model_sync (propmodel);
rhythmdb_entry_unref (entry);
}
static gboolean
set_extract (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
{
RBAudioCDEntryData *extra_data;
RhythmDBEntry *entry;
entry = rhythmdb_query_model_iter_to_entry (RHYTHMDB_QUERY_MODEL (model),
iter);
if (entry != NULL) {
extra_data = RHYTHMDB_ENTRY_GET_TYPE_DATA (entry, RBAudioCDEntryData);
extra_data->extract = GPOINTER_TO_INT (data);
gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, iter);
rhythmdb_entry_unref (entry);
}
return FALSE;
}
static void
extract_cell_data_func (GtkTreeViewColumn *column,
GtkCellRenderer *renderer,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
RBAudioCdSource *source)
{
RBAudioCDEntryData *extra_data;
RhythmDBEntry *entry;
entry = rhythmdb_query_model_iter_to_entry (RHYTHMDB_QUERY_MODEL (tree_model), iter);
if (entry != NULL) {
extra_data = RHYTHMDB_ENTRY_GET_TYPE_DATA (entry, RBAudioCDEntryData);
gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (renderer), extra_data->extract);
rhythmdb_entry_unref (entry);
}
}
static void
rb_playlist_source_row_deleted (GtkTreeModel *model,
GtkTreePath *path,
RBPlaylistSource *source)
{
RhythmDBEntry *entry;
RBRefString *location;
entry = rhythmdb_query_model_tree_path_to_entry (RHYTHMDB_QUERY_MODEL (model),
path);
location = rhythmdb_entry_get_refstring (entry, RHYTHMDB_PROP_LOCATION);
if (g_hash_table_remove (source->priv->entries, location))
source->priv->dirty = TRUE;
rb_refstring_unref (location);
rhythmdb_entry_unref (entry);
}
END_TEST
START_TEST (test_rhythmdb_modify_after_delete)
{
RhythmDBEntry *entry;
GValue val = {0,};
entry = rhythmdb_entry_new (db, RHYTHMDB_ENTRY_TYPE_IGNORE, "file:///whee.ogg");
fail_unless (entry != NULL, "failed to create entry");
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Anything");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_GENRE, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Nothing");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_ARTIST, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Something");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_ALBUM, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Thing");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_TITLE, &val);
g_value_unset (&val);
rhythmdb_commit (db);
rhythmdb_entry_ref (entry);
rhythmdb_entry_delete (db, entry);
rhythmdb_commit (db);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Something Else");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_ALBUM, &val);
g_value_unset (&val);
rhythmdb_commit (db);
rhythmdb_entry_unref (entry);
}
static void
save_playlist_entry (GtkTreeModel *model, GtkTreeIter *iter,
char **uri, char **title,
gboolean *custom_title,
SavePlaylistData *data)
{
RBGenericPlayerPlaylistSourcePrivate *priv = GET_PRIVATE (data->source);
RhythmDBEntry *entry;
const char *host_uri;
entry = rhythmdb_query_model_iter_to_entry (RHYTHMDB_QUERY_MODEL (model),
iter);
if (entry == NULL) {
return;
}
host_uri = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION);
*uri = rb_generic_player_source_uri_to_playlist_uri (priv->player_source, host_uri, data->playlist_type);
*title = rhythmdb_entry_dup_string (entry, RHYTHMDB_PROP_TITLE);
*custom_title = TRUE;
rhythmdb_entry_unref (entry);
}
static RhythmDBEntry *
rb_linear_play_order_get_previous (RBPlayOrder *porder)
{
RhythmDBQueryModel *model;
RhythmDBEntry *entry, *prev;
g_return_val_if_fail (porder != NULL, NULL);
g_return_val_if_fail (RB_IS_LINEAR_PLAY_ORDER (porder), NULL);
model = rb_play_order_get_query_model (porder);
if (model == NULL)
return NULL;
entry = rb_play_order_get_playing_entry (porder);
if (entry == NULL)
return NULL;
prev = rhythmdb_query_model_get_previous_from_entry (model, entry);
rhythmdb_entry_unref (entry);
return prev;
}
static gboolean
copy_entry (RhythmDBQueryModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
GList **list)
{
RBAudioCDEntryData *extra_data;
RhythmDBEntry *entry;
GList *l;
entry = rhythmdb_query_model_iter_to_entry (model, iter);
extra_data = RHYTHMDB_ENTRY_GET_TYPE_DATA (entry, RBAudioCDEntryData);
if (extra_data->extract) {
rb_debug ("adding track %s to transfer list",
rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
l = g_list_append (*list, entry);
*list = l;
} else {
rb_debug ("skipping track %s",
rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
rhythmdb_entry_unref (entry);
}
return FALSE;
}
static gboolean
start_next (RBTrackTransferBatch *batch)
{
GstEncodingProfile *profile = NULL;
if (batch->priv->cancelled == TRUE) {
return FALSE;
}
if (batch->priv->entries == NULL) {
/* guess we must be done.. */
g_signal_emit (batch, signals[COMPLETE], 0);
g_object_notify (G_OBJECT (batch), "task-outcome");
return FALSE;
}
batch->priv->current_fraction = 0.0;
rb_debug ("%d entries remain in the batch", g_list_length (batch->priv->entries));
while ((batch->priv->entries != NULL) && (batch->priv->cancelled == FALSE)) {
RhythmDBEntry *entry;
guint64 filesize;
gulong duration;
double fraction;
GList *n;
char *media_type;
char *extension;
n = batch->priv->entries;
batch->priv->entries = g_list_remove_link (batch->priv->entries, n);
entry = (RhythmDBEntry *)n->data;
g_list_free_1 (n);
rb_debug ("attempting to transfer %s", rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
/* calculate the fraction of the transfer that this entry represents */
filesize = rhythmdb_entry_get_uint64 (entry, RHYTHMDB_PROP_FILE_SIZE);
duration = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_DURATION);
if (batch->priv->total_duration > 0) {
g_assert (duration > 0); /* otherwise total_duration would be 0 */
fraction = ((double)duration) / (double) batch->priv->total_duration;
} else if (batch->priv->total_size > 0) {
g_assert (filesize > 0); /* otherwise total_size would be 0 */
fraction = ((double)filesize) / (double) batch->priv->total_size;
} else {
int count = g_list_length (batch->priv->entries) +
g_list_length (batch->priv->done_entries) + 1;
fraction = 1.0 / ((double)count);
}
profile = NULL;
if (select_profile_for_entry (batch, entry, &profile, FALSE) == FALSE) {
rb_debug ("skipping entry %s, can't find an encoding profile",
rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
rhythmdb_entry_unref (entry);
batch->priv->total_fraction += fraction;
continue;
}
if (profile != NULL) {
media_type = rb_gst_encoding_profile_get_media_type (profile);
extension = g_strdup (rb_gst_media_type_to_extension (media_type));
rb_gst_encoding_profile_set_preset (profile, NULL);
if (batch->priv->settings != NULL) {
GVariant *preset_settings;
char *active_preset;
preset_settings = g_settings_get_value (batch->priv->settings,
"media-type-presets");
active_preset = NULL;
g_variant_lookup (preset_settings, media_type, "s", &active_preset);
rb_debug ("setting preset %s for media type %s",
active_preset, media_type);
rb_gst_encoding_profile_set_preset (profile, active_preset);
g_free (active_preset);
}
} else {
media_type = rhythmdb_entry_dup_string (entry, RHYTHMDB_PROP_MEDIA_TYPE);
extension = g_strdup (rb_gst_media_type_to_extension (media_type));
if (extension == NULL) {
extension = get_extension_from_location (entry);
}
}
g_free (batch->priv->current_dest_uri);
batch->priv->current_dest_uri = NULL;
g_signal_emit (batch, signals[GET_DEST_URI], 0,
entry,
media_type,
extension,
&batch->priv->current_dest_uri);
g_free (media_type);
g_free (extension);
if (batch->priv->current_dest_uri == NULL) {
rb_debug ("unable to build destination URI for %s, skipping",
rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
rhythmdb_entry_unref (entry);
batch->priv->total_fraction += fraction;
continue;
}
batch->priv->current = entry;
batch->priv->current_entry_fraction = fraction;
batch->priv->current_profile = profile;
break;
}
if (batch->priv->current != NULL) {
g_signal_emit (batch, signals[TRACK_STARTED], 0,
batch->priv->current,
batch->priv->current_dest_uri);
start_encoding (batch, FALSE);
g_object_notify (G_OBJECT (batch), "task-detail");
}
return TRUE;
}
static gboolean
start_next (RBTrackTransferBatch *batch)
{
char *media_type = NULL;
char *extension = NULL;
if (batch->priv->cancelled == TRUE) {
return FALSE;
}
if (batch->priv->entries == NULL) {
/* guess we must be done.. */
g_signal_emit (batch, signals[COMPLETE], 0);
return FALSE;
}
batch->priv->current_fraction = 0.0;
batch->priv->current_encoder = rb_encoder_new ();
g_signal_connect_object (batch->priv->current_encoder, "progress",
G_CALLBACK (encoder_progress_cb),
batch, 0);
g_signal_connect_object (batch->priv->current_encoder, "overwrite",
G_CALLBACK (encoder_overwrite_cb),
batch, 0);
g_signal_connect_object (batch->priv->current_encoder, "completed",
G_CALLBACK (encoder_completed_cb),
batch, 0);
rb_debug ("%d entries remain in the batch", g_list_length (batch->priv->entries));
while ((batch->priv->entries != NULL) && (batch->priv->cancelled == FALSE)) {
RhythmDBEntry *entry;
guint64 filesize;
gulong duration;
double fraction;
GList *n;
n = batch->priv->entries;
batch->priv->entries = g_list_remove_link (batch->priv->entries, n);
entry = (RhythmDBEntry *)n->data;
g_list_free_1 (n);
rb_debug ("attempting to transfer %s", rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
/* calculate the fraction of the transfer that this entry represents */
filesize = rhythmdb_entry_get_uint64 (entry, RHYTHMDB_PROP_FILE_SIZE);
duration = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_DURATION);
if (batch->priv->total_duration > 0) {
g_assert (duration > 0); /* otherwise total_duration would be 0 */
fraction = ((double)duration) / (double) batch->priv->total_duration;
} else if (batch->priv->total_size > 0) {
g_assert (filesize > 0); /* otherwise total_size would be 0 */
fraction = ((double)filesize) / (double) batch->priv->total_size;
} else {
int count = g_list_length (batch->priv->entries) +
g_list_length (batch->priv->done_entries) + 1;
fraction = 1.0 / ((double)count);
}
g_free (media_type);
g_free (extension);
media_type = NULL;
extension = NULL;
if (rb_encoder_get_media_type (batch->priv->current_encoder,
entry,
batch->priv->media_types,
&media_type,
&extension) == FALSE) {
rb_debug ("skipping entry %s, can't find a destination format",
rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
rhythmdb_entry_unref (entry);
batch->priv->total_fraction += fraction;
continue;
}
g_free (batch->priv->current_dest_uri);
batch->priv->current_dest_uri = NULL;
g_signal_emit (batch, signals[GET_DEST_URI], 0,
entry,
media_type,
extension,
&batch->priv->current_dest_uri);
if (batch->priv->current_dest_uri == NULL) {
rb_debug ("unable to build destination URI for %s, skipping",
rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
rhythmdb_entry_unref (entry);
batch->priv->total_fraction += fraction;
continue;
}
batch->priv->current = entry;
batch->priv->current_entry_fraction = fraction;
break;
}
if (batch->priv->current == NULL) {
g_object_unref (batch->priv->current_encoder);
batch->priv->current_encoder = NULL;
} else {
g_signal_emit (batch, signals[TRACK_STARTED], 0,
batch->priv->current,
batch->priv->current_dest_uri);
rb_encoder_encode (batch->priv->current_encoder,
batch->priv->current,
batch->priv->current_dest_uri,
media_type);
}
g_free (media_type);
g_free (extension);
return TRUE;
}
static ClutterActor *
create_track_info (RBShell *shell)
{
RBShellPlayer *player;
RhythmDB *db;
ClutterActor *box;
ClutterActor *box2;
ClutterActor *widget;
ClutterActor *frame;
RhythmDBEntry *entry;
GValue *value;
guint elapsed;
g_object_get (shell, "shell-player", &player, "db", &db, NULL);
entry = rb_shell_player_get_playing_entry (player);
box = mx_box_layout_new ();
mx_box_layout_set_orientation (MX_BOX_LAYOUT (box), MX_ORIENTATION_HORIZONTAL);
mx_box_layout_set_spacing (MX_BOX_LAYOUT (box), 16);
mx_stylable_set_style_class (MX_STYLABLE (box), "TrackInfoBox");
mx_stylable_set_style (MX_STYLABLE (box), style);
/* XXX rtl? */
/* image container */
frame = mx_frame_new ();
mx_stylable_set_style_class (MX_STYLABLE (frame), "TrackInfoImage");
mx_stylable_set_style (MX_STYLABLE (frame), style);
mx_box_layout_add_actor (MX_BOX_LAYOUT (box), frame, 0);
clutter_container_child_set (CLUTTER_CONTAINER (box), frame,
"expand", FALSE,
NULL);
set_blank_image (MX_FRAME (frame));
clutter_actor_show_all (CLUTTER_ACTOR (frame));
g_signal_connect_object (player, "playing-song-changed", G_CALLBACK (cover_art_entry_changed_cb), frame, 0);
request_cover_art (MX_FRAME (frame), entry);
box2 = mx_box_layout_new ();
mx_box_layout_set_orientation (MX_BOX_LAYOUT (box2), MX_ORIENTATION_VERTICAL);
mx_box_layout_set_spacing (MX_BOX_LAYOUT (box2), 16);
mx_stylable_set_style (MX_STYLABLE (box2), style);
mx_box_layout_add_actor (MX_BOX_LAYOUT (box), box2, 1);
clutter_container_child_set (CLUTTER_CONTAINER (box), box2,
"expand", TRUE,
"x-fill", TRUE,
"y-fill", TRUE,
"y-align", MX_ALIGN_MIDDLE,
NULL);
/* track info */
widget = mx_label_new ();
mx_stylable_set_style_class (MX_STYLABLE (widget), "TrackInfoText");
mx_stylable_set_style (MX_STYLABLE (widget), style);
mx_box_layout_add_actor (MX_BOX_LAYOUT (box2), widget, 1);
clutter_container_child_set (CLUTTER_CONTAINER (box2), widget,
"expand", FALSE,
"x-fill", TRUE,
"y-fill", TRUE,
"y-align", MX_ALIGN_MIDDLE,
NULL);
g_signal_connect_object (player, "playing-song-changed", G_CALLBACK (playing_song_changed_cb), widget, 0);
g_signal_connect_object (db, "entry-changed", G_CALLBACK (entry_changed_cb), widget, 0);
g_signal_connect_object (db, "entry-extra-metadata-notify::" RHYTHMDB_PROP_STREAM_SONG_TITLE, G_CALLBACK (streaming_title_notify_cb), widget, 0);
value = rhythmdb_entry_request_extra_metadata (db, entry, RHYTHMDB_PROP_STREAM_SONG_TITLE);
if (value != NULL) {
update_track_info (MX_LABEL (widget), db, entry, g_value_get_string (value));
g_value_unset (value);
g_free (value);
} else {
update_track_info (MX_LABEL (widget), db, entry, NULL);
}
/* elapsed/duration */
widget = mx_label_new ();
mx_stylable_set_style_class (MX_STYLABLE (widget), "TrackTimeText");
mx_stylable_set_style (MX_STYLABLE (widget), style);
mx_box_layout_add_actor (MX_BOX_LAYOUT (box2), widget, 2);
clutter_container_child_set (CLUTTER_CONTAINER (box2), widget,
"expand", FALSE,
"x-fill", TRUE,
"y-fill", TRUE,
"y-align", MX_ALIGN_MIDDLE,
NULL);
g_signal_connect_object (player, "elapsed-changed", G_CALLBACK (elapsed_changed_cb), widget, 0);
if (rb_shell_player_get_playing_time (player, &elapsed, NULL)) {
update_elapsed (widget, player, elapsed);
}
rhythmdb_entry_unref (entry);
g_object_unref (player);
g_object_unref (db);
return box;
}
static void
prepare_encoder_sink_cb (RBEncoderFactory *factory,
const char *stream_uri,
GObject *sink,
RBMtpSource *source)
{
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);
RhythmDBEntry *entry;
RhythmDB *db;
LIBMTP_track_t *track;
char **bits;
char *extension;
LIBMTP_filetype_t filetype;
gulong track_id;
GDate d;
char **folder_path;
/* make sure this stream is for a file on our device */
if (g_str_has_prefix (stream_uri, "xrbmtp://") == FALSE)
return;
/* extract the entry ID, extension, and MTP filetype from the URI */
bits = g_strsplit (stream_uri + strlen ("xrbmtp://"), "/", 3);
track_id = strtoul (bits[0], NULL, 0);
extension = g_strdup (bits[1]);
filetype = strtoul (bits[2], NULL, 0);
g_strfreev (bits);
db = get_db_for_source (source);
entry = rhythmdb_entry_lookup_by_id (db, track_id);
g_object_unref (db);
if (entry == NULL) {
g_free (extension);
return;
}
track = LIBMTP_new_track_t ();
track->title = rhythmdb_entry_dup_string (entry, RHYTHMDB_PROP_TITLE);
track->album = rhythmdb_entry_dup_string (entry, RHYTHMDB_PROP_ALBUM);
track->artist = rhythmdb_entry_dup_string (entry, RHYTHMDB_PROP_ARTIST);
track->genre = rhythmdb_entry_dup_string (entry, RHYTHMDB_PROP_GENRE);
/* build up device filename */
track->filename = g_strdup_printf ("%s - %s.%s",
rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ARTIST),
rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE),
extension);
g_free (extension);
/* construct folder path: artist/album */
folder_path = g_new0 (char *, 3);
folder_path[0] = rhythmdb_entry_dup_string (entry, RHYTHMDB_PROP_ALBUM_ARTIST);
if (folder_path[0] == NULL || folder_path[0][0] == '\0') {
g_free (folder_path[0]);
folder_path[0] = rhythmdb_entry_dup_string (entry, RHYTHMDB_PROP_ARTIST);
}
folder_path[1] = rhythmdb_entry_dup_string (entry, RHYTHMDB_PROP_ALBUM);
/* ensure the filename is safe for FAT filesystems and doesn't contain slashes */
sanitize_for_mtp (track->filename);
sanitize_for_mtp (folder_path[0]);
sanitize_for_mtp (folder_path[1]);
if (rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_DATE) > 0) {
g_date_set_julian (&d, rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_DATE));
track->date = gdate_to_char (&d);
}
track->tracknumber = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_TRACK_NUMBER);
track->duration = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_DURATION) * 1000;
track->rating = rhythmdb_entry_get_double (entry, RHYTHMDB_PROP_RATING) * 20;
track->usecount = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_PLAY_COUNT);
track->filetype = filetype;
g_object_set (sink,
"device-thread", priv->device_thread,
"folder-path", folder_path,
"mtp-track", track,
NULL);
rhythmdb_entry_unref (entry);
g_strfreev (folder_path);
g_hash_table_insert (priv->track_transfer_map, g_strdup (stream_uri), track);
}
static void
impl_activate (PeasActivatable *activatable)
{
RBVisualizerPlugin *pi = RB_VISUALIZER_PLUGIN (activatable);
RBDisplayPageGroup *page_group;
RhythmDBEntry *entry;
GtkToggleAction *fullscreen;
GtkWidget *menu;
RBShell *shell;
g_object_get (pi, "object", &shell, NULL);
pi->settings = g_settings_new ("org.gnome.rhythmbox.plugins.visualizer");
g_signal_connect_object (pi->settings, "changed", G_CALLBACK (settings_changed_cb), pi, 0);
/* create UI actions and menus and stuff */
fullscreen = gtk_toggle_action_new ("VisualizerFullscreen",
_("Fullscreen"),
_("Toggle fullscreen visual effects"),
GTK_STOCK_FULLSCREEN);
menu = rb_visualizer_create_popup_menu (fullscreen);
g_object_ref_sink (menu);
/* create visualizer page */
pi->page = rb_visualizer_page_new (G_OBJECT (pi), shell, fullscreen, menu);
g_signal_connect_object (pi->page, "start", G_CALLBACK (start_visualizer_cb), pi, 0);
g_signal_connect_object (pi->page, "stop", G_CALLBACK (stop_visualizer_cb), pi, 0);
/* don't do anything if we couldn't create a video sink (clutter is broken, etc.) */
g_object_get (pi->page, "sink", &pi->sink, NULL);
if (pi->sink == NULL) {
g_object_unref (shell);
return;
}
/* prepare style stuff for fullscreen display */
rb_visualizer_fullscreen_load_style (G_OBJECT (pi));
/* add the visualizer page to the UI */
page_group = rb_display_page_group_get_by_id ("display");
if (page_group == NULL) {
page_group = rb_display_page_group_new (G_OBJECT (shell),
"display",
_("Display"),
RB_DISPLAY_PAGE_GROUP_CATEGORY_TOOLS);
rb_shell_append_display_page (shell, RB_DISPLAY_PAGE (page_group), NULL);
}
g_object_set (pi->page, "visibility", FALSE, NULL);
rb_shell_append_display_page (shell, RB_DISPLAY_PAGE (pi->page), RB_DISPLAY_PAGE (page_group));
/* get player objects */
g_object_get (shell, "shell-player", &pi->shell_player, NULL);
g_object_get (pi->shell_player, "player", &pi->player, NULL);
/* only show the page in the page tree when playing something */
g_signal_connect_object (pi->shell_player, "playing-song-changed", G_CALLBACK (playing_song_changed_cb), pi, 0);
entry = rb_shell_player_get_playing_entry (pi->shell_player);
playing_song_changed_cb (pi->shell_player, entry, pi);
if (entry != NULL) {
rhythmdb_entry_unref (entry);
}
/* figure out how to insert the visualizer into the playback pipeline */
if (g_object_class_find_property (G_OBJECT_GET_CLASS (pi->player), "playbin")) {
rb_debug ("using playbin-based visualization");
pi->playbin_notify_id = g_signal_connect_object (pi->player,
"notify::playbin",
G_CALLBACK (playbin_notify_cb),
pi,
0);
g_object_get (pi->player, "playbin", &pi->playbin, NULL);
if (pi->playbin != NULL) {
mutate_playbin (pi, pi->playbin);
}
} else if (RB_IS_PLAYER_GST_TEE (pi->player)) {
rb_debug ("using tee-based visualization");
} else {
g_warning ("unknown player backend type");
g_object_unref (pi->player);
pi->player = NULL;
}
g_object_unref (shell);
}
