static void impl_constructed (GObject *object) { RBVisualizerPage *page; ClutterInitError err; GstElement *colorspace; GstElement *realsink; GstElement *capsfilter; GstCaps *caps; GstPad *pad; RB_CHAIN_GOBJECT_METHOD (rb_visualizer_page_parent_class, constructed, object); page = RB_VISUALIZER_PAGE (object); err = gtk_clutter_init (NULL, NULL); if (err != CLUTTER_INIT_SUCCESS) { /* maybe do something more sensible here. not sure if there are any user-recoverable * conditions that would cause clutter init to fail, though, so it may not be worth it. * as it is, we just won't add the page to the page tree. */ g_warning ("Unable to display visual effects due to Clutter init failure"); return; } page->texture = clutter_texture_new (); clutter_texture_set_sync_size (CLUTTER_TEXTURE (page->texture), TRUE); clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (page->texture), TRUE); page->sink = gst_bin_new (NULL); g_object_ref (page->sink); /* actual sink */ realsink = gst_element_factory_make ("cluttersink", NULL); g_object_set (realsink, "texture", page->texture, NULL); colorspace = gst_element_factory_make ("ffmpegcolorspace", NULL); /* capsfilter to force rgb format (without this we end up using ayuv) */ capsfilter = gst_element_factory_make ("capsfilter", NULL); caps = gst_caps_from_string ("video/x-raw-rgb,bpp=(int)24,depth=(int)24," "endianness=(int)4321,red_mask=(int)16711680," "green_mask=(int)65280,blue_mask=(int)255"); g_object_set (capsfilter, "caps", caps, NULL); gst_caps_unref (caps); gst_bin_add_many (GST_BIN (page->sink), colorspace, capsfilter, realsink, NULL); gst_element_link (colorspace, capsfilter); gst_element_link (capsfilter, realsink); pad = gst_element_get_static_pad (colorspace, "sink"); gst_element_add_pad (page->sink, gst_ghost_pad_new ("sink", pad)); gst_object_unref (pad); g_signal_connect_object (page->fullscreen_action, "toggled", G_CALLBACK (toggle_fullscreen_cb), page, 0); }
static void rb_audioscrobbler_account_constructed (GObject *object) { RBAudioscrobblerAccount *account; RB_CHAIN_GOBJECT_METHOD (rb_audioscrobbler_account_parent_class, constructed, object); account = RB_AUDIOSCROBBLER_ACCOUNT (object); load_session_settings (account); }
static void rb_media_player_source_constructed (GObject *object) { RBMediaPlayerSourcePrivate *priv = MEDIA_PLAYER_SOURCE_GET_PRIVATE (object); RBShell *shell; RB_CHAIN_GOBJECT_METHOD (rb_media_player_source_parent_class, constructed, object); g_object_get (object, "shell", &shell, NULL); rb_media_player_source_init_actions (shell); g_object_unref (shell); priv->sync_action = gtk_action_group_get_action (action_group, "MediaPlayerSourceSync"); }
static void impl_constructed (GObject *object) { RBAndroidSource *source; RBAndroidSourcePrivate *priv; RhythmDBEntryType *entry_type; RBShell *shell; char **output_formats; RB_CHAIN_GOBJECT_METHOD (rb_android_source_parent_class, constructed, object); source = RB_ANDROID_SOURCE (object); priv = GET_PRIVATE (source); rb_device_source_set_display_details (RB_DEVICE_SOURCE (source)); g_object_get (source, "shell", &shell, "entry-type", &entry_type, NULL); g_object_get (shell, "db", &priv->db, NULL); priv->import_errors = rb_import_errors_source_new (shell, priv->error_type, entry_type, priv->ignore_type); g_object_get (priv->device_info, "output-formats", &output_formats, NULL); if (output_formats != NULL) { GstEncodingTarget *target; int i; target = gst_encoding_target_new ("android-device", "device", "", NULL); for (i = 0; output_formats[i] != NULL; i++) { const char *media_type = rb_gst_mime_type_to_media_type (output_formats[i]); if (media_type != NULL) { GstEncodingProfile *profile; profile = rb_gst_get_encoding_profile (media_type); if (profile != NULL) { gst_encoding_target_add_profile (target, profile); } } } g_object_set (source, "encoding-target", target, NULL); } g_strfreev (output_formats); g_object_unref (shell); }
static void impl_constructed (GObject *object) { RBButtonBar *bar; RB_CHAIN_GOBJECT_METHOD (rb_button_bar_parent_class, constructed, object); bar = RB_BUTTON_BAR (object); bar->priv->size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); bar->priv->handlers = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_object_unref); build_button_bar (bar); }
static void impl_constructed (GObject *object) { RBDisplayPageMenu *menu; RB_CHAIN_GOBJECT_METHOD (rb_display_page_menu_parent_class, constructed, object); menu = RB_DISPLAY_PAGE_MENU (object); g_signal_connect (menu->priv->real_model, "row-inserted", G_CALLBACK (row_inserted_cb), menu); g_signal_connect (menu->priv->real_model, "row-deleted", G_CALLBACK (row_deleted_cb), menu); g_signal_connect (menu->priv->real_model, "row-changed", G_CALLBACK (row_changed_cb), menu); g_signal_connect (menu->priv->real_model, "rows-reordered", G_CALLBACK (rows_reordered_cb), menu); rebuild_menu (menu); }
static void impl_constructed (GObject *object) { RBDisplayPageMenu *menu; GtkTreeModel *real_model; RB_CHAIN_GOBJECT_METHOD (rb_display_page_menu_parent_class, constructed, object); menu = RB_DISPLAY_PAGE_MENU (object); real_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (menu->priv->model)); g_signal_connect (real_model, "row-inserted", G_CALLBACK (row_inserted_cb), menu); g_signal_connect (real_model, "row-deleted", G_CALLBACK (row_deleted_cb), menu); g_signal_connect (real_model, "row-changed", G_CALLBACK (row_changed_cb), menu); g_signal_connect (real_model, "rows-reordered", G_CALLBACK (rows_reordered_cb), menu); rebuild_menu (menu); }
static void impl_constructed (GObject *object) { RBPodcastMainSource *source; RBPodcastManager *podcast_mgr; GdkPixbuf *pixbuf; gint size; RB_CHAIN_GOBJECT_METHOD (rb_podcast_main_source_parent_class, constructed, object); source = RB_PODCAST_MAIN_SOURCE (object); g_object_get (source, "podcast-manager", &podcast_mgr, NULL); g_signal_connect_object (podcast_mgr, "start_download", G_CALLBACK (start_download_cb), source, 0); g_signal_connect_object (podcast_mgr, "finish_download", G_CALLBACK (finish_download_cb), source, 0); g_signal_connect_object (podcast_mgr, "feed_updates_available", G_CALLBACK (feed_updates_available_cb), source, 0); g_signal_connect_object (podcast_mgr, "process_error", G_CALLBACK (feed_error_cb), source, 0); gtk_icon_size_lookup (RB_SOURCE_ICON_SIZE, &size, NULL); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), RB_STOCK_PODCAST, size, 0, NULL); if (pixbuf != NULL) { rb_source_set_pixbuf (RB_SOURCE (source), pixbuf); g_object_unref (pixbuf); } }
static void rb_removable_media_manager_constructed (GObject *object) { RBRemovableMediaManager *mgr = RB_REMOVABLE_MEDIA_MANAGER (object); RBRemovableMediaManagerPrivate *priv = GET_PRIVATE (mgr); GApplication *app; GActionEntry actions[] = { { "check-devices", check_devices_action_cb }, { "removable-media-eject", eject_action_cb } }; RB_CHAIN_GOBJECT_METHOD (rb_removable_media_manager_parent_class, constructed, object); app = g_application_get_default (); g_action_map_add_action_entries (G_ACTION_MAP (app), actions, G_N_ELEMENTS (actions), mgr); priv->page_changed_id = g_signal_connect (priv->shell, "notify::selected-page", G_CALLBACK (page_changed_cb), mgr); }
static void rb_mtp_source_constructed (GObject *object) { RBMtpSource *source; RBEntryView *tracks; RBShell *shell; RBShellPlayer *shell_player; GObject *player_backend; RB_CHAIN_GOBJECT_METHOD (rb_mtp_source_parent_class, constructed, object); source = RB_MTP_SOURCE (object); tracks = rb_source_get_entry_view (RB_SOURCE (source)); rb_entry_view_append_column (tracks, RB_ENTRY_VIEW_COL_RATING, FALSE); rb_entry_view_append_column (tracks, RB_ENTRY_VIEW_COL_LAST_PLAYED, FALSE); /* the source element needs our cooperation */ g_object_get (source, "shell", &shell, NULL); g_object_get (shell, "shell-player", &shell_player, NULL); g_object_get (shell_player, "player", &player_backend, NULL); g_object_unref (shell_player); g_signal_connect_object (player_backend, "prepare-source", G_CALLBACK (prepare_player_source_cb), source, 0); g_object_unref (player_backend); g_object_unref (shell); g_signal_connect_object (rb_encoder_factory_get (), "prepare-source", G_CALLBACK (prepare_encoder_source_cb), source, 0); g_signal_connect_object (rb_encoder_factory_get (), "prepare-sink", G_CALLBACK (prepare_encoder_sink_cb), source, 0); rb_display_page_set_icon_name (RB_DISPLAY_PAGE (source), "multimedia-player-symbolic"); }
static void rb_library_browser_constructed (GObject *object) { RBLibraryBrowser *browser; RBLibraryBrowserPrivate *priv; int i; RB_CHAIN_GOBJECT_METHOD (rb_library_browser_parent_class, constructed, object); browser = RB_LIBRARY_BROWSER (object); priv = RB_LIBRARY_BROWSER_GET_PRIVATE (browser); for (i = 0; i < num_browser_properties; i++) { RBPropertyView *view; view = rb_property_view_new (priv->db, browser_properties[i].type, _(browser_properties[i].name)); g_hash_table_insert (priv->property_views, (gpointer)(browser_properties[i].type), view); rb_property_view_set_selection_mode (view, GTK_SELECTION_MULTIPLE); g_signal_connect_object (G_OBJECT (view), "properties-selected", G_CALLBACK (view_property_selected_cb), browser, 0); g_signal_connect_object (G_OBJECT (view), "property-selection-reset", G_CALLBACK (view_selection_reset_cb), browser, 0); gtk_widget_show_all (GTK_WIDGET (view)); gtk_widget_set_no_show_all (GTK_WIDGET (view), TRUE); gtk_box_pack_start (GTK_BOX (browser), GTK_WIDGET (view), TRUE, TRUE, 0); } update_browser_views_visibility (browser); priv->browser_view_notify_id = eel_gconf_notification_add (CONF_UI_BROWSER_VIEWS, (GConfClientNotifyFunc) rb_library_browser_views_changed, browser); }
static void rb_media_player_source_constructed (GObject *object) { RBMediaPlayerSourcePrivate *priv = MEDIA_PLAYER_SOURCE_GET_PRIVATE (object); RBShell *shell; GApplication *app; GActionEntry actions[] = { { "media-player-sync", sync_action_cb }, { "media-player-properties", properties_action_cb } }; RB_CHAIN_GOBJECT_METHOD (rb_media_player_source_parent_class, constructed, object); app = g_application_get_default (); g_object_get (object, "shell", &shell, NULL); _rb_add_display_page_actions (G_ACTION_MAP (app), G_OBJECT (shell), actions, G_N_ELEMENTS (actions)); g_object_unref (shell); priv->sync_action = g_action_map_lookup_action (G_ACTION_MAP (app), "media-player-sync"); priv->properties_action = g_action_map_lookup_action (G_ACTION_MAP (app), "media-player-properties"); g_signal_connect (object, "notify::load-status", G_CALLBACK (load_status_changed_cb), NULL); update_actions (RB_MEDIA_PLAYER_SOURCE (object)); }
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_constructed (GObject *object) { RBObjectPropertyEditor *editor; GObjectClass *klass; int i; int row; RB_CHAIN_GOBJECT_METHOD (rb_object_property_editor_parent_class, constructed, object); editor = RB_OBJECT_PROPERTY_EDITOR (object); klass = G_OBJECT_GET_CLASS (editor->priv->object); editor->priv->notify_id = g_signal_connect (editor->priv->object, "notify", G_CALLBACK (notify_cb), editor); row = 0; for (i = 0; editor->priv->properties[i] != NULL; i++) { GParamSpec *pspec; GtkWidget *label; GtkWidget *control; GType prop_type; pspec = g_object_class_find_property (klass, editor->priv->properties[i]); if (pspec == NULL) { g_warning ("couldn't find property %s on object %s", editor->priv->properties[i], G_OBJECT_CLASS_NAME (klass)); continue; } prop_type = G_PARAM_SPEC_TYPE (pspec); if (prop_type == G_TYPE_PARAM_BOOLEAN) { control = create_boolean_editor (editor, editor->priv->properties[i], pspec); } else if (prop_type == G_TYPE_PARAM_ENUM) { control = create_enum_editor (editor, editor->priv->properties[i], pspec); } else if (prop_type == G_TYPE_PARAM_INT) { control = create_int_editor (editor, editor->priv->properties[i], pspec); } else if (prop_type == G_TYPE_PARAM_FLOAT) { control = create_float_editor (editor, editor->priv->properties[i], pspec); } else if (prop_type == G_TYPE_PARAM_DOUBLE) { control = create_double_editor (editor, editor->priv->properties[i], pspec); } else { /* can't do this */ g_warning ("don't know how to edit %s", g_type_name (prop_type)); continue; } g_signal_connect (control, "focus-out-event", G_CALLBACK (focus_out_cb), editor); gtk_widget_set_hexpand (control, TRUE); label = gtk_label_new (g_param_spec_get_nick (pspec)); gtk_widget_set_tooltip_text (label, g_param_spec_get_blurb (pspec)); gtk_grid_attach (GTK_GRID (editor), label, 0, row, 1, 1); gtk_grid_attach (GTK_GRID (editor), control, 1, row, 1, 1); row++; } }
static void rb_iradio_source_constructed (GObject *object) { RBIRadioSource *source; RBShell *shell; GtkAction *action; GSettings *settings; GtkUIManager *ui_manager; GtkWidget *grid; GtkWidget *paned; RBSourceToolbar *toolbar; gint size; GdkPixbuf *pixbuf; RB_CHAIN_GOBJECT_METHOD (rb_iradio_source_parent_class, constructed, object); source = RB_IRADIO_SOURCE (object); paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); g_object_get (source, "shell", &shell, NULL); g_object_get (shell, "db", &source->priv->db, "shell-player", &source->priv->player, "ui-manager", &ui_manager, NULL); g_object_unref (shell); gtk_icon_size_lookup (RB_SOURCE_ICON_SIZE, &size, NULL); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), IRADIO_SOURCE_ICON, size, 0, NULL); g_object_set (source, "pixbuf", pixbuf, NULL); if (pixbuf != NULL) { g_object_unref (pixbuf); } settings = g_settings_new ("org.gnome.rhythmbox.plugins.iradio"); if (g_settings_get_boolean (settings, "initial-stations-loaded") == FALSE) { GObject *plugin; char *file; g_object_get (source, "plugin", &plugin, NULL); file = rb_find_plugin_data_file (plugin, "iradio-initial.xspf"); if (file != NULL) { char *uri = g_filename_to_uri (file, NULL, NULL); if (uri != NULL) { rb_iradio_source_add_from_playlist (source, uri); g_free (uri); g_settings_set_boolean (settings, "initial-stations-loaded", TRUE); } } g_free (file); g_object_unref (plugin); } source->priv->action_group = _rb_display_page_register_action_group (RB_DISPLAY_PAGE (source), "IRadioActions", rb_iradio_source_actions, G_N_ELEMENTS (rb_iradio_source_actions), source); action = gtk_action_group_get_action (source->priv->action_group, "MusicNewInternetRadioStation"); /* Translators: this is the toolbar button label for New Internet Radio Station action. */ g_object_set (action, "short-label", C_("Radio", "Add"), NULL); /* set up stations view */ source->priv->stations = rb_entry_view_new (source->priv->db, G_OBJECT (source->priv->player), FALSE, FALSE); rb_entry_view_append_column (source->priv->stations, RB_ENTRY_VIEW_COL_TITLE, TRUE); rb_entry_view_append_column (source->priv->stations, RB_ENTRY_VIEW_COL_GENRE, FALSE); /* rb_entry_view_append_column (source->priv->stations, RB_ENTRY_VIEW_COL_QUALITY, FALSE); */ rb_entry_view_append_column (source->priv->stations, RB_ENTRY_VIEW_COL_RATING, FALSE); /* rb_entry_view_append_column (source->priv->stations, RB_ENTRY_VIEW_COL_PLAY_COUNT, FALSE);*/ rb_entry_view_append_column (source->priv->stations, RB_ENTRY_VIEW_COL_LAST_PLAYED, FALSE); g_signal_connect_object (source->priv->stations, "notify::sort-order", G_CALLBACK (rb_iradio_source_songs_view_sort_order_changed_cb), source, 0); /* set up drag and drop for the song tree view. * we don't use RBEntryView's DnD support because it does too much. * we just want to be able to drop stations in to add them. */ g_signal_connect_object (source->priv->stations, "drag_data_received", G_CALLBACK (stations_view_drag_data_received_cb), source, 0); gtk_drag_dest_set (GTK_WIDGET (source->priv->stations), GTK_DEST_DEFAULT_ALL, stations_view_drag_types, 2, GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect_object (source->priv->stations, "show_popup", G_CALLBACK (rb_iradio_source_songs_show_popup_cb), source, 0); /* set up genre entry view */ source->priv->genres = rb_property_view_new (source->priv->db, RHYTHMDB_PROP_GENRE, _("Genre")); gtk_widget_show_all (GTK_WIDGET (source->priv->genres)); gtk_widget_set_no_show_all (GTK_WIDGET (source->priv->genres), TRUE); g_signal_connect_object (source->priv->genres, "property-selected", G_CALLBACK (genre_selected_cb), source, 0); g_signal_connect_object (source->priv->genres, "property-selection-reset", G_CALLBACK (genre_selection_reset_cb), source, 0); g_object_set (source->priv->genres, "vscrollbar_policy", GTK_POLICY_AUTOMATIC, NULL); gtk_paned_pack1 (GTK_PANED (paned), GTK_WIDGET (source->priv->genres), FALSE, FALSE); gtk_paned_pack2 (GTK_PANED (paned), GTK_WIDGET (source->priv->stations), TRUE, FALSE); /* set up toolbar */ toolbar = rb_source_toolbar_new (RB_SOURCE (source), ui_manager); rb_source_toolbar_add_search_entry (toolbar, NULL, _("Search your internet radio stations")); grid = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (grid), 6); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_widget_set_margin_top (GTK_WIDGET (grid), 6); gtk_grid_attach (GTK_GRID (grid), GTK_WIDGET (toolbar), 0, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), paned, 0, 1, 1, 1); gtk_container_add (GTK_CONTAINER (source), grid); rb_source_bind_settings (RB_SOURCE (source), GTK_WIDGET (source->priv->stations), paned, GTK_WIDGET (source->priv->genres)); gtk_widget_show_all (GTK_WIDGET (source)); g_signal_connect_object (source->priv->player, "playing-source-changed", G_CALLBACK (playing_source_changed_cb), source, 0); source->priv->default_search = rb_iradio_source_search_new (); rb_iradio_source_do_query (source); }
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); }
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 impl_constructed (GObject *object) { RBGenericPlayerSource *source; RBGenericPlayerSourcePrivate *priv; RhythmDBEntryType *entry_type; char **playlist_formats; char **output_formats; char *mount_name; RBShell *shell; GFile *root; GFileInfo *info; GError *error = NULL; RB_CHAIN_GOBJECT_METHOD (rb_generic_player_source_parent_class, constructed, object); source = RB_GENERIC_PLAYER_SOURCE (object); priv = GET_PRIVATE (source); rb_device_source_set_display_details (RB_DEVICE_SOURCE (source)); g_object_get (source, "shell", &shell, "entry-type", &entry_type, NULL); g_object_get (shell, "db", &priv->db, NULL); priv->import_errors = rb_import_errors_source_new (shell, priv->error_type, entry_type, priv->ignore_type); g_object_unref (shell); root = g_mount_get_root (priv->mount); mount_name = g_mount_get_name (priv->mount); info = g_file_query_filesystem_info (root, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY, NULL, &error); if (error != NULL) { rb_debug ("error querying filesystem info for %s: %s", mount_name, error->message); g_error_free (error); priv->read_only = FALSE; } else { priv->read_only = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY); g_object_unref (info); } g_free (mount_name); g_object_unref (root); g_object_get (priv->device_info, "playlist-formats", &playlist_formats, NULL); if (playlist_formats != NULL && g_strv_length (playlist_formats) > 0) { g_object_set (entry_type, "has-playlists", TRUE, NULL); } g_strfreev (playlist_formats); g_object_unref (entry_type); g_object_get (priv->device_info, "output-formats", &output_formats, NULL); if (output_formats != NULL) { GstEncodingTarget *target; int i; target = gst_encoding_target_new ("generic-player", "device", "", NULL); for (i = 0; output_formats[i] != NULL; i++) { const char *media_type = rb_gst_mime_type_to_media_type (output_formats[i]); if (media_type != NULL) { GstEncodingProfile *profile; profile = rb_gst_get_encoding_profile (media_type); if (profile != NULL) { gst_encoding_target_add_profile (target, profile); } } } g_object_set (source, "encoding-target", target, NULL); } g_strfreev (output_formats); }
static void rb_missing_files_source_constructed (GObject *object) { GObject *shell_player; RBMissingFilesSource *source; RBShell *shell; GPtrArray *query; RhythmDBQueryModel *model; RhythmDBEntryType *entry_type; RB_CHAIN_GOBJECT_METHOD (rb_missing_files_source_parent_class, constructed, object); source = RB_MISSING_FILES_SOURCE (object); g_object_get (source, "shell", &shell, "entry-type", &entry_type, NULL); g_object_get (shell, "db", &source->priv->db, NULL); shell_player = rb_shell_get_player (shell); g_object_unref (shell); /* construct real query */ query = rhythmdb_query_parse (source->priv->db, RHYTHMDB_QUERY_PROP_EQUALS, RHYTHMDB_PROP_TYPE, entry_type, RHYTHMDB_QUERY_PROP_EQUALS, RHYTHMDB_PROP_HIDDEN, TRUE, RHYTHMDB_QUERY_END); g_object_unref (entry_type); model = rhythmdb_query_model_new (source->priv->db, query, NULL, NULL, NULL, FALSE); rhythmdb_query_free (query); g_object_set (model, "show-hidden", TRUE, NULL); /* set up entry view */ source->priv->view = rb_entry_view_new (source->priv->db, shell_player, NULL, FALSE, FALSE); rb_entry_view_set_model (source->priv->view, model); rb_entry_view_append_column (source->priv->view, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE); rb_entry_view_append_column (source->priv->view, RB_ENTRY_VIEW_COL_TITLE, TRUE); /* rb_entry_view_append_column (source->priv->view, RB_ENTRY_VIEW_COL_GENRE, FALSE); */ rb_entry_view_append_column (source->priv->view, RB_ENTRY_VIEW_COL_ARTIST, FALSE); rb_entry_view_append_column (source->priv->view, RB_ENTRY_VIEW_COL_ALBUM, FALSE); rb_entry_view_append_column (source->priv->view, RB_ENTRY_VIEW_COL_LOCATION, TRUE); rb_entry_view_append_column (source->priv->view, RB_ENTRY_VIEW_COL_LAST_SEEN, TRUE); rb_entry_view_set_columns_clickable (source->priv->view, TRUE); gtk_container_add (GTK_CONTAINER (source), GTK_WIDGET (source->priv->view)); g_signal_connect_object (source->priv->view, "show_popup", G_CALLBACK (rb_missing_files_source_songs_show_popup_cb), source, 0); g_signal_connect_object (source->priv->view, "sort-order-changed", G_CALLBACK (rb_missing_files_source_songs_sort_order_changed_cb), source, 0); gtk_widget_show_all (GTK_WIDGET (source)); g_object_set (source, "query-model", model, NULL); g_object_unref (model); }
static void rb_static_playlist_source_constructed (GObject *object) { RBStaticPlaylistSource *source; RBStaticPlaylistSourcePrivate *priv; RBPlaylistSource *psource; RBEntryView *songs; RBShell *shell; RhythmDBEntryType *entry_type; RB_CHAIN_GOBJECT_METHOD (rb_static_playlist_source_parent_class, constructed, object); source = RB_STATIC_PLAYLIST_SOURCE (object); priv = RB_STATIC_PLAYLIST_SOURCE_GET_PRIVATE (source); psource = RB_PLAYLIST_SOURCE (source); priv->base_model = rb_playlist_source_get_query_model (RB_PLAYLIST_SOURCE (psource)); g_object_set (priv->base_model, "show-hidden", TRUE, NULL); g_object_ref (priv->base_model); g_signal_connect_object (priv->base_model, "filter-entry-drop", G_CALLBACK (rb_static_playlist_source_filter_entry_drop), source, 0); priv->paned = gtk_vpaned_new (); g_object_get (source, "shell", &shell, NULL); priv->action_group = _rb_display_page_register_action_group (RB_DISPLAY_PAGE (source), "StaticPlaylistActions", NULL, 0, shell); if (gtk_action_group_get_action (priv->action_group, rb_static_playlist_source_radio_actions[0].name) == NULL) { gtk_action_group_add_radio_actions (priv->action_group, rb_static_playlist_source_radio_actions, G_N_ELEMENTS (rb_static_playlist_source_radio_actions), 0, NULL, NULL); rb_source_search_basic_create_for_actions (priv->action_group, rb_static_playlist_source_radio_actions, G_N_ELEMENTS (rb_static_playlist_source_radio_actions)); } priv->default_search = rb_source_search_basic_new (RHYTHMDB_PROP_SEARCH_MATCH); g_object_unref (shell); g_object_get (source, "entry-type", &entry_type, NULL); priv->browser = rb_library_browser_new (rb_playlist_source_get_db (RB_PLAYLIST_SOURCE (source)), entry_type); if (entry_type != NULL) { g_object_unref (entry_type); } gtk_paned_pack1 (GTK_PANED (priv->paned), GTK_WIDGET (priv->browser), TRUE, FALSE); g_signal_connect_object (priv->browser, "notify::output-model", G_CALLBACK (rb_static_playlist_source_browser_changed_cb), source, 0); rb_library_browser_set_model (priv->browser, priv->base_model, FALSE); rb_static_playlist_source_do_query (source); /* reparent the entry view */ songs = rb_source_get_entry_view (RB_SOURCE (source)); g_object_ref (songs); gtk_container_remove (GTK_CONTAINER (source), GTK_WIDGET (songs)); gtk_paned_pack2 (GTK_PANED (priv->paned), GTK_WIDGET (songs), TRUE, FALSE); gtk_container_add (GTK_CONTAINER (source), priv->paned); rb_source_bind_settings (RB_SOURCE (source), GTK_WIDGET (songs), priv->paned, GTK_WIDGET (priv->browser)); g_object_unref (songs); /* watch these to find out when things are dropped into the entry view */ g_signal_connect_object (priv->base_model, "row-inserted", G_CALLBACK (rb_static_playlist_source_row_inserted), source, 0); g_signal_connect_object (priv->base_model, "non-entry-dropped", G_CALLBACK (rb_static_playlist_source_non_entry_dropped), source, 0); g_signal_connect_object (priv->base_model, "rows-reordered", G_CALLBACK (rb_static_playlist_source_rows_reordered), source, 0); gtk_widget_show_all (GTK_WIDGET (source)); }
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 rb_import_errors_source_constructed (GObject *object) { GObject *shell_player; RBImportErrorsSource *source; RBShell *shell; GPtrArray *query; RhythmDBQueryModel *model; RhythmDBEntryType *entry_type; GtkWidget *box; GtkWidget *label; RB_CHAIN_GOBJECT_METHOD (rb_import_errors_source_parent_class, constructed, object); source = RB_IMPORT_ERRORS_SOURCE (object); g_object_get (source, "shell", &shell, "entry-type", &entry_type, NULL); g_object_get (shell, "db", &source->priv->db, NULL); shell_player = rb_shell_get_player (shell); g_object_unref (shell); /* construct real query */ query = rhythmdb_query_parse (source->priv->db, RHYTHMDB_QUERY_PROP_EQUALS, RHYTHMDB_PROP_TYPE, entry_type, RHYTHMDB_QUERY_END); model = rhythmdb_query_model_new (source->priv->db, query, (GCompareDataFunc) rhythmdb_query_model_string_sort_func, GUINT_TO_POINTER (RHYTHMDB_PROP_LOCATION), NULL, FALSE); rhythmdb_query_free (query); /* set up entry view */ source->priv->view = rb_entry_view_new (source->priv->db, shell_player, NULL, FALSE, FALSE); rb_entry_view_set_model (source->priv->view, model); rb_entry_view_append_column (source->priv->view, RB_ENTRY_VIEW_COL_LOCATION, TRUE); rb_entry_view_append_column (source->priv->view, RB_ENTRY_VIEW_COL_ERROR, TRUE); g_signal_connect_object (source->priv->view, "show_popup", G_CALLBACK (rb_import_errors_source_songs_show_popup_cb), source, 0); g_object_set (source, "query-model", model, NULL); g_object_unref (model); /* set up query model for tracking missing plugin information */ query = rhythmdb_query_parse (source->priv->db, RHYTHMDB_QUERY_PROP_EQUALS, RHYTHMDB_PROP_TYPE, entry_type, RHYTHMDB_QUERY_PROP_NOT_EQUAL, RHYTHMDB_PROP_COMMENT, "", RHYTHMDB_QUERY_END); source->priv->missing_plugin_model = rhythmdb_query_model_new_empty (source->priv->db); rhythmdb_do_full_query_async_parsed (source->priv->db, RHYTHMDB_QUERY_RESULTS (source->priv->missing_plugin_model), query); rhythmdb_query_free (query); /* set up info bar for triggering codec installation */ source->priv->infobar = gtk_info_bar_new_with_buttons (_("Install Plugins"), GTK_RESPONSE_OK, NULL); g_signal_connect_object (source->priv->infobar, "response", G_CALLBACK (infobar_response_cb), source, 0); label = gtk_label_new (_("Additional GStreamer plugins are required to play some of these files.")); gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (source->priv->infobar))), label); g_object_unref (entry_type); box = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (box), GTK_WIDGET (source->priv->view), TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box), source->priv->infobar, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (source), box); gtk_widget_show_all (GTK_WIDGET (source)); gtk_widget_hide (source->priv->infobar); /* show the info bar when there are missing plugin entries */ g_signal_connect_object (source->priv->missing_plugin_model, "row-inserted", G_CALLBACK (missing_plugin_row_inserted_cb), source, 0); g_signal_connect_object (source->priv->missing_plugin_model, "row-deleted", G_CALLBACK (missing_plugin_row_deleted_cb), source, 0); }
static void rb_mtp_source_constructed (GObject *object) { RBMtpSource *source; RBMtpSourcePrivate *priv; RBEntryView *tracks; RBShell *shell; RBShellPlayer *shell_player; GObject *player_backend; GtkIconTheme *theme; GdkPixbuf *pixbuf; #if defined(HAVE_GUDEV) GMount *mount; #endif gint size; RB_CHAIN_GOBJECT_METHOD (rb_mtp_source_parent_class, constructed, object); source = RB_MTP_SOURCE (object); priv = MTP_SOURCE_GET_PRIVATE (source); /* try to open the device. if gvfs has mounted it, unmount it first */ #if defined(HAVE_GUDEV) mount = find_mount_for_device (priv->udev_device); if (mount != NULL) { rb_debug ("device is already mounted, waiting until activated"); g_mount_unmount_with_operation (mount, G_MOUNT_UNMOUNT_NONE, NULL, NULL, unmount_done_cb, g_object_ref (source)); /* mount gets unreffed in callback */ } else #endif open_device (source); tracks = rb_source_get_entry_view (RB_SOURCE (source)); rb_entry_view_append_column (tracks, RB_ENTRY_VIEW_COL_RATING, FALSE); rb_entry_view_append_column (tracks, RB_ENTRY_VIEW_COL_LAST_PLAYED, FALSE); /* the source element needs our cooperation */ g_object_get (source, "shell", &shell, NULL); shell_player = RB_SHELL_PLAYER (rb_shell_get_player (shell)); g_object_get (shell_player, "player", &player_backend, NULL); g_signal_connect_object (player_backend, "prepare-source", G_CALLBACK (prepare_player_source_cb), source, 0); g_object_unref (player_backend); g_object_unref (shell); g_signal_connect_object (rb_encoder_factory_get (), "prepare-source", G_CALLBACK (prepare_encoder_source_cb), source, 0); g_signal_connect_object (rb_encoder_factory_get (), "prepare-sink", G_CALLBACK (prepare_encoder_sink_cb), source, 0); /* icon */ theme = gtk_icon_theme_get_default (); gtk_icon_size_lookup (GTK_ICON_SIZE_LARGE_TOOLBAR, &size, NULL); pixbuf = gtk_icon_theme_load_icon (theme, "multimedia-player", size, 0, NULL); rb_source_set_pixbuf (RB_SOURCE (source), pixbuf); g_object_unref (pixbuf); if (priv->album_art_supported) { RhythmDB *db; db = get_db_for_source (source); g_signal_connect_object (db, "entry-extra-metadata-notify::rb:coverArt", G_CALLBACK (artwork_notify_cb), source, 0); g_object_unref (db); } }
static void impl_constructed (GObject *object) { RBGenericPlayerSource *source; RBGenericPlayerSourcePrivate *priv; RhythmDBEntryType *entry_type; char **playlist_formats; char **output_formats; char *mount_name; RBShell *shell; GFile *root; GFileInfo *info; GError *error = NULL; char *label; char *fullname; char *name; RB_CHAIN_GOBJECT_METHOD (rb_generic_player_source_parent_class, constructed, object); source = RB_GENERIC_PLAYER_SOURCE (object); priv = GET_PRIVATE (source); rb_device_source_set_display_details (RB_DEVICE_SOURCE (source)); g_object_get (source, "shell", &shell, "entry-type", &entry_type, "name", &name, NULL); g_object_get (shell, "db", &priv->db, NULL); priv->import_errors = rb_import_errors_source_new (shell, priv->error_type, entry_type, priv->ignore_type); priv->new_playlist_action_name = g_strdup_printf ("generic-player-%p-playlist-new", source); fullname = g_strdup_printf ("app.%s", priv->new_playlist_action_name); label = g_strdup_printf (_("New Playlist on %s"), name); rb_application_add_plugin_menu_item (RB_APPLICATION (g_application_get_default ()), "display-page-add-playlist", priv->new_playlist_action_name, g_menu_item_new (label, fullname)); g_free (fullname); g_free (label); g_free (name); root = g_mount_get_root (priv->mount); mount_name = g_mount_get_name (priv->mount); info = g_file_query_filesystem_info (root, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY, NULL, &error); if (error != NULL) { rb_debug ("error querying filesystem info for %s: %s", mount_name, error->message); g_error_free (error); priv->read_only = FALSE; } else { priv->read_only = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY); g_object_unref (info); } g_free (mount_name); g_object_unref (root); g_object_get (priv->device_info, "playlist-formats", &playlist_formats, NULL); if ((priv->read_only == FALSE) && playlist_formats != NULL && g_strv_length (playlist_formats) > 0) { RBDisplayPageModel *model; GMenu *playlist_menu; GMenuModel *playlists; priv->new_playlist_action = g_simple_action_new (priv->new_playlist_action_name, NULL); g_signal_connect (priv->new_playlist_action, "activate", G_CALLBACK (new_playlist_action_cb), source); g_action_map_add_action (G_ACTION_MAP (g_application_get_default ()), G_ACTION (priv->new_playlist_action)); g_object_get (shell, "display-page-model", &model, NULL); playlists = rb_display_page_menu_new (model, RB_DISPLAY_PAGE (source), RB_TYPE_GENERIC_PLAYER_PLAYLIST_SOURCE, "app.playlist-add-to"); g_object_unref (model); playlist_menu = g_menu_new (); g_menu_append (playlist_menu, _("Add to New Playlist"), priv->new_playlist_action_name); g_menu_append_section (playlist_menu, NULL, playlists); g_object_set (source, "playlist-menu", playlist_menu, NULL); } g_strfreev (playlist_formats); g_object_unref (entry_type); g_object_get (priv->device_info, "output-formats", &output_formats, NULL); if (output_formats != NULL) { GstEncodingTarget *target; int i; target = gst_encoding_target_new ("generic-player", "device", "", NULL); for (i = 0; output_formats[i] != NULL; i++) { const char *media_type = rb_gst_mime_type_to_media_type (output_formats[i]); if (media_type != NULL) { GstEncodingProfile *profile; profile = rb_gst_get_encoding_profile (media_type); if (profile != NULL) { gst_encoding_target_add_profile (target, profile); } } } g_object_set (source, "encoding-target", target, NULL); } g_strfreev (output_formats); g_object_unref (shell); }
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 rb_grilo_source_constructed (GObject *object) { RBGriloSource *source; RBShell *shell; RBShellPlayer *shell_player; const GList *source_keys; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkWidget *scrolled; GtkWidget *browserbox; GtkWidget *vbox; GtkWidget *mainbox; GtkAdjustment *adjustment; RB_CHAIN_GOBJECT_METHOD (rb_grilo_source_parent_class, constructed, object); source = RB_GRILO_SOURCE (object); g_object_get (source, "shell", &shell, NULL); g_object_get (shell, "db", &source->priv->db, "shell-player", &shell_player, NULL); g_object_unref (shell); g_object_get (source, "entry-type", &source->priv->entry_type, NULL); source->priv->entry_view = rb_entry_view_new (source->priv->db, G_OBJECT (shell_player), TRUE, FALSE); g_object_unref (shell_player); g_signal_connect (source->priv->entry_view, "notify::sort-order", G_CALLBACK (notify_sort_order_cb), source); source_keys = grl_source_supported_keys (source->priv->grilo_source); if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER)); } if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TITLE, TRUE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE)); } if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_GENRE, FALSE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE)); } if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ARTIST, FALSE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST)); } if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ALBUM, FALSE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM)); } /* if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DATE))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_YEAR, FALSE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DATE)); } */ if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_DURATION, FALSE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION)); } source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_CHILDCOUNT)); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_URL)); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_THUMBNAIL)); /* probably add an image column too? */ source->priv->browser_model = gtk_tree_store_new (4, GRL_TYPE_MEDIA, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT); source->priv->browser_view = gtk_tree_view_new (); gtk_tree_view_set_model (GTK_TREE_VIEW (source->priv->browser_view), GTK_TREE_MODEL (source->priv->browser_model)); column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_set_title (column, _("Browse")); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "text", 1); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column (GTK_TREE_VIEW (source->priv->browser_view), column); gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (source->priv->browser_view), TRUE); gtk_tree_view_set_expander_column (GTK_TREE_VIEW (source->priv->browser_view), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (source->priv->browser_view), TRUE); gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (source->priv->browser_view), TRUE); g_signal_connect (source->priv->browser_view, "row-expanded", G_CALLBACK (browser_row_expanded_cb), source); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (source->priv->browser_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /* should be multiple eventually */ g_signal_connect (selection, "changed", G_CALLBACK (browser_selection_changed_cb), source); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled)); g_signal_connect (adjustment, "changed", G_CALLBACK (scroll_adjust_changed_cb), source); g_signal_connect (adjustment, "value-changed", G_CALLBACK (scroll_adjust_value_changed_cb), source); browserbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); /* search bar (if the source supports searching) */ if (grl_source_supported_operations (source->priv->grilo_source) & GRL_OP_SEARCH) { source->priv->search_entry = rb_search_entry_new (FALSE); g_object_set (source->priv->search_entry, "explicit-mode", TRUE, NULL); g_signal_connect (source->priv->search_entry, "search", G_CALLBACK (search_cb), source); g_signal_connect (source->priv->search_entry, "activate", G_CALLBACK (search_cb), source); gtk_box_pack_start (GTK_BOX (browserbox), GTK_WIDGET (source->priv->search_entry), FALSE, FALSE, 6); } gtk_container_add (GTK_CONTAINER (scrolled), source->priv->browser_view); gtk_box_pack_start (GTK_BOX (browserbox), scrolled, TRUE, TRUE, 0); mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (source), mainbox, TRUE, TRUE, 0); /* info bar */ source->priv->info_bar_label = gtk_label_new (""); source->priv->info_bar = gtk_info_bar_new (); gtk_info_bar_set_message_type (GTK_INFO_BAR (source->priv->info_bar), GTK_MESSAGE_INFO); gtk_info_bar_add_button (GTK_INFO_BAR (source->priv->info_bar), _("Fetch more tracks"), GTK_RESPONSE_OK); gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (source->priv->info_bar))), source->priv->info_bar_label); gtk_widget_show (GTK_WIDGET (source->priv->info_bar_label)); gtk_widget_set_no_show_all (GTK_WIDGET (source->priv->info_bar), TRUE); g_signal_connect (source->priv->info_bar, "response", G_CALLBACK (fetch_more_cb), source); /* don't allow the browser to be hidden? */ source->priv->paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); rb_source_bind_settings (RB_SOURCE (source), GTK_WIDGET (source->priv->entry_view), source->priv->paned, NULL); gtk_paned_pack1 (GTK_PANED (source->priv->paned), browserbox, FALSE, FALSE); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (source->priv->entry_view), TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), source->priv->info_bar, FALSE, FALSE, 0); gtk_paned_pack2 (GTK_PANED (source->priv->paned), vbox, TRUE, FALSE); gtk_box_pack_start (GTK_BOX (mainbox), source->priv->paned, TRUE, TRUE, 0); gtk_widget_show_all (GTK_WIDGET (source)); }