static void
rb_import_errors_source_songs_show_popup_cb (RBEntryView *view,
gboolean over_entry,
RBImportErrorsSource *source)
{
GtkWidget *menu;
GtkBuilder *builder;
if (over_entry == FALSE)
return;
if (source->priv->popup == NULL) {
builder = rb_builder_load ("import-errors-popup.ui", NULL);
source->priv->popup = G_MENU_MODEL (gtk_builder_get_object (builder, "import-errors-popup"));
g_object_ref (source->priv->popup);
g_object_unref (builder);
}
menu = gtk_menu_new_from_model (source->priv->popup);
gtk_menu_attach_to_widget (GTK_MENU (menu), GTK_WIDGET (source), NULL);
gtk_menu_popup (GTK_MENU (menu),
NULL,
NULL,
NULL,
NULL,
3,
gtk_get_current_event_time ());
}
static GtkWidget *
impl_create_configure_widget (PeasGtkConfigurable *bplugin)
{
RBAudioscrobblerPlugin *plugin;
char *builderfile;
GtkBuilder *builder;
GtkWidget *widget;
plugin = RB_AUDIOSCROBBLER_PLUGIN (bplugin);
builderfile = rb_find_plugin_data_file (G_OBJECT (plugin), "audioscrobbler-preferences.ui");
if (builderfile == NULL) {
g_warning ("can't find audioscrobbler-preferences.ui");
return NULL;
}
builder = rb_builder_load (builderfile, plugin);
g_free (builderfile);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "config"));
g_object_ref_sink (widget);
plugin->lastfm_enabled_check = GTK_WIDGET (gtk_builder_get_object (builder, "lastfm_enabled_check"));
g_settings_bind (plugin->lastfm_settings, AUDIOSCROBBLER_SERVICE_ENABLED_KEY, plugin->lastfm_enabled_check, "active", G_SETTINGS_BIND_DEFAULT);
plugin->librefm_enabled_check = GTK_WIDGET (gtk_builder_get_object (builder, "librefm_enabled_check"));
g_settings_bind (plugin->librefm_settings, AUDIOSCROBBLER_SERVICE_ENABLED_KEY, plugin->librefm_enabled_check, "active", G_SETTINGS_BIND_DEFAULT);
g_object_unref (builder);
return widget;
}
static GtkWidget *
impl_get_config_widget (RBDisplayPage *page, RBShellPreferences *prefs)
{
RBPodcastMainSource *source = RB_PODCAST_MAIN_SOURCE (page);
RBPodcastManager *podcast_mgr;
GtkBuilder *builder;
GtkWidget *update_interval;
GtkWidget *btn_file;
GSettings *settings;
char *download_dir;
if (source->priv->config_widget)
return source->priv->config_widget;
builder = rb_builder_load ("podcast-prefs.ui", source);
source->priv->config_widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast_vbox"));
btn_file = GTK_WIDGET (gtk_builder_get_object (builder, "location_chooser"));
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (btn_file),
rb_music_dir (),
NULL);
g_object_get (source,
"podcast-manager", &podcast_mgr,
NULL);
download_dir = rb_podcast_manager_get_podcast_dir (podcast_mgr);
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (btn_file),
download_dir);
g_object_unref (podcast_mgr);
g_free (download_dir);
g_signal_connect_object (btn_file,
"selection-changed",
G_CALLBACK (rb_podcast_main_source_btn_file_change_cb),
source, 0);
update_interval = GTK_WIDGET (gtk_builder_get_object (builder, "update_interval"));
g_object_set (update_interval, "id-column", 1, NULL);
settings = g_settings_new (PODCAST_SETTINGS_SCHEMA);
g_settings_bind (settings, PODCAST_DOWNLOAD_INTERVAL,
update_interval, "active-id",
G_SETTINGS_BIND_DEFAULT);
g_object_unref (settings);
return source->priv->config_widget;
}
static GtkWidget *
impl_get_config_widget (RBSource *asource, RBShellPreferences *prefs)
{
RBPodcastMainSource *source = RB_PODCAST_MAIN_SOURCE (asource);
RBPodcastManager *podcast_mgr;
GtkBuilder *builder;
GtkWidget *cb_update_interval;
GtkWidget *btn_file;
char *download_dir;
if (source->priv->config_widget)
return source->priv->config_widget;
builder = rb_builder_load ("podcast-prefs.ui", source);
source->priv->config_widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast_vbox"));
btn_file = GTK_WIDGET (gtk_builder_get_object (builder, "location_chooser"));
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (btn_file),
rb_music_dir (),
NULL);
g_object_get (source, "podcast-manager", &podcast_mgr, NULL);
download_dir = rb_podcast_manager_get_podcast_dir (podcast_mgr);
g_object_unref (podcast_mgr);
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (btn_file),
download_dir);
g_free (download_dir);
g_signal_connect (btn_file,
"selection-changed",
G_CALLBACK (rb_podcast_main_source_btn_file_change_cb),
CONF_STATE_PODCAST_DOWNLOAD_DIR);
cb_update_interval = GTK_WIDGET (gtk_builder_get_object (builder, "cb_update_interval"));
gtk_combo_box_set_active (GTK_COMBO_BOX (cb_update_interval),
eel_gconf_get_integer (CONF_STATE_PODCAST_DOWNLOAD_INTERVAL));
g_signal_connect (cb_update_interval,
"changed",
G_CALLBACK (rb_podcast_main_source_cb_interval_changed_cb),
source);
return source->priv->config_widget;
}
static void
impl_show_properties (RBMediaPlayerSource *source, GtkWidget *info_box, GtkWidget *notebook)
{
RhythmDBQueryModel *model;
GtkBuilder *builder;
GtkWidget *widget;
GObject *plugin;
char *builder_file;
char *text;
g_object_get (source, "plugin", &plugin, NULL);
builder_file = rb_find_plugin_data_file (plugin, "android-info.ui");
g_object_unref (plugin);
if (builder_file == NULL) {
g_warning ("Couldn't find android-info.ui");
return;
}
builder = rb_builder_load (builder_file, NULL);
g_free (builder_file);
if (builder == NULL) {
rb_debug ("Couldn't load android-info.ui");
return;
}
/* 'basic' tab stuff */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "android-basic-info"));
gtk_box_pack_start (GTK_BOX (info_box), widget, TRUE, TRUE, 0);
g_object_get (source, "base-query-model", &model, NULL);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "num-tracks"));
text = g_strdup_printf ("%d", gtk_tree_model_iter_n_children (GTK_TREE_MODEL (model), NULL));
gtk_label_set_text (GTK_LABEL (widget), text);
g_free (text);
g_object_unref (model);
g_object_unref (builder);
}
gboolean
rb_ipod_helpers_show_first_time_dialog (GMount *mount, const char *builder_file)
{
/* could be an uninitialised iPod, ask the user */
GtkBuilder *builder;
GtkWidget *dialog;
GtkWidget *widget;
GtkTreeModel *tree_model;
GtkTreeIter iter;
int response;
char *mountpoint;
const Itdb_IpodInfo *info;
char *ipod_name;
GFile *root;
GError *error = NULL;
root = g_mount_get_root (mount);
if (root == NULL) {
return FALSE;
}
mountpoint = g_file_get_path (root);
g_object_unref (G_OBJECT (root));
if (mountpoint == NULL) {
return FALSE;
}
/* create message dialog with model-number combo box
* and asking whether they want to initialise the iPod
*/
builder = rb_builder_load (builder_file, NULL);
if (builder == NULL) {
return FALSE;
}
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "ipod_init"));
widget = GTK_WIDGET (gtk_builder_get_object (builder, "model_combo"));
fill_model_combo (widget, mountpoint);
g_object_unref (builder);
rb_debug ("showing init dialog for ipod mount on '%s'", mountpoint);
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response != GTK_RESPONSE_ACCEPT) {
gtk_widget_destroy (dialog);
g_free (mountpoint);
return FALSE;
}
/* get model number and name */
tree_model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter)) {
gtk_widget_destroy (dialog);
g_free (mountpoint);
return FALSE;
}
gtk_tree_model_get (tree_model, &iter, COL_INFO, &info, -1);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "name_entry"));
ipod_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (widget)));
gtk_widget_destroy (dialog);
rb_debug ("attempting to init ipod on '%s', with model '%s' and name '%s'",
mountpoint, info->model_number, ipod_name);
if (!itdb_init_ipod (mountpoint, info->model_number, ipod_name, &error)) {
rb_error_dialog (NULL, _("Unable to initialize new iPod"), "%s", error->message);
g_free (mountpoint);
g_free (ipod_name);
g_error_free (error);
return FALSE;
}
g_free (mountpoint);
g_free (ipod_name);
return TRUE;
}
static void
rb_query_creator_constructed (GObject *object)
{
RBQueryCreatorPrivate *priv;
RBQueryCreator *creator;
GtkWidget *mainbox;
GtkWidget *content_area;
GtkBuilder *builder;
RB_CHAIN_GOBJECT_METHOD (rb_query_creator_parent_class, constructed, object);
creator = RB_QUERY_CREATOR (object);
priv = QUERY_CREATOR_GET_PRIVATE (creator);
if (priv->creating) {
gtk_dialog_add_button (GTK_DIALOG (creator),
_("_Cancel"),
GTK_RESPONSE_CLOSE);
gtk_dialog_add_button (GTK_DIALOG (creator),
_("_New"),
GTK_RESPONSE_OK);
} else {
gtk_dialog_add_button (GTK_DIALOG (creator),
_("_Close"),
GTK_RESPONSE_CLOSE);
}
gtk_dialog_set_default_response (GTK_DIALOG (creator),
GTK_RESPONSE_CLOSE);
priv->property_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->criteria_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->entry_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->button_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
if (priv->creating)
gtk_window_set_title (GTK_WINDOW (creator), _("Create Automatic Playlist"));
else
gtk_window_set_title (GTK_WINDOW (creator), _("Edit Automatic Playlist"));
content_area = gtk_dialog_get_content_area (GTK_DIALOG (creator));
gtk_container_set_border_width (GTK_CONTAINER (creator), 5);
gtk_box_set_spacing (GTK_BOX (content_area), 2);
builder = rb_builder_load ("create-playlist.ui", creator);
priv->disjunction_check = GTK_WIDGET (gtk_builder_get_object (builder, "disjunctionCheck"));
priv->limit_check = GTK_WIDGET (gtk_builder_get_object (builder, "limitCheck"));
priv->limit_entry = GTK_WIDGET (gtk_builder_get_object (builder, "limitEntry"));
priv->limit_option = GTK_WIDGET (gtk_builder_get_object (builder, "limitOption"));
priv->addbutton = GTK_WIDGET (gtk_builder_get_object (builder, "addButton"));
priv->sort_label = GTK_WIDGET (gtk_builder_get_object (builder, "sortLabel"));
priv->sort_menu = GTK_WIDGET (gtk_builder_get_object (builder, "sortMenu"));
priv->sort_desc = GTK_WIDGET (gtk_builder_get_object (builder, "sortDesc"));
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->limit_option), 0);
g_signal_connect_object (G_OBJECT (priv->limit_check), "toggled", G_CALLBACK (limit_toggled_cb),
creator, 0);
limit_toggled_cb (priv->limit_check, creator);
gtk_size_group_add_widget (priv->button_size_group, priv->addbutton);
g_signal_connect_object (G_OBJECT (priv->addbutton), "clicked", G_CALLBACK (add_button_click_cb),
creator, 0);
setup_sort_option_menu (creator, priv->sort_menu, sort_options, num_sort_options);
priv->vbox = GTK_BOX (gtk_builder_get_object (builder, "sub_vbox"));
if (priv->creating)
append_row (creator);
mainbox = GTK_WIDGET (gtk_builder_get_object (builder, "complex-playlist-creator"));
gtk_box_pack_start (GTK_BOX (content_area), mainbox, FALSE, FALSE, 0);
gtk_widget_show_all (GTK_WIDGET (creator));
g_object_unref (builder);
}
static void
display_sync_settings_dialog (RBMediaPlayerSource *source)
{
RBMediaPlayerSourcePrivate *priv = MEDIA_PLAYER_SOURCE_GET_PRIVATE (source);
GtkWidget *content;
GtkWidget *widget;
GtkBuilder *builder;
const char *ui_file;
char *name;
char *title;
g_object_get (source, "name", &name, NULL);
title = g_strdup_printf (_("%s Sync Settings"), name);
priv->sync_dialog = gtk_dialog_new_with_buttons (title,
NULL,
0,
_("Sync with the device"),
GTK_RESPONSE_YES,
_("Don't sync"),
GTK_RESPONSE_CANCEL,
NULL);
g_free (title);
priv->sync_dialog_update_id = g_signal_connect_object (priv->sync_state,
"updated",
G_CALLBACK (sync_dialog_state_update),
source, 0);
g_signal_connect_object (priv->sync_dialog,
"response",
G_CALLBACK (sync_confirm_dialog_cb),
source, 0);
/* display the sync settings, the sync state, and some helpful text indicating why
* we're not syncing already
*/
content = gtk_dialog_get_content_area (GTK_DIALOG (priv->sync_dialog));
ui_file = rb_file ("sync-dialog.ui");
if (ui_file == NULL) {
g_warning ("Couldn't find sync-state.ui");
gtk_widget_show_all (priv->sync_dialog);
return;
}
builder = rb_builder_load (ui_file, NULL);
if (builder == NULL) {
g_warning ("Couldn't load sync-state.ui");
gtk_widget_show_all (priv->sync_dialog);
return;
}
priv->sync_dialog_label = GTK_WIDGET (gtk_builder_get_object (builder, "sync-dialog-reason"));
priv->sync_dialog_error_box = GTK_WIDGET (gtk_builder_get_object (builder, "sync-dialog-message"));
widget = GTK_WIDGET (gtk_builder_get_object (builder, "sync-settings-ui-container"));
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (widget), rb_sync_settings_ui_new (source, priv->sync_settings));
widget = GTK_WIDGET (gtk_builder_get_object (builder, "sync-state-ui-container"));
gtk_box_pack_start (GTK_BOX (widget), rb_sync_state_ui_new (priv->sync_state), TRUE, TRUE, 0);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "sync-dialog"));
gtk_box_pack_start (GTK_BOX (content), widget, TRUE, TRUE, 0);
gtk_widget_show_all (priv->sync_dialog);
update_sync_settings_dialog (source);
g_object_unref (builder);
}
void
rb_media_player_source_show_properties (RBMediaPlayerSource *source)
{
RBMediaPlayerSourcePrivate *priv = MEDIA_PLAYER_SOURCE_GET_PRIVATE (source);
RBMediaPlayerSourceClass *klass = RB_MEDIA_PLAYER_SOURCE_GET_CLASS (source);
GtkBuilder *builder;
GtkContainer *container;
const char *ui_file;
char *name;
char *text;
if (priv->properties_dialog != NULL) {
gtk_window_present (GTK_WINDOW (priv->properties_dialog));
return;
}
/* load dialog UI */
ui_file = rb_file ("media-player-properties.ui");
if (ui_file == NULL) {
g_warning ("Couldn't find media-player-properties.ui");
return;
}
builder = rb_builder_load (ui_file, NULL);
if (builder == NULL) {
g_warning ("Couldn't load media-player-properties.ui");
return;
}
priv->properties_dialog = GTK_DIALOG (gtk_builder_get_object (builder, "media-player-properties"));
g_object_ref (priv->properties_dialog);
g_signal_connect_object (priv->properties_dialog,
"response",
G_CALLBACK (properties_dialog_response_cb),
source, 0);
g_object_get (source, "name", &name, NULL);
text = g_strdup_printf (_("%s Properties"), name);
gtk_window_set_title (GTK_WINDOW (priv->properties_dialog), text);
g_free (text);
g_free (name);
/* ensure device usage information is available and up to date */
update_sync (source);
/*
* fill in some common details:
* - volume usage (need to hook up signals etc. to update this live)
*/
rb_sync_state_ui_create_bar (&priv->volume_usage, rb_media_player_source_get_capacity (source), NULL);
rb_sync_state_ui_update_volume_usage (&priv->volume_usage, priv->sync_state);
gtk_widget_show_all (priv->volume_usage.widget);
container = GTK_CONTAINER (gtk_builder_get_object (builder, "device-usage-container"));
gtk_container_add (container, priv->volume_usage.widget);
/* let the subclass fill in device type specific details (model names, device names,
* .. battery levels?) and add more tabs to the notebook to display 'advanced' stuff.
*/
if (klass->show_properties) {
klass->show_properties (source,
GTK_WIDGET (gtk_builder_get_object (builder, "device-info-box")),
GTK_WIDGET (gtk_builder_get_object (builder, "media-player-notebook")));
}
/* create sync UI */
container = GTK_CONTAINER (gtk_builder_get_object (builder, "sync-settings-ui-container"));
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (container), rb_sync_settings_ui_new (source, priv->sync_settings));
container = GTK_CONTAINER (gtk_builder_get_object (builder, "sync-state-ui-container"));
gtk_box_pack_start (GTK_BOX (container), rb_sync_state_ui_new (priv->sync_state), TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (container));
/* create encoding settings UI */
if (priv->encoding_settings) {
container = GTK_CONTAINER (gtk_builder_get_object (builder, "encoding-settings-container"));
gtk_container_add (container, rb_encoding_settings_new (priv->encoding_settings, priv->encoding_target, TRUE));
gtk_widget_show_all (GTK_WIDGET (container));
} else {
container = GTK_CONTAINER (gtk_builder_get_object (builder, "encoding-settings-frame"));
gtk_widget_hide (GTK_WIDGET (container));
gtk_widget_set_no_show_all (GTK_WIDGET (container), TRUE);
}
gtk_widget_show (GTK_WIDGET (priv->properties_dialog));
g_object_unref (builder);
}
static void
impl_show_properties (RBMediaPlayerSource *source, GtkWidget *info_box, GtkWidget *notebook)
{
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);
GtkBuilder *builder;
GtkWidget *widget;
GHashTableIter iter;
gpointer key, value;
int num_podcasts;
char *device_name;
char *builder_file;
RBPlugin *plugin;
char *text;
GList *output_formats;
GList *t;
GString *str;
g_object_get (source, "plugin", &plugin, NULL);
builder_file = rb_plugin_find_file (plugin, "mtp-info.ui");
g_object_unref (plugin);
if (builder_file == NULL) {
g_warning ("Couldn't find mtp-info.ui");
return;
}
builder = rb_builder_load (builder_file, NULL);
g_free (builder_file);
if (builder == NULL) {
rb_debug ("Couldn't load mtp-info.ui");
return;
}
/* 'basic' tab stuff */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "mtp-basic-info"));
gtk_box_pack_start (GTK_BOX (info_box), widget, TRUE, TRUE, 0);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry-mtp-name"));
g_object_get (source, "name", &device_name, NULL);
gtk_entry_set_text (GTK_ENTRY (widget), device_name);
g_free (device_name);
g_signal_connect (widget, "focus-out-event",
(GCallback)rb_mtp_source_name_changed_cb, source);
num_podcasts = 0;
g_hash_table_iter_init (&iter, priv->entry_map);
while (g_hash_table_iter_next (&iter, &key, &value)) {
LIBMTP_track_t *track = value;
if (g_strcmp0 (track->genre, "Podcast") == 0) {
num_podcasts++;
}
}
widget = GTK_WIDGET (gtk_builder_get_object (builder, "mtp-num-tracks"));
text = g_strdup_printf ("%d", g_hash_table_size (priv->entry_map) - num_podcasts);
gtk_label_set_text (GTK_LABEL (widget), text);
g_free (text);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "mtp-num-podcasts"));
text = g_strdup_printf ("%d", num_podcasts);
gtk_label_set_text (GTK_LABEL (widget), text);
g_free (text);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "mtp-num-playlists"));
text = g_strdup_printf ("%d", 0); /* correct, but wrong */
gtk_label_set_text (GTK_LABEL (widget), text);
g_free (text);
/* 'advanced' tab stuff */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "mtp-advanced-tab"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), widget, gtk_label_new (_("Advanced")));
widget = GTK_WIDGET (gtk_builder_get_object (builder, "label-mtp-model-value"));
gtk_label_set_text (GTK_LABEL (widget), priv->model_name);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "label-serial-number-value"));
gtk_label_set_text (GTK_LABEL (widget), priv->serial);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "label-firmware-version-value"));
gtk_label_set_text (GTK_LABEL (widget), priv->device_version);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "label-manufacturer-value"));
gtk_label_set_text (GTK_LABEL (widget), priv->manufacturer);
str = g_string_new ("");
output_formats = rb_removable_media_source_get_format_descriptions (RB_REMOVABLE_MEDIA_SOURCE (source));
for (t = output_formats; t != NULL; t = t->next) {
if (t != output_formats) {
g_string_append (str, "\n");
}
g_string_append (str, t->data);
}
rb_list_deep_free (output_formats);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "label-audio-formats-value"));
gtk_label_set_text (GTK_LABEL (widget), str->str);
g_string_free (str, TRUE);
g_object_unref (builder);
}
static void
impl_constructed (GObject *object)
{
RBPodcastAddDialog *dialog;
GtkBuilder *builder;
GtkWidget *widget;
GtkWidget *paned;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
RBEntryView *episodes;
RBShellPlayer *shell_player;
RhythmDBQuery *query;
RhythmDBQueryModel *query_model;
const char *episode_strings[3];
RB_CHAIN_GOBJECT_METHOD (rb_podcast_add_dialog_parent_class, constructed, object);
dialog = RB_PODCAST_ADD_DIALOG (object);
g_object_get (dialog->priv->podcast_mgr, "db", &dialog->priv->db, NULL);
builder = rb_builder_load ("podcast-add-dialog.ui", NULL);
dialog->priv->info_bar_message = gtk_label_new ("");
dialog->priv->info_bar = gtk_info_bar_new ();
g_object_set (dialog->priv->info_bar, "spacing", 0, NULL);
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (dialog->priv->info_bar))),
dialog->priv->info_bar_message);
gtk_widget_set_no_show_all (dialog->priv->info_bar, TRUE);
gtk_box_pack_start (GTK_BOX (dialog), dialog->priv->info_bar, FALSE, FALSE, 0);
gtk_widget_show (dialog->priv->info_bar_message);
dialog->priv->subscribe_button = GTK_WIDGET (gtk_builder_get_object (builder, "subscribe-button"));
g_signal_connect_object (dialog->priv->subscribe_button, "clicked", G_CALLBACK (subscribe_clicked_cb), dialog, 0);
gtk_widget_set_sensitive (dialog->priv->subscribe_button, FALSE);
dialog->priv->feed_view = GTK_WIDGET (gtk_builder_get_object (builder, "feed-view"));
g_signal_connect (dialog->priv->feed_view, "row-activated", G_CALLBACK (feed_activated_cb), dialog);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->feed_view)),
"changed",
G_CALLBACK (feed_selection_changed_cb),
dialog);
dialog->priv->search_entry = rb_search_entry_new (FALSE);
gtk_widget_set_size_request (GTK_WIDGET (dialog->priv->search_entry), 400, -1);
g_object_set (dialog->priv->search_entry,"explicit-mode", TRUE, NULL);
g_signal_connect (dialog->priv->search_entry, "search", G_CALLBACK (search_cb), dialog);
g_signal_connect (dialog->priv->search_entry, "activate", G_CALLBACK (search_cb), dialog);
gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (builder, "search-entry-box")),
GTK_WIDGET (dialog->priv->search_entry));
g_signal_connect (gtk_builder_get_object (builder, "close-button"),
"clicked",
G_CALLBACK (close_clicked_cb),
dialog);
dialog->priv->feed_model = gtk_list_store_new (7,
G_TYPE_STRING, /* name */
G_TYPE_STRING, /* author */
GDK_TYPE_PIXBUF, /* image */
G_TYPE_FILE, /* image file */
G_TYPE_INT, /* episode count */
G_TYPE_POINTER, /* RBPodcastChannel */
G_TYPE_ULONG); /* date */
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->priv->feed_view), GTK_TREE_MODEL (dialog->priv->feed_model));
column = gtk_tree_view_column_new_with_attributes (_("Title"), gtk_cell_renderer_pixbuf_new (), "pixbuf", FEED_COLUMN_IMAGE, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer, "text", FEED_COLUMN_TITLE, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes (_("Author"), renderer, "text", FEED_COLUMN_AUTHOR, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Episodes"), renderer, NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer, episode_count_column_cell_data_func, NULL, NULL);
episode_strings[0] = "0000";
episode_strings[1] = _("Episodes");
episode_strings[2] = NULL;
rb_set_tree_view_column_fixed_width (dialog->priv->feed_view, column, renderer, episode_strings, 6);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast-add-dialog"));
gtk_box_pack_start (GTK_BOX (dialog), widget, TRUE, TRUE, 0);
/* set up episode view */
g_object_get (dialog->priv->shell, "shell-player", &shell_player, NULL);
episodes = rb_entry_view_new (dialog->priv->db, G_OBJECT (shell_player), TRUE, FALSE);
g_object_unref (shell_player);
g_signal_connect (episodes, "entry-activated", G_CALLBACK (episode_entry_activated_cb), dialog);
/* date column */
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_clickable (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
{
const char *sample_strings[3];
sample_strings[0] = _("Date");
sample_strings[1] = rb_entry_view_get_time_date_column_sample ();
sample_strings[2] = NULL;
rb_entry_view_set_fixed_column_width (episodes, column, renderer, sample_strings);
}
gtk_tree_view_column_set_cell_data_func (column, renderer,
(GtkTreeCellDataFunc) podcast_post_date_cell_data_func,
dialog, NULL);
rb_entry_view_append_column_custom (episodes, column,
_("Date"), "Date",
(GCompareDataFunc) podcast_post_date_sort_func,
0, NULL);
rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_TITLE, TRUE);
rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_DURATION, TRUE);
rb_entry_view_set_sorting_order (RB_ENTRY_VIEW (episodes), "Date", GTK_SORT_DESCENDING);
g_signal_connect (episodes,
"notify::sort-order",
G_CALLBACK (episodes_sort_changed_cb),
dialog);
query = rhythmdb_query_parse (dialog->priv->db,
RHYTHMDB_QUERY_PROP_EQUALS,
RHYTHMDB_PROP_TYPE,
RHYTHMDB_ENTRY_TYPE_PODCAST_SEARCH,
RHYTHMDB_QUERY_END);
query_model = rhythmdb_query_model_new_empty (dialog->priv->db);
rb_entry_view_set_model (episodes, query_model);
rhythmdb_do_full_query_async_parsed (dialog->priv->db, RHYTHMDB_QUERY_RESULTS (query_model), query);
rhythmdb_query_free (query);
g_object_unref (query_model);
paned = GTK_WIDGET (gtk_builder_get_object (builder, "paned"));
g_signal_connect (paned, "size-allocate", G_CALLBACK (paned_size_allocate_cb), dialog);
gtk_paned_pack2 (GTK_PANED (paned),
GTK_WIDGET (episodes),
TRUE,
FALSE);
gtk_widget_show_all (GTK_WIDGET (dialog));
g_object_unref (builder);
}
static void
impl_constructed (GObject *object)
{
RBImportDialog *dialog;
RhythmDBQuery *query;
GtkBuilder *builder;
GSettings *settings;
char **locations;
RB_CHAIN_GOBJECT_METHOD (rb_import_dialog_parent_class, constructed, object);
dialog = RB_IMPORT_DIALOG (object);
g_object_get (dialog->priv->shell,
"db", &dialog->priv->db,
"shell-player", &dialog->priv->shell_player,
NULL);
/* create entry types */
dialog->priv->entry_type = g_object_new (rb_import_dialog_entry_type_get_type (),
"db", dialog->priv->db,
"name", "import-dialog",
NULL);
dialog->priv->ignore_type = g_object_new (rb_import_dialog_ignore_type_get_type (),
"db", dialog->priv->db,
"name", "import-dialog-ignore",
NULL);
rhythmdb_register_entry_type (dialog->priv->db, dialog->priv->entry_type);
rhythmdb_register_entry_type (dialog->priv->db, dialog->priv->ignore_type);
builder = rb_builder_load ("import-dialog.ui", NULL);
dialog->priv->import_button = GTK_WIDGET (gtk_builder_get_object (builder, "import-button"));
g_signal_connect_object (dialog->priv->import_button, "clicked", G_CALLBACK (import_clicked_cb), dialog, 0);
gtk_widget_set_sensitive (dialog->priv->import_button, FALSE);
dialog->priv->copy_check = GTK_WIDGET (gtk_builder_get_object (builder, "copy-check"));
g_signal_connect (gtk_builder_get_object (builder, "close-button"),
"clicked",
G_CALLBACK (close_clicked_cb),
dialog);
dialog->priv->file_chooser = GTK_WIDGET (gtk_builder_get_object (builder, "file-chooser-button"));
/* select the first library location, since the default may be
* the user's home dir or / or something that will take forever to scan.
*/
settings = g_settings_new ("org.gnome.rhythmbox.rhythmdb");
locations = g_settings_get_strv (settings, "locations");
if (locations[0] != NULL) {
dialog->priv->current_uri = g_strdup (locations[0]);
} else {
dialog->priv->current_uri = g_filename_to_uri (rb_music_dir (), NULL, NULL);
}
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (dialog->priv->file_chooser),
dialog->priv->current_uri);
g_strfreev (locations);
g_object_unref (settings);
g_signal_connect_object (dialog->priv->file_chooser, "selection-changed", G_CALLBACK (current_folder_changed_cb), dialog, 0);
/* not sure why we have to set this, it should be the default */
gtk_widget_set_vexpand (gtk_widget_get_parent (dialog->priv->file_chooser), FALSE);
dialog->priv->info_bar_container = GTK_WIDGET (gtk_builder_get_object (builder, "info-bar-container"));
/* set up entry view */
dialog->priv->entry_view = rb_entry_view_new (dialog->priv->db, G_OBJECT (dialog->priv->shell_player), TRUE, FALSE);
g_signal_connect (dialog->priv->entry_view, "entry-activated", G_CALLBACK (entry_activated_cb), dialog);
g_signal_connect (dialog->priv->entry_view, "selection-changed", G_CALLBACK (selection_changed_cb), dialog);
rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE);
rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_TITLE, TRUE);
rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_GENRE, FALSE);
rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_ARTIST, FALSE);
rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_ALBUM, FALSE);
rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_YEAR, FALSE);
rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_DURATION, FALSE);
rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_QUALITY, FALSE);
rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_PLAY_COUNT, FALSE);
rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_BPM, FALSE);
rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_COMMENT, FALSE);
rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_LOCATION, FALSE);
settings = g_settings_new ("org.gnome.rhythmbox.sources");
g_settings_bind (settings, "visible-columns", dialog->priv->entry_view, "visible-columns", G_SETTINGS_BIND_DEFAULT);
g_object_unref (settings);
g_signal_connect (dialog->priv->entry_view,
"notify::sort-order",
G_CALLBACK (sort_changed_cb),
dialog);
rb_entry_view_set_sorting_order (dialog->priv->entry_view, "Album", GTK_SORT_ASCENDING);
gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (builder, "entry-view-container")),
GTK_WIDGET (dialog->priv->entry_view));
dialog->priv->query_model = rhythmdb_query_model_new_empty (dialog->priv->db);
rb_entry_view_set_model (dialog->priv->entry_view, dialog->priv->query_model);
query = rhythmdb_query_parse (dialog->priv->db,
RHYTHMDB_QUERY_PROP_EQUALS, RHYTHMDB_PROP_TYPE, dialog->priv->entry_type,
RHYTHMDB_QUERY_END);
rhythmdb_do_full_query_async_parsed (dialog->priv->db, RHYTHMDB_QUERY_RESULTS (dialog->priv->query_model), query);
rhythmdb_query_free (query);
g_signal_connect (dialog->priv->query_model, "post-entry-delete", G_CALLBACK (entry_deleted_cb), dialog);
g_signal_connect (dialog->priv->query_model, "row-inserted", G_CALLBACK (entry_inserted_cb), dialog);
gtk_container_add (GTK_CONTAINER (dialog), GTK_WIDGET (gtk_builder_get_object (builder, "import-dialog")));
gtk_widget_show_all (GTK_WIDGET (dialog));
g_object_unref (builder);
}
/*
* Utility function for when there are more than one albums
* available. Borrowed from Sound Juicer.
*/
static AlbumDetails *
multiple_album_dialog (GList *albums, RBAudioCdSource *source)
{
GtkWidget *dialog;
GtkWidget *albums_listview;
GtkListStore *albums_store;
GtkTreeSelection *selection;
AlbumDetails *album;
GtkTreeIter iter;
int response;
GtkBuilder *builder;
GtkTreeViewColumn *column;
GtkCellRenderer *text_renderer;
RBPlugin *plugin;
char *builder_file;
gdk_threads_enter ();
g_object_get (source, "plugin", &plugin, NULL);
g_assert (plugin != NULL);
/* create dialog */
builder_file = rb_plugin_find_file (plugin, "multiple-album.ui");
g_object_unref (plugin);
if (builder_file == NULL) {
g_warning ("couldn't find multiple-album.ui");
return NULL;
}
builder = rb_builder_load (builder_file, NULL);
g_free (builder_file);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "multiple_dialog"));
g_assert (dialog != NULL);
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (source))));
albums_listview = GTK_WIDGET (gtk_builder_get_object (builder, "albums_listview"));
g_signal_connect (albums_listview, "row-activated", G_CALLBACK (album_row_activated), dialog);
/* add columns */
text_renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Title"),
text_renderer,
"text", 0,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (albums_listview), column);
column = gtk_tree_view_column_new_with_attributes (_("Artist"),
text_renderer,
"text", 1,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (albums_listview), column);
/* create model for the tree view */
albums_store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
gtk_tree_view_set_model (GTK_TREE_VIEW (albums_listview), GTK_TREE_MODEL (albums_store));
for (; albums ; albums = g_list_next (albums)) {
GtkTreeIter iter;
AlbumDetails *album = (AlbumDetails*)(albums->data);
gtk_list_store_append (albums_store, &iter);
gtk_list_store_set (albums_store, &iter,
0, album->title,
1, album->artist,
2, album,
-1);
}
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (albums_listview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
/* select the first row */
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (albums_store), &iter);
gtk_tree_selection_select_iter (selection, &iter);
gtk_widget_grab_focus (albums_listview);
gtk_widget_show_all (dialog);
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (dialog);
if (response == GTK_RESPONSE_DELETE_EVENT) {
album = NULL;
} else {
gtk_tree_selection_get_selected (selection, NULL, &iter);
gtk_tree_model_get (GTK_TREE_MODEL (albums_store), &iter, 2, &album, -1);
}
gtk_widget_destroy (GTK_WIDGET (dialog));
gdk_threads_leave ();
g_object_unref (builder);
return album;
}
static void
rb_audiocd_source_constructed (GObject *object)
{
RBAudioCdSourcePrivate *priv;
RBAudioCdSource *source;
RBEntryView *entry_view;
GtkCellRenderer *renderer;
GtkTreeViewColumn *extract;
GtkWidget *widget;
GtkAction *action;
RhythmDB *db;
RBPlugin *plugin;
RBShell *shell;
char *ui_file;
int toggle_width;
RB_CHAIN_GOBJECT_METHOD (rb_audiocd_source_parent_class, constructed, object);
source = RB_AUDIOCD_SOURCE (object);
priv = AUDIOCD_SOURCE_GET_PRIVATE (source);
g_object_set (G_OBJECT (source), "name", "Unknown Audio", NULL);
g_object_get (source, "shell", &shell, NULL);
priv->action_group = _rb_source_register_action_group (RB_SOURCE (source),
"AudioCdActions",
NULL, 0, NULL);
_rb_action_group_add_source_actions (priv->action_group,
G_OBJECT (shell),
rb_audiocd_source_actions,
G_N_ELEMENTS (rb_audiocd_source_actions));
g_object_unref (shell);
action = gtk_action_group_get_action (priv->action_group,
"AudioCdCopyTracks");
/* Translators: this is the toolbar button label
for Copy to Library action. */
g_object_set (action, "short-label", _("Extract"), NULL);
#if !defined(HAVE_SJ_METADATA_GETTER)
action = gtk_action_group_get_action (priv->action_group, "AudioCdSourceReloadMetadata");
g_object_set (action, "visible", FALSE, NULL);
#endif
/* we want audio cds to sort by track# by default */
entry_view = rb_source_get_entry_view (RB_SOURCE (source));
rb_entry_view_set_sorting_order (entry_view, "Track", GTK_SORT_ASCENDING);
/* enable in-place editing for titles, artists, and genres */
rb_entry_view_set_column_editable (entry_view, RB_ENTRY_VIEW_COL_TITLE, TRUE);
rb_entry_view_set_column_editable (entry_view, RB_ENTRY_VIEW_COL_ARTIST, TRUE);
rb_entry_view_set_column_editable (entry_view, RB_ENTRY_VIEW_COL_GENRE, TRUE);
/* create the 'extract' column */
renderer = gtk_cell_renderer_toggle_new ();
extract = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (extract, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func (extract,
renderer,
(GtkTreeCellDataFunc) extract_cell_data_func,
source,
NULL);
gtk_tree_view_column_set_clickable (extract, TRUE);
widget = gtk_check_button_new ();
g_object_set (widget, "active", TRUE, NULL);
gtk_widget_show_all (widget);
g_signal_connect_object (extract, "clicked", G_CALLBACK (extract_column_clicked_cb), source, 0);
gtk_tree_view_column_set_widget (extract, widget);
g_signal_connect_object (renderer, "toggled", G_CALLBACK (extract_toggled_cb), source, 0);
/* set column width */
gtk_cell_renderer_get_size (renderer, GTK_WIDGET (entry_view), NULL, NULL, NULL, &toggle_width, NULL);
gtk_tree_view_column_set_sizing (extract, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (extract, toggle_width + 5);
rb_entry_view_insert_column_custom (entry_view, extract, "", "Extract", NULL, NULL, NULL, 1);
gtk_widget_set_tooltip_text (gtk_tree_view_column_get_widget (extract),
_("Select tracks to be extracted"));
/* hide the 'album' column */
gtk_tree_view_column_set_visible (rb_entry_view_get_column (entry_view, RB_ENTRY_VIEW_COL_ALBUM), FALSE);
/* handle extra metadata requests for album artist and album artist sortname */
db = get_db_for_source (source);
g_signal_connect_object (G_OBJECT (db), "entry-extra-metadata-request::" RHYTHMDB_PROP_ALBUM_ARTIST,
G_CALLBACK (album_artist_metadata_request_cb), source, 0);
g_signal_connect_object (G_OBJECT (db), "entry-extra-metadata-request::" RHYTHMDB_PROP_ALBUM_ARTIST_SORTNAME,
G_CALLBACK (album_artist_sortname_metadata_request_cb), source, 0);
g_signal_connect_object (G_OBJECT (db), "entry-extra-metadata-gather",
G_CALLBACK (metadata_gather_cb), source, 0);
g_object_unref (db);
/* set up the album info widgets */
g_object_get (source, "plugin", &plugin, NULL);
ui_file = rb_plugin_find_file (plugin, "album-info.ui");
g_object_unref (plugin);
if (ui_file == NULL) {
g_warning ("couldn't find album-info.ui");
} else {
RBAudioCdSourcePrivate *priv;
GtkWidget *table;
GtkBuilder *builder;
#if defined(HAVE_SJ_METADATA_GETTER) && GTK_CHECK_VERSION(2,17,6)
GtkWidget *box;
char *message;
#endif
priv = AUDIOCD_SOURCE_GET_PRIVATE (source);
builder = rb_builder_load (ui_file, NULL);
g_free (ui_file);
table = GTK_WIDGET (gtk_builder_get_object (builder, "album_info"));
g_assert (table != NULL);
#if defined(HAVE_SJ_METADATA_GETTER) && GTK_CHECK_VERSION(2,17,6)
/* Info bar for non-Musicbrainz data */
priv->info_bar = gtk_info_bar_new_with_buttons (_("S_ubmit Album"), GTK_RESPONSE_OK,
_("Hide"), GTK_RESPONSE_CANCEL,
NULL);
message = g_strdup_printf ("<b>%s</b>\n%s", _("Could not find this album on MusicBrainz."),
_("You can improve the MusicBrainz database by adding this album."));
priv->info_bar_label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (priv->info_bar_label), message);
gtk_label_set_justify (GTK_LABEL (priv->info_bar_label), GTK_JUSTIFY_LEFT);
g_free (message);
box = gtk_info_bar_get_content_area (GTK_INFO_BAR (priv->info_bar));
gtk_container_add (GTK_CONTAINER (box), priv->info_bar_label);
gtk_widget_show_all (box);
gtk_widget_set_no_show_all (priv->info_bar, TRUE);
g_signal_connect (G_OBJECT (priv->info_bar), "response",
G_CALLBACK (info_bar_response_cb), source);
gtk_table_attach_defaults (GTK_TABLE (table), priv->info_bar, 0, 2, 0, 1);
#endif
priv->artist_entry = GTK_WIDGET (gtk_builder_get_object (builder, "artist_entry"));
priv->artist_sort_entry = GTK_WIDGET (gtk_builder_get_object (builder, "artist_sort_entry"));
priv->album_entry = GTK_WIDGET (gtk_builder_get_object (builder, "album_entry"));
priv->year_entry = GTK_WIDGET (gtk_builder_get_object (builder, "year_entry"));
priv->genre_entry = GTK_WIDGET (gtk_builder_get_object (builder, "genre_entry"));
priv->disc_number_entry = GTK_WIDGET (gtk_builder_get_object (builder, "disc_number_entry"));
g_signal_connect_object (priv->album_entry, "focus-out-event", G_CALLBACK (update_album_cb), source, 0);
g_signal_connect_object (priv->genre_entry, "focus-out-event", G_CALLBACK (update_genre_cb), source, 0);
g_signal_connect_object (priv->year_entry, "focus-out-event", G_CALLBACK (update_year_cb), source, 0);
g_signal_connect_object (priv->disc_number_entry, "focus-out-event", G_CALLBACK (update_disc_number_cb), source, 0);
gtk_box_pack_start (GTK_BOX (priv->box), table, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (priv->box), table, 0);
g_object_unref (builder);
}
g_object_ref (G_OBJECT (source));
g_thread_create ((GThreadFunc)rb_audiocd_load_songs, source, FALSE, NULL);
}
static void
rb_playlist_source_constructed (GObject *object)
{
GObject *shell_player;
RBPlaylistSource *source;
RBShell *shell;
RhythmDB *db;
RhythmDBQueryModel *query_model;
GtkBuilder *builder;
GSettings *settings;
RB_CHAIN_GOBJECT_METHOD (rb_playlist_source_parent_class, constructed, object);
source = RB_PLAYLIST_SOURCE (object);
g_object_get (source, "shell", &shell, NULL);
g_object_get (shell,
"db", &db,
"shell-player", &shell_player,
NULL);
rb_playlist_source_set_db (source, db);
g_object_unref (db);
g_object_unref (shell);
/* store playlist settings using the memory backend
* this means the settings path doesn't have to be consistent,
* it just has to be unique, so the address of the source object works.
* for local playlists, we write the settings into the playlist file on disk
* to make them persistent.
*/
g_object_get (source, "settings", &settings, NULL);
if (settings == NULL) {
char *path;
path = g_strdup_printf ("/org/gnome/rhythmbox/playlist/%p/", source);
settings = g_settings_new_with_backend_and_path ("org.gnome.rhythmbox.source",
playlist_settings_backend,
path);
g_free (path);
g_object_set (source, "settings", settings, NULL);
}
g_signal_connect (settings, "changed", G_CALLBACK (playlist_settings_changed_cb), source);
g_object_unref (settings);
builder = rb_builder_load ("playlist-popup.ui", NULL);
source->priv->popup = G_MENU (gtk_builder_get_object (builder, "playlist-popup"));
rb_application_link_shared_menus (RB_APPLICATION (g_application_get_default ()), source->priv->popup);
g_object_ref (source->priv->popup);
g_object_unref (builder);
source->priv->entries = g_hash_table_new_full (rb_refstring_hash, rb_refstring_equal,
(GDestroyNotify)rb_refstring_unref, NULL);
source->priv->songs = rb_entry_view_new (source->priv->db,
shell_player,
TRUE, TRUE);
g_object_unref (shell_player);
g_signal_connect_object (source->priv->songs,
"notify::sort-order",
G_CALLBACK (rb_playlist_source_songs_sort_order_changed_cb),
source, 0);
query_model = rhythmdb_query_model_new_empty (source->priv->db);
rb_playlist_source_set_query_model (source, query_model);
g_object_unref (query_model);
{
const char *title = "";
const char *strings[3] = {0};
GtkTreeViewColumn *column = gtk_tree_view_column_new ();
GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer,
"style", PANGO_STYLE_OBLIQUE,
"weight", PANGO_WEIGHT_LIGHT,
"xalign", 1.0,
NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
strings[0] = title;
strings[1] = "9999";
rb_entry_view_set_fixed_column_width (source->priv->songs, column, renderer,
strings);
gtk_tree_view_column_set_cell_data_func (column, renderer,
(GtkTreeCellDataFunc)
rb_playlist_source_track_cell_data_func,
source, NULL);
rb_entry_view_insert_column_custom (source->priv->songs, column, title,
"PlaylistTrack", NULL, 0, NULL, 0);
}
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_TITLE, TRUE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_GENRE, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_ARTIST, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_COMPOSER, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_ALBUM, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_YEAR, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_DURATION, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_QUALITY, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_RATING, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_PLAY_COUNT, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_COMMENT, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_LOCATION, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_LAST_PLAYED, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_FIRST_SEEN, FALSE);
rb_entry_view_append_column (source->priv->songs, RB_ENTRY_VIEW_COL_BPM, FALSE);
rb_entry_view_set_columns_clickable (source->priv->songs, FALSE);
rb_playlist_source_setup_entry_view (source, source->priv->songs);
gtk_container_add (GTK_CONTAINER (source), GTK_WIDGET (source->priv->songs));
gtk_widget_show_all (GTK_WIDGET (source));
}
static void
impl_show_properties (RBMediaPlayerSource *source, GtkWidget *info_box, GtkWidget *notebook)
{
RBGenericPlayerSourcePrivate *priv = GET_PRIVATE (source);
RhythmDBQueryModel *model;
GtkBuilder *builder;
GtkWidget *widget;
GString *str;
char *device_name;
char *builder_file;
char *vendor_name;
char *model_name;
char *serial_id;
GObject *plugin;
char *text;
GList *output_formats;
GList *t;
g_object_get (source, "plugin", &plugin, NULL);
builder_file = rb_find_plugin_data_file (plugin, "generic-player-info.ui");
g_object_unref (plugin);
if (builder_file == NULL) {
g_warning ("Couldn't find generic-player-info.ui");
return;
}
builder = rb_builder_load (builder_file, NULL);
g_free (builder_file);
if (builder == NULL) {
rb_debug ("Couldn't load generic-player-info.ui");
return;
}
/* 'basic' tab stuff */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "generic-player-basic-info"));
gtk_box_pack_start (GTK_BOX (info_box), widget, TRUE, TRUE, 0);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry-device-name"));
g_object_get (source, "name", &device_name, NULL);
gtk_entry_set_text (GTK_ENTRY (widget), device_name);
g_free (device_name);
/* don't think we can support this..
g_signal_connect (widget, "focus-out-event",
(GCallback)rb_mtp_source_name_changed_cb, source);
*/
g_object_get (source, "base-query-model", &model, NULL);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "num-tracks"));
text = g_strdup_printf ("%d", gtk_tree_model_iter_n_children (GTK_TREE_MODEL (model), NULL));
gtk_label_set_text (GTK_LABEL (widget), text);
g_free (text);
g_object_unref (model);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "num-playlists"));
text = g_strdup_printf ("%d", g_list_length (priv->playlists));
gtk_label_set_text (GTK_LABEL (widget), text);
g_free (text);
/* 'advanced' tab stuff */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "generic-player-advanced-tab"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), widget, gtk_label_new (_("Advanced")));
g_object_get (priv->device_info,
"model", &model_name,
"vendor", &vendor_name,
"serial", &serial_id,
NULL);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "label-model-value"));
gtk_label_set_text (GTK_LABEL (widget), model_name);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "label-manufacturer-value"));
gtk_label_set_text (GTK_LABEL (widget), vendor_name);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "label-serial-number-value"));
gtk_label_set_text (GTK_LABEL (widget), serial_id);
g_free (model_name);
g_free (vendor_name);
g_free (serial_id);
str = g_string_new ("");
output_formats = rb_transfer_target_get_format_descriptions (RB_TRANSFER_TARGET (source));
for (t = output_formats; t != NULL; t = t->next) {
if (t != output_formats) {
g_string_append (str, "\n");
}
g_string_append (str, t->data);
}
rb_list_deep_free (output_formats);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "audio-format-list"));
gtk_label_set_text (GTK_LABEL (widget), str->str);
g_string_free (str, TRUE);
g_object_unref (builder);
}
