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 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 ft_manager_build_ui (EmpathyFTManager *manager) { GtkBuilder *gui; GtkTreeView *view; GtkListStore *liststore; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; gchar *filename; EmpathyFTManagerPriv *priv = GET_PRIV (manager); filename = empathy_file_lookup ("empathy-ft-manager.ui", "src"); gui = tpaw_builder_get_file (filename, "ft_manager_dialog", &priv->window, "ft_list", &priv->treeview, "clear_button", &priv->clear_button, "open_button", &priv->open_button, "abort_button", &priv->abort_button, NULL); g_free (filename); tpaw_builder_connect (gui, manager, "ft_manager_dialog", "destroy", ft_manager_destroy_cb, "ft_manager_dialog", "response", ft_manager_response_cb, "ft_manager_dialog", "delete-event", ft_manager_delete_event_cb, "ft_manager_dialog", "key-press-event", ft_manager_key_press_event_cb, NULL); tpaw_builder_unref_and_keep_widget (gui, priv->window); /* Window geometry. */ empathy_geometry_bind (GTK_WINDOW (priv->window), "ft-manager"); /* Setup the tree view */ view = GTK_TREE_VIEW (priv->treeview); selection = gtk_tree_view_get_selection (view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); g_signal_connect (selection, "changed", G_CALLBACK (ft_manager_selection_changed), manager); g_signal_connect (view, "button-press-event", G_CALLBACK (ft_view_button_press_event_cb), manager); gtk_tree_view_set_headers_visible (view, TRUE); gtk_tree_view_set_enable_search (view, FALSE); /* Setup the model */ liststore = gtk_list_store_new (5, G_TYPE_INT, /* percent */ G_TYPE_ICON, /* icon */ G_TYPE_STRING, /* message */ G_TYPE_STRING, /* remaining */ G_TYPE_OBJECT); /* ft_handler */ gtk_tree_view_set_model (view, GTK_TREE_MODEL (liststore)); priv->model = GTK_TREE_MODEL (liststore); g_object_unref (liststore); /* Progress column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("%")); gtk_tree_view_column_set_sort_column_id (column, COL_PERCENT); gtk_tree_view_insert_column (view, column, -1); renderer = gtk_cell_renderer_progress_new (); g_object_set (renderer, "xalign", 0.5, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func (column, renderer, ft_manager_progress_cell_data_func, NULL, NULL); /* Icon and filename column*/ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("File")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sort_column_id (column, COL_MESSAGE); gtk_tree_view_column_set_spacing (column, 3); gtk_tree_view_insert_column (view, column, -1); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "xpad", 3, "stock-size", GTK_ICON_SIZE_DND, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "gicon", COL_ICON, 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", COL_MESSAGE, NULL); /* Remaining time column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Remaining")); gtk_tree_view_column_set_sort_column_id (column, COL_REMAINING); gtk_tree_view_insert_column (view, column, -1); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.5, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "text", COL_REMAINING, NULL); /* clear button should be sensitive only if there are completed/cancelled * handlers in the store. */ gtk_widget_set_sensitive (priv->clear_button, FALSE); }
/* create the "open with" dialog. */ void dlg_open_with (FrWindow *window, GList *file_list) { DialogData *data; GAppInfo *app; GList *scan, *app_names = NULL; char **editors; int i; GtkWidget *cancel_button; GtkTreeIter iter; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkIconTheme *theme; int icon_size; if (file_list == NULL) return; data = g_new0 (DialogData, 1); data->settings = g_settings_new (EXRED_SCHEMA_GENERAL); data->builder = _gtk_builder_new_from_file ("open-with.ui"); if (data->builder == NULL) { g_free (data); return; } data->file_list = path_list_dup (file_list); data->window = window; /* Get the widgets. */ data->dialog = _gtk_builder_get_widget (data->builder, "open_with_dialog"); data->o_app_tree_view = _gtk_builder_get_widget (data->builder, "o_app_list_tree_view"); data->o_recent_tree_view = _gtk_builder_get_widget (data->builder, "o_recent_tree_view"); data->o_app_entry = _gtk_builder_get_widget (data->builder, "o_app_entry"); data->o_del_button = _gtk_builder_get_widget (data->builder, "o_del_button"); data->ok_button = _gtk_builder_get_widget (data->builder, "o_ok_button"); cancel_button = _gtk_builder_get_widget (data->builder, "o_cancel_button"); gtk_widget_set_sensitive (data->ok_button, FALSE); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "destroy", G_CALLBACK (open_with__destroy_cb), data); g_signal_connect (G_OBJECT (data->o_app_entry), "changed", G_CALLBACK (app_entry__changed_cb), data); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->o_app_tree_view))), "changed", G_CALLBACK (app_list_selection_changed_cb), data); g_signal_connect (G_OBJECT (data->o_app_tree_view), "row_activated", G_CALLBACK (app_activated_cb), data); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->o_recent_tree_view))), "changed", G_CALLBACK (recent_list_selection_changed_cb), data); g_signal_connect (G_OBJECT (data->o_recent_tree_view), "row_activated", G_CALLBACK (recent_activated_cb), data); g_signal_connect (G_OBJECT (data->ok_button), "clicked", G_CALLBACK (open_cb), data); g_signal_connect_swapped (G_OBJECT (cancel_button), "clicked", G_CALLBACK (gtk_widget_destroy), G_OBJECT (data->dialog)); g_signal_connect (G_OBJECT (data->o_del_button), "clicked", G_CALLBACK (delete_recent_cb), data); /* Set data. */ /* * registered applications list. */ data->app_list = NULL; for (scan = data->file_list; scan; scan = scan->next) { const char *mime_type; const char *name = scan->data; mime_type = get_file_mime_type_for_path (name, FALSE); if ((mime_type != NULL) && ! g_content_type_is_unknown (mime_type)) data->app_list = g_list_concat (data->app_list, g_app_info_get_all_for_type (mime_type)); } data->app_model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->app_model), TEXT_COLUMN, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (data->o_app_tree_view), data->app_model); g_object_unref (G_OBJECT (data->app_model)); theme = gtk_icon_theme_get_default (); icon_size = get_folder_pixbuf_size_for_list (GTK_WIDGET (data->dialog)); for (scan = data->app_list; scan; scan = scan->next) { gboolean found; char *utf8_name; GdkPixbuf *icon_image = NULL; app = scan->data; found = FALSE; if (app_names != NULL) { GList *p; for (p = app_names; p && !found; p = p->next) if (g_strcmp0 ((char*)p->data, g_app_info_get_executable (app)) == 0) found = TRUE; } if (found) continue; app_names = g_list_prepend (app_names, (char*) g_app_info_get_executable (app)); utf8_name = g_locale_to_utf8 (g_app_info_get_name (app), -1, NULL, NULL, NULL); icon_image = get_icon_pixbuf (g_app_info_get_icon (app), icon_size, theme); gtk_list_store_append (GTK_LIST_STORE (data->app_model), &iter); gtk_list_store_set (GTK_LIST_STORE (data->app_model), &iter, ICON_COLUMN, icon_image, TEXT_COLUMN, utf8_name, DATA_COLUMN, app, -1); g_free (utf8_name); } column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", ICON_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", TEXT_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (data->o_app_tree_view), column); if (app_names) g_list_free (app_names); /* * recent editors list. */ data->recent_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->recent_model), 0, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (data->o_recent_tree_view), data->recent_model); g_object_unref (G_OBJECT (data->recent_model)); editors = g_settings_get_strv (data->settings, PREF_GENERAL_EDITORS); for (i = 0; editors[i] != NULL; i++) { gtk_list_store_append (GTK_LIST_STORE (data->recent_model), &iter); gtk_list_store_set (GTK_LIST_STORE (data->recent_model), &iter, 0, editors[i], -1); } g_strfreev (editors); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW (data->o_recent_tree_view), column); /* Run dialog. */ gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (window)); gtk_window_set_modal (GTK_WINDOW (data->dialog), TRUE); gtk_widget_show_all (data->dialog); }
static void caja_history_sidebar_init (CajaHistorySidebar *sidebar) { GtkTreeView *tree_view; GtkTreeViewColumn *col; GtkCellRenderer *cell; GtkListStore *store; GtkTreeSelection *selection; tree_view = GTK_TREE_VIEW (gtk_tree_view_new ()); gtk_tree_view_set_headers_visible (tree_view, FALSE); gtk_widget_show (GTK_WIDGET (tree_view)); col = GTK_TREE_VIEW_COLUMN (gtk_tree_view_column_new ()); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (col, cell, FALSE); gtk_tree_view_column_set_attributes (col, cell, "surface", HISTORY_SIDEBAR_COLUMN_ICON, NULL); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, cell, TRUE); gtk_tree_view_column_set_attributes (col, cell, "text", HISTORY_SIDEBAR_COLUMN_NAME, NULL); gtk_tree_view_column_set_fixed_width (col, CAJA_ICON_SIZE_SMALLER); gtk_tree_view_append_column (tree_view, col); store = gtk_list_store_new (HISTORY_SIDEBAR_COLUMN_COUNT, CAIRO_GOBJECT_TYPE_SURFACE, G_TYPE_STRING, CAJA_TYPE_BOOKMARK); gtk_tree_view_set_model (tree_view, GTK_TREE_MODEL (store)); g_object_unref (store); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sidebar), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_hadjustment (GTK_SCROLLED_WINDOW (sidebar), NULL); gtk_scrolled_window_set_vadjustment (GTK_SCROLLED_WINDOW (sidebar), NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sidebar), GTK_SHADOW_IN); gtk_scrolled_window_set_overlay_scrolling (GTK_SCROLLED_WINDOW (sidebar), FALSE); gtk_container_add (GTK_CONTAINER (sidebar), GTK_WIDGET (tree_view)); gtk_widget_show (GTK_WIDGET (sidebar)); sidebar->tree_view = tree_view; selection = gtk_tree_view_get_selection (tree_view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect_object (tree_view, "row_activated", G_CALLBACK (row_activated_callback), sidebar, 0); g_signal_connect_object (caja_signaller_get_current (), "history_list_changed", G_CALLBACK (history_changed_callback), sidebar, 0); g_signal_connect (tree_view, "button-press-event", G_CALLBACK (button_press_event_callback), sidebar); g_signal_connect_swapped (caja_preferences, "changed::" CAJA_PREFERENCES_CLICK_POLICY, G_CALLBACK(click_policy_changed_callback), sidebar); update_click_policy (sidebar); }
GtkWidget * pgd_fonts_create_widget (PopplerDocument *document) { PgdFontsDemo *demo; GtkWidget *vbox; GtkListStore *model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *swindow; GtkWidget *hbox, *button; demo = g_new0 (PgdFontsDemo, 1); demo->doc = g_object_ref (document); vbox = gtk_vbox_new (FALSE, 12); hbox = gtk_hbox_new (FALSE, 6); demo->progress = gtk_progress_bar_new (); gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (demo->progress), PANGO_ELLIPSIZE_END); gtk_box_pack_start (GTK_BOX (hbox), demo->progress, TRUE, TRUE, 0); gtk_widget_show (demo->progress); button = gtk_button_new_with_label ("Scan"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_fonts_scan_button_clicked), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 6); gtk_widget_show (hbox); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); model = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING); demo->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (demo->treeview), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (demo->treeview), TRUE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (demo->treeview)), GTK_SELECTION_NONE); g_object_unref (model); column = gtk_tree_view_column_new (); gtk_tree_view_append_column (GTK_TREE_VIEW (demo->treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (GTK_TREE_VIEW_COLUMN (column), renderer, FALSE); gtk_tree_view_column_set_cell_data_func (column, renderer, pdg_fonts_cell_data_func, NULL, NULL); gtk_container_add (GTK_CONTAINER (swindow), demo->treeview); gtk_widget_show (demo->treeview); gtk_box_pack_start (GTK_BOX (vbox), swindow, TRUE, TRUE, 0); gtk_widget_show (swindow); g_object_weak_ref (G_OBJECT (swindow), (GWeakNotify)pgd_fonts_free, (gpointer)demo); return vbox; }
/* public methods implementation */ GtkWidget * book_view_gtk_new (Ekiga::BookPtr book) { BookViewGtk *result = NULL; GtkWidget *label = NULL; GtkWidget *hbox = NULL; GtkWidget *button = NULL; GtkTreeSelection *selection = NULL; GtkListStore *store = NULL; GtkTreeViewColumn *column = NULL; GtkCellRenderer *renderer = NULL; result = (BookViewGtk *) g_object_new (BOOK_VIEW_GTK_TYPE, NULL); result->priv = new _BookViewGtkPrivate (book); result->priv->vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_frame_set_shadow_type (GTK_FRAME (result), GTK_SHADOW_NONE); /* The Search Box */ boost::shared_ptr<Ekiga::Filterable> filtered = boost::dynamic_pointer_cast<Ekiga::Filterable> (book); if (filtered) { hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); result->priv->entry = gtk_entry_new (); button = gtk_button_new_from_stock (GTK_STOCK_FIND); label = gtk_label_new_with_mnemonic (_("_Search Filter:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (hbox), result->priv->entry, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (result->priv->vbox), hbox, FALSE, FALSE, 0); g_signal_connect (result->priv->entry, "activate", G_CALLBACK (on_entry_activated_cb), result); g_signal_connect (button, "clicked", G_CALLBACK (on_button_clicked_cb), result); } else { result->priv->entry = NULL; } /* The List Store */ result->priv->scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (result->priv->scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); result->priv->tree_view = GTK_TREE_VIEW (gtk_tree_view_new ()); gtk_tree_view_set_headers_visible (result->priv->tree_view, FALSE); gtk_container_add (GTK_CONTAINER (result), GTK_WIDGET (result->priv->vbox)); gtk_box_pack_start (GTK_BOX (result->priv->vbox), GTK_WIDGET (result->priv->scrolled_window), TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (result->priv->scrolled_window), GTK_WIDGET (result->priv->tree_view)); selection = gtk_tree_view_get_selection (result->priv->tree_view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (on_selection_changed), result); g_signal_connect (result->priv->tree_view, "event-after", G_CALLBACK (on_contact_clicked), result); store = gtk_list_store_new (COLUMN_NUMBER, G_TYPE_POINTER, GDK_TYPE_PIXBUF, G_TYPE_STRING); gtk_tree_view_set_model (result->priv->tree_view, GTK_TREE_MODEL (store)); g_object_unref (store); /* Name */ column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", COLUMN_PIXBUF, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "text", COLUMN_NAME, NULL); gtk_tree_view_column_set_title (column, _("Full Name")); gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (column, true); gtk_tree_view_append_column (GTK_TREE_VIEW (result->priv->tree_view), column); /* The status bar */ result->priv->statusbar = gtk_statusbar_new (); gtk_box_pack_start (GTK_BOX (result->priv->vbox), result->priv->statusbar, FALSE, TRUE, 0); /* connect to the signals */ result->priv->connections.add (book->contact_added.connect (boost::bind (&on_contact_added, _1, (gpointer)result))); result->priv->connections.add (book->contact_updated.connect (boost::bind (&on_contact_updated, _1, (gpointer)result))); result->priv->connections.add (book->contact_removed.connect (boost::bind (&on_contact_removed, _1, (gpointer)result))); result->priv->connections.add (book->updated.connect (boost::bind (&on_updated, (gpointer)result))); /* populate */ book->visit_contacts (boost::bind (&on_visit_contacts, _1, (gpointer)result)); return (GtkWidget *) result; }
GtkWidget * create_directory_treeview (void) { GtkCellRenderer *cell; GtkTreeViewColumn *col; GtkWidget *scrolled; GtkWidget *tvw = GTK_WIDGET (gtk_builder_get_object (baobab.main_ui, "treeview1")); g_signal_connect (tvw, "row-expanded", G_CALLBACK (on_tv_row_expanded), NULL); g_signal_connect (tvw, "cursor-changed", G_CALLBACK (on_tv_cur_changed), NULL); g_signal_connect (tvw, "button-press-event", G_CALLBACK (on_tv_button_press), NULL); /* dir name column */ g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (tvw)), "changed", G_CALLBACK (on_tv_selection_changed), NULL); cell = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup", COL_DIR_NAME, "text", COL_DIR_NAME, NULL); gtk_tree_view_column_set_sort_column_id (col, COL_DIR_NAME); gtk_tree_view_column_set_reorderable (col, TRUE); gtk_tree_view_column_set_title (col, _("Folder")); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col); /* percentage bar & text column */ col = gtk_tree_view_column_new (); cell = baobab_cell_renderer_progress_new (); gtk_tree_view_column_pack_start (col, cell, FALSE); gtk_tree_view_column_set_attributes (col, cell, "perc", COL_H_PERC, NULL); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, cell, TRUE); gtk_tree_view_column_set_cell_data_func (col, cell, perc_cell_data_func, NULL, NULL); g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL); gtk_tree_view_column_set_sort_column_id (col, COL_H_PERC); gtk_tree_view_column_set_reorderable (col, TRUE); gtk_tree_view_column_set_title (col, _("Usage")); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (col, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col); /* directory size column */ cell = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup", COL_DIR_SIZE, "text", COL_DIR_SIZE, NULL); g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL); gtk_tree_view_column_set_sort_column_id (col, baobab.show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE); gtk_tree_view_column_set_reorderable (col, TRUE); gtk_tree_view_column_set_title (col, _("Size")); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col); /* store this column, we need it when toggling 'allocated' */ g_object_set_data (G_OBJECT (tvw), "baobab_size_col", col); /* objects column */ cell = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup", COL_ELEMENTS, "text", COL_ELEMENTS, NULL); g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL); gtk_tree_view_column_set_sort_column_id (col, COL_H_ELEMENTS); gtk_tree_view_column_set_reorderable (col, TRUE); gtk_tree_view_column_set_title (col, _("Contents")); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col); /* hardlink column */ cell = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup", COL_HARDLINK, "text", COL_HARDLINK, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col); gtk_tree_view_collapse_all (GTK_TREE_VIEW (tvw)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tvw), FALSE); scrolled = GTK_WIDGET (gtk_builder_get_object (baobab.main_ui, "scrolledwindow1")); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (tvw), baobab_treeview_equal_func, NULL, NULL); baobab.model = create_model (); /* By default, sort by size */ gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (baobab.model), baobab.show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE, GTK_SORT_DESCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (tvw), GTK_TREE_MODEL (baobab.model)); g_object_unref (baobab.model); return tvw; }
/* Create the window for selecting folders with checkboxes */ static void foldercheck_create_window(SpecificFolderArrayEntry *entry) { GtkWidget *vbox; GtkWidget *scrolledwin; GtkWidget *confirm_area; GtkWidget *checkbox; GtkWidget *cancel_button; GtkWidget *ok_button; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkCellRenderer *renderer; static GdkGeometry geometry; /* Create window */ entry->window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "notification_foldercheck"); gtk_window_set_title(GTK_WINDOW(entry->window), _("Select folder(s)")); gtk_container_set_border_width(GTK_CONTAINER(entry->window), 4); gtk_window_set_position(GTK_WINDOW(entry->window), GTK_WIN_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(entry->window), TRUE); gtk_window_set_resizable(GTK_WINDOW(entry->window), TRUE); gtk_window_set_wmclass (GTK_WINDOW(entry->window), "folder_selection", "Claws Mail"); g_signal_connect(G_OBJECT(entry->window), "delete_event", G_CALLBACK(delete_event), entry); g_signal_connect(G_OBJECT(entry->window), "key_press_event", G_CALLBACK(key_pressed), entry); MANAGE_WINDOW_SIGNALS_CONNECT(entry->window); /* vbox */ vbox = gtk_vbox_new(FALSE, 4); gtk_container_add(GTK_CONTAINER(entry->window), vbox); /* scrolled window */ scrolledwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0); /* pixbufs */ if(!folder_pixbuf) stock_pixbuf_gdk(STOCK_PIXMAP_DIR_CLOSE, &folder_pixbuf); if(!folderopen_pixbuf) stock_pixbuf_gdk(STOCK_PIXMAP_DIR_OPEN, &folderopen_pixbuf); if(!foldernoselect_pixbuf) stock_pixbuf_gdk(STOCK_PIXMAP_DIR_NOSELECT_CLOSE, &foldernoselect_pixbuf); if(!foldernoselectopen_pixbuf) stock_pixbuf_gdk(STOCK_PIXMAP_DIR_NOSELECT_OPEN, &foldernoselectopen_pixbuf); /* Tree store */ foldercheck_set_tree(entry); gtk_tree_model_foreach(GTK_TREE_MODEL(entry->tree_store), foldercheck_foreach_update_to_list, entry); /* tree view */ entry->treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(entry->tree_store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(entry->treeview), FALSE); gtk_tree_view_set_search_column(GTK_TREE_VIEW(entry->treeview), FOLDERCHECK_FOLDERNAME); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(entry->treeview), prefs_common_get_prefs()->use_stripes_everywhere); gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(entry->treeview), FALSE); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(entry->treeview)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); gtk_tree_selection_set_select_function(selection, foldercheck_selected, NULL, NULL); gtk_container_add(GTK_CONTAINER(scrolledwin), entry->treeview); /* --- column 1 --- */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, "sel"); gtk_tree_view_column_set_spacing(column, 2); /* checkbox */ renderer = gtk_cell_renderer_toggle_new(); g_object_set(renderer, "xalign", 0.0, NULL); gtk_tree_view_column_pack_start(column, renderer, TRUE); g_signal_connect(renderer, "toggled", G_CALLBACK(folder_toggle_cb),entry); gtk_tree_view_column_set_attributes(column, renderer, "active", FOLDERCHECK_CHECK,NULL); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(entry->treeview), column); /* --- column 2 --- */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, "Folder"); gtk_tree_view_column_set_spacing(column, 2); /* pixbuf */ renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", FOLDERCHECK_PIXBUF, "pixbuf-expander-open", FOLDERCHECK_PIXBUF_OPEN, "pixbuf-expander-closed", FOLDERCHECK_PIXBUF, NULL); /* text */ renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_attributes(column, renderer, "text", FOLDERCHECK_FOLDERNAME, NULL); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(entry->treeview), column); /* recursive */ checkbox = gtk_check_button_new_with_label( _("select recursively")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), FALSE); g_signal_connect(G_OBJECT(checkbox), "toggled", G_CALLBACK(foldercheck_recursive_cb), entry); gtk_box_pack_start(GTK_BOX(vbox), checkbox, FALSE, FALSE, 10); gtkut_stock_button_set_create(&confirm_area, &cancel_button, GTK_STOCK_CANCEL, &ok_button, GTK_STOCK_OK, NULL, NULL); gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0); gtk_widget_grab_default(ok_button); g_signal_connect(G_OBJECT(ok_button), "clicked", G_CALLBACK(foldercheck_ok), entry); g_signal_connect(G_OBJECT(cancel_button), "clicked", G_CALLBACK(foldercheck_cancel), entry); if(!geometry.min_height) { geometry.min_width = 360; geometry.min_height = 360; } gtk_window_set_geometry_hints(GTK_WINDOW(entry->window), NULL, &geometry, GDK_HINT_MIN_SIZE); gtk_tree_view_expand_all(GTK_TREE_VIEW(entry->treeview)); gtk_widget_show_all(vbox); }
static void remmina_ftp_client_init(RemminaFTPClient *client) { RemminaFTPClientPriv *priv; GtkWidget *vpaned; GtkWidget *scrolledwindow; GtkWidget *widget; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *vbox; priv = g_new0(RemminaFTPClientPriv, 1); client->priv = priv; /* Main container */ gtk_box_set_homogeneous(GTK_BOX(client), FALSE); gtk_box_set_spacing(GTK_BOX(client), 4); /* Toolbar */ remmina_ftp_client_create_toolbar(client); /* The Paned to separate File List and Task List */ #if GTK_VERSION == 3 vpaned = gtk_paned_new(GTK_ORIENTATION_VERTICAL); #elif GTK_VERSION == 2 vpaned = gtk_vpaned_new(); #endif gtk_widget_show(vpaned); gtk_box_pack_start(GTK_BOX(client), vpaned, TRUE, TRUE, 0); priv->vpaned = vpaned; /* Remote */ #if GTK_VERSION == 3 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #elif GTK_VERSION == 2 vbox = gtk_vbox_new(FALSE, 0); #endif gtk_widget_show(vbox); gtk_paned_pack1(GTK_PANED(vpaned), vbox, TRUE, FALSE); /* Remote Directory */ widget = gtk_combo_box_text_new_with_entry(); gtk_widget_show(widget); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "/"); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0); priv->directory_combo = widget; /* Remote File List */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0); widget = gtk_tree_view_new(); gtk_widget_show(widget); gtk_container_add(GTK_CONTAINER(scrolledwindow), widget); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)), GTK_SELECTION_MULTIPLE); priv->file_list_view = widget; /* Remote File List - Columns */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("File Name")); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_NAME_SORT); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL); gtk_tree_view_column_set_alignment(column, 1.0); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size, NULL, NULL); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_SIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("User"), renderer, "text", REMMINA_FTP_FILE_COLUMN_USER, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_USER); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", REMMINA_FTP_FILE_COLUMN_GROUP, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_GROUP); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Permission"), renderer, "text", REMMINA_FTP_FILE_COLUMN_PERMISSION, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_permission, NULL, NULL); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_PERMISSION); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); /* Remote File List - Model */ priv->file_list_model = GTK_TREE_MODEL( gtk_list_store_new(REMMINA_FTP_FILE_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING)); priv->file_list_filter = gtk_tree_model_filter_new(priv->file_list_model, NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(priv->file_list_filter), (GtkTreeModelFilterVisibleFunc) remmina_ftp_client_filter_visible_func, client, NULL); priv->file_list_sort = gtk_tree_model_sort_new_with_model(priv->file_list_filter); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(priv->file_list_sort), REMMINA_FTP_FILE_COLUMN_NAME_SORT, GTK_SORT_ASCENDING); gtk_tree_view_set_model(GTK_TREE_VIEW(priv->file_list_view), priv->file_list_sort); /* Task List */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_paned_pack2(GTK_PANED(vpaned), scrolledwindow, FALSE, TRUE); widget = gtk_tree_view_new(); gtk_widget_show(widget); gtk_container_add(GTK_CONTAINER(scrolledwindow), widget); g_object_set(widget, "has-tooltip", TRUE, NULL); priv->task_list_view = widget; /* Task List - Columns */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("File Name")); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_NAME); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress_pixbuf, NULL, NULL); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Remote"), renderer, "text", REMMINA_FTP_TASK_COLUMN_REMOTEDIR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_REMOTEDIR); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Local"), renderer, "text", REMMINA_FTP_TASK_COLUMN_LOCALDIR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_LOCALDIR); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL); gtk_tree_view_column_set_alignment(column, 1.0); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size_progress, NULL, NULL); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_SIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_progress_new(); column = gtk_tree_view_column_new_with_attributes(_("Progress"), renderer, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress, NULL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = remmina_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, NULL); g_object_set(G_OBJECT(renderer), "stock-id", "_Cancel", NULL); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); g_signal_connect(G_OBJECT(renderer), "activate", G_CALLBACK(remmina_ftp_client_task_list_cell_on_activate), client); /* Task List - Model */ priv->task_list_model = GTK_TREE_MODEL( gtk_list_store_new(REMMINA_FTP_TASK_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_FLOAT, G_TYPE_STRING)); gtk_tree_view_set_model(GTK_TREE_VIEW(priv->task_list_view), priv->task_list_model); /* Setup the internal signals */ g_signal_connect(G_OBJECT(client), "destroy", G_CALLBACK(remmina_ftp_client_destroy), NULL); g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN(priv->directory_combo))), "activate", G_CALLBACK(remmina_ftp_client_dir_on_activate), client); g_signal_connect(G_OBJECT(priv->directory_combo), "changed", G_CALLBACK(remmina_ftp_client_dir_on_changed), client); g_signal_connect(G_OBJECT(priv->file_list_view), "button-press-event", G_CALLBACK(remmina_ftp_client_file_list_on_button_press), client); g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view))), "changed", G_CALLBACK(remmina_ftp_client_file_selection_on_changed), client); g_signal_connect(G_OBJECT(priv->task_list_view), "query-tooltip", G_CALLBACK(remmina_ftp_client_task_list_on_query_tooltip), client); }
void gui_init(dt_lib_module_t *self) { dt_lib_tagging_t *d = (dt_lib_tagging_t *)malloc(sizeof(dt_lib_tagging_t)); self->data = (void *)d; d->imgsel = -1; self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); // gtk_widget_set_size_request(self->widget, DT_PIXEL_APPLY_DPI(100), -1); GtkBox *box, *hbox; GtkWidget *button; GtkWidget *w; GtkListStore *liststore; // left side, current box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0); w = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(w, -1, DT_PIXEL_APPLY_DPI(100)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->current = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->current, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->current, col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->current), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->current, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); gtk_widget_set_tooltip_text(GTK_WIDGET(d->current), _("attached tags,\ndoubleclick to detach")); g_signal_connect(G_OBJECT(d->current), "row-activated", G_CALLBACK(detach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->current)); // attach/detach buttons hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5)); button = gtk_button_new_with_label(_("attach")); d->attach_button = button; gtk_widget_set_tooltip_text(button, _("attach tag to all selected images")); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(attach_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("detach")); d->detach_button = button; gtk_widget_set_tooltip_text(button, _("detach tag from all selected images")); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(detach_button_clicked), (gpointer)self); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0); // right side, related box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 5); // text entry and new button w = gtk_entry_new(); gtk_widget_set_tooltip_text(w, _("enter tag name")); gtk_box_pack_start(box, w, TRUE, TRUE, 0); gtk_widget_add_events(GTK_WIDGET(w), GDK_KEY_RELEASE_MASK); // g_signal_connect(G_OBJECT(w), "key-release-event", g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(tag_name_changed), (gpointer)self); g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(entry_activated), (gpointer)self); d->entry = GTK_ENTRY(w); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry)); // related tree view w = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(w, -1, DT_PIXEL_APPLY_DPI(100)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->related = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->related, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->related, col); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->related), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->related, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); gtk_widget_set_tooltip_text(GTK_WIDGET(d->related), _("related tags,\ndoubleclick to attach")); g_signal_connect(G_OBJECT(d->related), "row-activated", G_CALLBACK(attach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->related)); // attach and delete buttons hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5)); button = gtk_button_new_with_label(_("new")); d->new_button = button; gtk_widget_set_tooltip_text(button, _("create a new tag with the\nname you entered")); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(new_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("delete")); d->delete_button = button; gtk_widget_set_tooltip_text(button, _("delete selected tag")); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(delete_button_clicked), (gpointer)self); button = gtk_button_new_with_label(C_("verb", "import")); d->import_button = button; gtk_widget_set_tooltip_text(button, _("import tags from a Lightroom keyword file")); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(import_button_clicked), (gpointer)self); button = gtk_button_new_with_label(C_("verb", "export")); d->export_button = button; gtk_widget_set_tooltip_text(button, _("export all tags to a Lightroom keyword file")); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(export_button_clicked), (gpointer)self); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0); // add entry completion GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->related))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* connect to mouse over id */ dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE, G_CALLBACK(_lib_tagging_redraw_callback), self); dt_control_signal_connect(darktable.signals, DT_SIGNAL_TAG_CHANGED, G_CALLBACK(_lib_tagging_tags_changed_callback), self); update(self, 0); set_keyword(self, d); }
/* Public API */ GtkWidget * accounts_window_new (boost::shared_ptr<Ekiga::AccountCore> account_core, boost::shared_ptr<Ekiga::PersonalDetails> details) { AccountsWindow *self = NULL; boost::signals::connection conn; GtkWidget *vbox = NULL; GtkWidget *menu_bar = NULL; GtkWidget *menu_item = NULL; GtkWidget *menu = NULL; GtkWidget *item = NULL; GtkWidget *event_box = NULL; GtkWidget *scroll_window = NULL; GtkWidget* button_box = NULL; GtkWidget* button = NULL; GtkWidget *frame = NULL; GtkWidget *hbox = NULL; GtkCellRenderer *renderer = NULL; GtkListStore *list_store = NULL; GtkTreeViewColumn *column = NULL; GtkTreeSelection* selection = NULL; AtkObject *aobj; const gchar *column_names [] = { "", "", "", "", _("Account Name"), _("Status") }; /* The window */ self = (AccountsWindow *) g_object_new (ACCOUNTS_WINDOW_TYPE, NULL); self->priv = new AccountsWindowPrivate; self->priv->details = details; self->priv->account_core = account_core; vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_window_set_title (GTK_WINDOW (self), _("Accounts")); /* The menu */ menu_bar = gtk_menu_bar_new (); self->priv->accel = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (self), self->priv->accel); g_object_unref (self->priv->accel); self->priv->menu_item_core = gtk_menu_item_new_with_mnemonic (_("_Accounts")); gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), self->priv->menu_item_core); g_object_ref (self->priv->menu_item_core); menu_item = gtk_menu_item_new_with_mnemonic (_("_Help")); gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), menu_item); menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu); item = gtk_image_menu_item_new_from_stock (GTK_STOCK_HELP, NULL); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_signal_connect (item, "activate", G_CALLBACK (help_callback), NULL); /* The accounts list store */ list_store = gtk_list_store_new (COLUMN_ACCOUNT_NUMBER, G_TYPE_POINTER, G_TYPE_STRING, /* Icon */ G_TYPE_BOOLEAN, /* Is account active? */ G_TYPE_INT, G_TYPE_STRING, /* Account Name */ G_TYPE_STRING, /* Error Message */ G_TYPE_INT); /* State */ self->priv->accounts_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store)); g_object_unref (list_store); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (self->priv->accounts_list), TRUE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (self->priv->accounts_list), TRUE); aobj = gtk_widget_get_accessible (GTK_WIDGET (self->priv->accounts_list)); atk_object_set_name (aobj, _("Accounts")); renderer = gtk_cell_renderer_pixbuf_new (); column = gtk_tree_view_column_new (); g_object_set (renderer, "yalign", 0.5, "xpad", 5, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "icon-name", COLUMN_ACCOUNT_ICON); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->accounts_list), column); /* Add all text renderers */ for (int i = COLUMN_ACCOUNT_ACCOUNT_NAME ; i < COLUMN_ACCOUNT_NUMBER ; i++) { renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (column_names [i], renderer, "text", i, "weight", COLUMN_ACCOUNT_WEIGHT, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->accounts_list), column); gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_sort_column_id (column, i); } g_signal_connect (self->priv->accounts_list, "event_after", G_CALLBACK (account_clicked_cb), self); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->accounts_list)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (on_selection_changed), self); /* The scrolled window with the accounts list store */ scroll_window = gtk_scrolled_window_new (FALSE, FALSE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); event_box = gtk_event_box_new (); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_container_add (GTK_CONTAINER (event_box), hbox); frame = gtk_frame_new (NULL); gtk_widget_set_size_request (GTK_WIDGET (frame), 250, 150); gtk_container_set_border_width (GTK_CONTAINER (frame), 4); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (frame), scroll_window); gtk_container_add (GTK_CONTAINER (scroll_window), self->priv->accounts_list); gtk_container_set_border_width (GTK_CONTAINER (self->priv->accounts_list), 0); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); /* setting up a horizontal button box * (each button with be dynamically disabled/enabled as needed) */ button_box = gtk_button_box_new (GTK_ORIENTATION_VERTICAL); gtk_button_box_set_layout (GTK_BUTTON_BOX (button_box), GTK_BUTTONBOX_CENTER); button = gtk_button_new_with_mnemonic (_("_Enable")); gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3); self->priv->toolbar.add_button ("user-available", GTK_BUTTON (button)); button = gtk_button_new_with_mnemonic (_("_Disable")); gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3); self->priv->toolbar.add_button ("user-offline", GTK_BUTTON (button)); button = gtk_button_new_with_mnemonic (_("Edi_t")); gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3); self->priv->toolbar.add_button ("edit", GTK_BUTTON (button)); button = gtk_button_new_with_mnemonic (_("_Remove")); gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3); self->priv->toolbar.add_button ("remove", GTK_BUTTON (button)); gtk_box_pack_start (GTK_BOX (hbox), button_box, FALSE, FALSE, 10); populate_menu (GTK_WIDGET (self)); // This will add static and dynamic actions gtk_box_pack_start (GTK_BOX (vbox), menu_bar, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), event_box, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (self), vbox); gtk_widget_show_all (GTK_WIDGET (vbox)); /* Engine Signals callbacks */ conn = self->priv->account_core->bank_added.connect (boost::bind (&on_bank_added, _1, self)); self->priv->connections.add (conn); conn = self->priv->account_core->account_added.connect (boost::bind (&on_account_added, _1, _2, self)); self->priv->connections.add (conn); conn = self->priv->account_core->account_updated.connect (boost::bind (&on_account_updated, _1, _2, self)); self->priv->connections.add (conn); conn = self->priv->account_core->account_removed.connect (boost::bind (&on_account_removed, _1, _2, self)); self->priv->connections.add (conn); conn = self->priv->account_core->questions.connect (boost::bind (&on_handle_questions, _1, (gpointer) self)); self->priv->connections.add (conn); self->priv->presence = self->priv->details->get_presence (); conn = self->priv->details->updated.connect (boost::bind (&on_personal_details_updated, self, self->priv->details)); self->priv->connections.add (conn); self->priv->account_core->visit_banks (boost::bind (&on_visit_banks, _1, self)); return GTK_WIDGET (self); }
static void gw_settingswindow_init_dictionary_treeview (GwSettingsWindow *window) { //Declarations GwSettingsWindowPrivate *priv; GwApplication *application; GwDictionaryList *dictionarylist; GtkListStore *liststore; GtkTreeModel *treemodel; GtkTreeView *view; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; priv = window->priv; application = gw_window_get_application (GW_WINDOW (window)); dictionarylist = gw_application_get_installed_dictionarylist (application); liststore = gw_dictionarylist_get_liststore (dictionarylist); treemodel = GTK_TREE_MODEL (liststore); view = priv->manage_dictionaries_treeview; selection = gtk_tree_view_get_selection (view); gtk_tree_view_set_model (view, treemodel); //Create the columns and renderer for each column renderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_renderer_set_padding (renderer, 6, 4); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, " "); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "icon-name", GW_DICTIONARYLIST_COLUMN_IMAGE, NULL); gtk_tree_view_append_column (view, column); renderer = gtk_cell_renderer_text_new(); gtk_cell_renderer_set_padding (renderer, 6, 4); column = gtk_tree_view_column_new_with_attributes ("#", renderer, "text", GW_DICTIONARYLIST_COLUMN_POSITION, NULL); gtk_tree_view_append_column (view, column); renderer = gtk_cell_renderer_text_new(); gtk_cell_renderer_set_padding (renderer, 6, 4); column = gtk_tree_view_column_new_with_attributes (gettext("Name"), renderer, "text", GW_DICTIONARYLIST_COLUMN_LONG_NAME, NULL); gtk_tree_view_column_set_min_width (column, 100); gtk_tree_view_append_column (view, column); renderer = gtk_cell_renderer_text_new(); gtk_cell_renderer_set_padding (renderer, 6, 4); column = gtk_tree_view_column_new_with_attributes (gettext("Engine"), renderer, "text", GW_DICTIONARYLIST_COLUMN_ENGINE, NULL); gtk_tree_view_append_column (view, column); renderer = gtk_cell_renderer_text_new(); gtk_cell_renderer_set_padding (renderer, 6, 4); column = gtk_tree_view_column_new_with_attributes (gettext("Shortcut"), renderer, "text", GW_DICTIONARYLIST_COLUMN_SHORTCUT, NULL); gtk_tree_view_append_column (view, column); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); gtk_drag_source_set ( GTK_WIDGET (priv->manage_dictionaries_treeview), GDK_BUTTON1_MASK, dictionary_row_source_targets, n_list_row_source_targets, GDK_ACTION_MOVE ); gtk_drag_dest_set ( GTK_WIDGET (priv->manage_dictionaries_treeview), GTK_DEST_DEFAULT_ALL, dictionary_row_dest_targets, n_list_row_dest_targets, GDK_ACTION_MOVE ); }
void ctree_init(void) { GtkTreeView *view = GTK_TREE_VIEW(ctree_wnd); GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; gint i; tree = gtk_tree_store_new(CTREE_NCOLS, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING, GDK_TYPE_PIXBUF); model = GTK_TREE_MODEL(tree); gtk_tree_view_set_model(view, model); gtk_tree_view_set_headers_visible(view, TRUE); gtk_tree_view_set_headers_clickable(view, TRUE); gtk_tree_view_set_rules_hint(view, FALSE); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(view, column); gtk_tree_view_column_set_title(column, _("Name")); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "pixbuf", COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "text", COLUMN_NAME, "font", COLUMN_FONT, NULL); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Attr"), renderer, "pixbuf", COLUMN_ATTR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Type"), renderer, "text", COLUMN_TYPE, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Size"), renderer, "text", COLUMN_SIZE, NULL); for (i = 0; i < CTREE_NVCOLS; i++) { GtkTreeViewColumn *col; col = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_clickable(col, TRUE); g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(column_clicked), view); } selection = gtk_tree_view_get_selection(view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(tree_selection_changed), NULL); ctree_set_basetree(); }
static GtkWidget *bar_pane_keywords_new(const gchar *id, const gchar *title, const gchar *key, gboolean expanded) { PaneKeywordsData *pkd; GtkWidget *hbox; GtkWidget *scrolled; GtkTextBuffer *buffer; GtkTreeModel *store; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeIter iter; pkd = g_new0(PaneKeywordsData, 1); pkd->pane.pane_set_fd = bar_pane_keywords_set_fd; pkd->pane.pane_event = bar_pane_keywords_event; pkd->pane.pane_write_config = bar_pane_keywords_write_config; pkd->pane.title = bar_pane_expander_title(title); pkd->pane.id = g_strdup(id); pkd->pane.type = PANE_KEYWORDS; pkd->pane.expanded = expanded; pkd->key = g_strdup(key); pkd->expand_checked = TRUE; hbox = gtk_hbox_new(FALSE, PREF_PAD_GAP); pkd->widget = hbox; g_object_set_data(G_OBJECT(pkd->widget), "pane_data", pkd); g_signal_connect(G_OBJECT(pkd->widget), "destroy", G_CALLBACK(bar_pane_keywords_destroy), pkd); gtk_widget_show(hbox); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); pkd->keyword_view = gtk_text_view_new(); gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_view); g_signal_connect(G_OBJECT(pkd->keyword_view), "populate-popup", G_CALLBACK(bar_pane_keywords_populate_popup_cb), pkd); gtk_widget_show(pkd->keyword_view); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view)); g_signal_connect(G_OBJECT(buffer), "changed", G_CALLBACK(bar_pane_keywords_changed), pkd); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); if (!keyword_tree || !gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_tree), &iter)) { /* keyword tree does not exist or is empty - fill with defaults */ keyword_tree_new_default(); } store = gtk_tree_model_filter_new(GTK_TREE_MODEL(keyword_tree), NULL); gtk_tree_model_filter_set_modify_func(GTK_TREE_MODEL_FILTER(store), FILTER_KEYWORD_COLUMN_COUNT, filter_keyword_column_types, bar_pane_keywords_filter_modify, pkd, NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(store), bar_pane_keywords_filter_visible, store, NULL); pkd->keyword_treeview = gtk_tree_view_new_with_model(store); g_object_unref(store); gtk_widget_set_size_request(pkd->keyword_treeview, -1, 400); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(pkd->keyword_treeview), FALSE); // gtk_tree_view_set_search_column(GTK_TREE_VIEW(pkd->keyword_treeview), FILTER_KEYWORD_COLUMN_); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_MARK); gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); renderer = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "active", FILTER_KEYWORD_COLUMN_TOGGLE); gtk_tree_view_column_add_attribute(column, renderer, "visible", FILTER_KEYWORD_COLUMN_IS_KEYWORD); g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(bar_pane_keywords_keyword_toggle), pkd); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column); gtk_tree_view_set_expander_column(GTK_TREE_VIEW(pkd->keyword_treeview), column); gtk_drag_source_set(pkd->keyword_treeview, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK, bar_pane_keywords_drag_types, n_keywords_drag_types, GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_get", G_CALLBACK(bar_pane_keywords_dnd_get), pkd); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_begin", G_CALLBACK(bar_pane_keywords_dnd_begin), pkd); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_end", G_CALLBACK(bar_pane_keywords_dnd_end), pkd); gtk_drag_dest_set(pkd->keyword_treeview, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, bar_pane_keywords_drop_types, n_keywords_drop_types, GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_received", G_CALLBACK(bar_pane_keywords_dnd_receive), pkd); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_motion", G_CALLBACK(bar_pane_keywords_dnd_motion), pkd); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "button_release_event", G_CALLBACK(bar_pane_keywords_menu_cb), pkd); gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_treeview); gtk_widget_show(pkd->keyword_treeview); file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW); return pkd->widget; }
gint main (gint argc, gchar **argv) { GtkWidget *window; GtkWidget *scrolled_window; GtkWidget *tree_view; GtkWidget *vbox, *hbox, *cntl_vbox; GtkTreeModel *tree_model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkCellArea *area; CallbackData callback[4]; gtk_init (&argc, &argv); if (g_getenv ("RTL")) gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "GtkTreeView editing sample"); g_signal_connect (window, "destroy", gtk_main_quit, NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_widget_show (vbox); gtk_container_add (GTK_CONTAINER (window), vbox); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE); tree_model = create_model (); tree_view = gtk_tree_view_new_with_model (tree_model); g_signal_connect (tree_view, "button_press_event", G_CALLBACK (button_press_event), NULL); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), TRUE); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, "String"); area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "icon-name", ICON_NAME_COLUMN, "sensitive", IS_SENSITIVE_COLUMN, NULL); callback[0].area = area; callback[0].renderer = renderer; renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "text", STRING_COLUMN, "editable", IS_EDITABLE_COLUMN, "sensitive", IS_SENSITIVE_COLUMN, NULL); callback[1].area = area; callback[1].renderer = renderer; g_signal_connect (renderer, "edited", G_CALLBACK (edited), tree_model); g_object_set (renderer, "placeholder-text", "Type here", NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "text", STRING_COLUMN, "editable", IS_EDITABLE_COLUMN, "sensitive", IS_SENSITIVE_COLUMN, NULL); callback[2].area = area; callback[2].renderer = renderer; g_signal_connect (renderer, "edited", G_CALLBACK (edited), tree_model); g_object_set (renderer, "placeholder-text", "Type here too", NULL); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "xalign", 0.0, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "icon-name", LAST_ICON_NAME_COLUMN, "sensitive", IS_SENSITIVE_COLUMN, NULL); callback[3].area = area; callback[3].renderer = renderer; gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (editable_toggled), tree_model); g_object_set (renderer, "xalign", 0.0, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "Editable", renderer, "active", IS_EDITABLE_COLUMN, NULL); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (sensitive_toggled), tree_model); g_object_set (renderer, "xalign", 0.0, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "Sensitive", renderer, "active", IS_SENSITIVE_COLUMN, NULL); renderer = gtk_cell_renderer_progress_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "Progress", renderer, "value", PROGRESS_COLUMN, NULL); gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view); gtk_window_set_default_size (GTK_WINDOW (window), 800, 250); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_widget_show (hbox); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE); /* Alignment controls */ cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_widget_show (cntl_vbox); gtk_box_pack_start (GTK_BOX (hbox), cntl_vbox, FALSE, FALSE); create_control (cntl_vbox, 1, CNTL_ALIGN, &callback[0]); create_control (cntl_vbox, 2, CNTL_ALIGN, &callback[1]); create_control (cntl_vbox, 3, CNTL_ALIGN, &callback[2]); create_control (cntl_vbox, 4, CNTL_ALIGN, &callback[3]); /* Expand controls */ cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_widget_show (cntl_vbox); gtk_box_pack_start (GTK_BOX (hbox), cntl_vbox, FALSE, FALSE); create_control (cntl_vbox, 1, CNTL_EXPAND, &callback[0]); create_control (cntl_vbox, 2, CNTL_EXPAND, &callback[1]); create_control (cntl_vbox, 3, CNTL_EXPAND, &callback[2]); create_control (cntl_vbox, 4, CNTL_EXPAND, &callback[3]); /* Fixed controls */ cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_widget_show (cntl_vbox); gtk_box_pack_start (GTK_BOX (hbox), cntl_vbox, FALSE, FALSE); create_control (cntl_vbox, 1, CNTL_FIXED, &callback[0]); create_control (cntl_vbox, 2, CNTL_FIXED, &callback[1]); create_control (cntl_vbox, 3, CNTL_FIXED, &callback[2]); create_control (cntl_vbox, 4, CNTL_FIXED, &callback[3]); gtk_widget_show_all (window); gtk_main (); return 0; }
GtkWidget * gimp_file_proc_view_new (Gimp *gimp, GSList *procedures, const gchar *automatic, const gchar *automatic_help_id) { GtkFileFilter *all_filter; GtkTreeView *view; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkListStore *store; GSList *list; GtkTreeIter iter; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); store = gtk_list_store_new (N_COLUMNS, GIMP_TYPE_PLUG_IN_PROCEDURE, /* COLUMN_PROC */ G_TYPE_STRING, /* COLUMN_LABEL */ G_TYPE_STRING, /* COLUMN_EXTENSIONS */ G_TYPE_STRING, /* COLUMN_HELP_ID */ GTK_TYPE_FILE_FILTER); /* COLUMN_FILTER */ view = g_object_new (GIMP_TYPE_FILE_PROC_VIEW, "model", store, "rules-hint", TRUE, NULL); g_object_unref (store); all_filter = gtk_file_filter_new (); for (list = procedures; list; list = g_slist_next (list)) { GimpPlugInProcedure *proc = list->data; if (! proc->prefixes_list) /* skip URL loaders */ { const gchar *label = gimp_procedure_get_label (GIMP_PROCEDURE (proc)); const gchar *help_id = gimp_procedure_get_help_id (GIMP_PROCEDURE (proc)); GSList *list2; if (label) { GtkFileFilter *filter; filter = gimp_file_proc_view_process_procedure (proc, all_filter); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COLUMN_PROC, proc, COLUMN_LABEL, label, COLUMN_EXTENSIONS, proc->extensions, COLUMN_HELP_ID, help_id, COLUMN_FILTER, filter, -1); g_object_unref (filter); } for (list2 = proc->extensions_list; list2; list2 = g_slist_next (list2)) { GimpFileProcView *proc_view = GIMP_FILE_PROC_VIEW (view); const gchar *ext = list2->data; const gchar *dot = strchr (ext, '.'); if (dot && dot != ext) proc_view->meta_extensions = g_list_append (proc_view->meta_extensions, g_strdup (dot + 1)); } } } if (automatic) { gtk_list_store_prepend (store, &iter); gtk_list_store_set (store, &iter, COLUMN_PROC, NULL, COLUMN_LABEL, automatic, COLUMN_HELP_ID, automatic_help_id, COLUMN_FILTER, all_filter, -1); } column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("File Type")); gtk_tree_view_column_set_expand (column, TRUE); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", COLUMN_LABEL, NULL); gtk_tree_view_append_column (view, column); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Extensions")); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", COLUMN_EXTENSIONS, NULL); gtk_tree_view_append_column (view, column); g_signal_connect (gtk_tree_view_get_selection (view), "changed", G_CALLBACK (gimp_file_proc_view_selection_changed), view); return GTK_WIDGET (view); }
void pragha_filter_dialog (struct con_win *cwin) { GtkWidget *dialog, *scrollwin, *vbox, *search_entry; GtkWidget *filter_view = NULL; GtkListStore *filter_store; GtkTreeModel *filter_model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; PraghaFilterDialog *fdialog; fdialog = g_slice_new0(PraghaFilterDialog); /* Crete the filter entry */ search_entry = pragha_search_entry_new(cwin->preferences); g_signal_connect (G_OBJECT(search_entry), "changed", G_CALLBACK(simple_filter_search_keyrelease_handler), fdialog); g_signal_connect (G_OBJECT(search_entry), "activate", G_CALLBACK(simple_filter_search_activate_handler), fdialog); /* Create the view */ filter_store = gtk_list_store_new (2, G_TYPE_UINT, G_TYPE_STRING); column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "text", 0, NULL); gtk_tree_view_column_set_spacing (column, 4); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "markup", 1, NULL); gtk_tree_view_column_set_spacing (column, 4); /* Fill the filter tree view with current playlist */ pragha_filter_dialog_fill_model(filter_store, cwin->cplaylist); filter_model = gtk_tree_model_filter_new(GTK_TREE_MODEL(filter_store), NULL); g_object_unref(filter_store); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter_model), (GtkTreeModelFilterVisibleFunc)filter_model_visible_func, fdialog, NULL); /* Create the tree view */ filter_view = gtk_tree_view_new_with_model(filter_model); gtk_tree_view_append_column (GTK_TREE_VIEW(filter_view), column); g_object_unref(G_OBJECT(filter_model)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(filter_view), TRUE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(filter_view), FALSE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(filter_view), FALSE); /* Store references */ fdialog->filter_view = filter_view; fdialog->filter_model = filter_model; fdialog->filter_string = NULL; fdialog->timeout_id = 0; fdialog->cplaylist = cwin->cplaylist; fdialog->preferences = pragha_preferences_get(); /* The search dialog */ dialog = gtk_dialog_new_with_buttons (_("_Search in playlist"), GTK_WINDOW(cwin->mainwindow), GTK_DIALOG_MODAL, GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL, NULL); gtk_dialog_add_button (GTK_DIALOG (dialog), _("Add to playback queue"), GTK_RESPONSE_ACCEPT); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_JUMP_TO, GTK_RESPONSE_APPLY); gtk_window_set_default_size (GTK_WINDOW (dialog), 600, 500); /* Add to the dialog's main vbox */ vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_box_pack_start (GTK_BOX(vbox), search_entry, FALSE, FALSE, 3); scrollwin = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER(scrollwin), filter_view); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scrollwin), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0); /* Connect signals */ g_signal_connect (filter_view, "row-activated", G_CALLBACK(pragha_filter_dialog_activated_cb), dialog); g_signal_connect (filter_view, "key_press_event", G_CALLBACK (pragha_filter_dialog_key_press), fdialog); g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(pragha_filter_dialog_response), fdialog); gtk_widget_show_all (dialog); }
/** * create the page 2 of the assistant * this page permit to choose the archive to export * * \param assistant the GtkWidget assistant * * \return a GtkWidget containing the page * */ static GtkWidget *gsb_assistant_archive_export_page_choose ( GtkWidget *assistant ) { GtkWidget *vbox_page, *scrolled_window; GtkWidget *paddingbox; GtkListStore *archive_model; gchar *titles[] = { "", _("Name"), _("Initial date"), _("Final date"), _("Financial year"), _("Report name") }; gfloat alignment[] = { COLUMN_CENTER, COLUMN_LEFT, COLUMN_CENTER, COLUMN_CENTER , COLUMN_CENTER, COLUMN_CENTER }; gint i; GSList *tmp_list; /* create the page */ vbox_page = gtk_vbox_new ( FALSE, 0); gtk_container_set_border_width ( GTK_CONTAINER(vbox_page), 12 ); paddingbox = new_paddingbox_with_title (vbox_page, TRUE, _("Select the archive to export")); /* Create scrolled window */ scrolled_window = gtk_scrolled_window_new ( NULL, NULL ); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW ( scrolled_window ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW ( scrolled_window ), GTK_SHADOW_IN); gtk_box_pack_start ( GTK_BOX (paddingbox), scrolled_window, TRUE, TRUE, 0 ); /* Create tree view */ archive_model = gtk_list_store_new (NUM_ARCHIVES_EXPORT_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT ); archive_export_treeview = gtk_tree_view_new_with_model ( GTK_TREE_MODEL (archive_model) ); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (archive_export_treeview), TRUE); gtk_container_add ( GTK_CONTAINER (scrolled_window), archive_export_treeview ); /* set the columns */ for (i=0 ; i<6 ; i++) { GtkTreeViewColumn *column; GtkCellRenderer *renderer; column = gtk_tree_view_column_new (); gtk_tree_view_column_set_sizing ( column, GTK_TREE_VIEW_COLUMN_AUTOSIZE ); gtk_tree_view_column_set_alignment ( column, alignment[i] ); gtk_tree_view_column_set_title ( column, titles[i] ); gtk_tree_view_column_set_expand ( column, TRUE ); gtk_tree_view_column_set_resizable ( column, TRUE ); if (i) { /* we are on a text column */ renderer = gtk_cell_renderer_text_new (); g_object_set ( G_OBJECT (renderer), "xalign", alignment[i], NULL ); gtk_tree_view_column_pack_start ( column, renderer, TRUE ); gtk_tree_view_column_set_attributes (column, renderer, "text", i, NULL); } else { /* we are on the select column */ renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (gsb_assistant_archive_export_toggled), assistant ); gtk_tree_view_column_pack_start ( column, renderer, TRUE ); gtk_tree_view_column_set_attributes (column, renderer, "active", i, NULL); } gtk_tree_view_append_column ( GTK_TREE_VIEW(archive_export_treeview), column); } /* fill the list */ tmp_list = gsb_data_archive_get_archives_list (); while ( tmp_list ) { gint archive_number; GtkTreeIter iter; gchar *init_date; gchar *final_date; archive_number = gsb_data_archive_get_no_archive (tmp_list -> data); init_date = gsb_format_gdate (gsb_data_archive_get_beginning_date (archive_number)); final_date = gsb_format_gdate (gsb_data_archive_get_end_date (archive_number)); gtk_list_store_append ( GTK_LIST_STORE (archive_model), &iter ); gtk_list_store_set ( GTK_LIST_STORE (archive_model), &iter, ARCHIVES_EXPORT_NAME_COLUMN, gsb_data_archive_get_name (archive_number), ARCHIVES_EXPORT_INIT_DATE, init_date, ARCHIVES_EXPORT_FINAL_DATE, final_date, ARCHIVES_EXPORT_FYEAR_NAME, gsb_data_fyear_get_name (gsb_data_archive_get_fyear (archive_number)), ARCHIVES_EXPORT_REPORT_TITLE, gsb_data_archive_get_report_title (archive_number), ARCHIVES_EXPORT_NUMBER, archive_number, -1 ); if (init_date) g_free (init_date); if (final_date) g_free (final_date); tmp_list = tmp_list -> next; } gtk_widget_show_all (vbox_page); return ( vbox_page ); }
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)); }
GtkTreeSelection *sel = NULL; GtkListStore *liststore = NULL; liststore = gtk_list_store_new (1, G_TYPE_STRING); // 1 column, of type String (this is a vararg list) GuiObject scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); my widget = gtk_tree_view_new_with_model (GTK_TREE_MODEL (liststore)); gtk_container_add (GTK_CONTAINER (scrolled), my widget); gtk_widget_show (scrolled); gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (my widget), allowMultipleSelection ? GTK_SELECTION_MULTIPLE : GTK_SELECTION_SINGLE); g_object_unref (liststore); // Destroys the widget after the list is destroyed _GuiObject_setUserData (my widget, me); /* nog een functie die je niet moet vergeten */ renderer = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_add_attribute (col, renderer, "text", 0); // zeroeth column if (header != NULL) gtk_tree_view_column_set_title (col, Melder_peekWcsToUtf8 (header)); gtk_tree_view_append_column (GTK_TREE_VIEW (my widget), col); g_object_set_data_full (G_OBJECT (my widget), "guiList", me, (GDestroyNotify) _GuiGtkList_destroyCallback); /* GtkCellRenderer *renderer; GtkTreeViewColumn *col; my widget = gtk_tree_view_new_with_model (GTK_TREE_MODEL (liststore)); renderer = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new ();
static void editor_list_window_create(void) { GtkWidget *win_vbox; GtkWidget *hbox; GtkWidget *button; GtkWidget *scrolled; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkTreeModel *store; GtkTreeSortable *sortable; EditorListWindow *ewl; editor_list_window = ewl = g_new0(EditorListWindow, 1); ewl->window = window_new(GTK_WINDOW_TOPLEVEL, "editors", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Plugins")); DEBUG_NAME(ewl->window); gtk_window_set_type_hint(GTK_WINDOW(ewl->window), GDK_WINDOW_TYPE_HINT_DIALOG); g_signal_connect(G_OBJECT(ewl->window), "delete_event", G_CALLBACK(editor_list_window_delete), NULL); gtk_window_set_default_size(GTK_WINDOW(ewl->window), CONFIG_WINDOW_DEF_WIDTH, CONFIG_WINDOW_DEF_HEIGHT); gtk_window_set_resizable(GTK_WINDOW(ewl->window), TRUE); gtk_container_set_border_width(GTK_CONTAINER(ewl->window), PREF_PAD_BORDER); win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE); gtk_container_add(GTK_CONTAINER(ewl->window), win_vbox); gtk_widget_show(win_vbox); hbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP); gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); button = pref_button_new(NULL, GTK_STOCK_HELP, NULL, FALSE, G_CALLBACK(editor_list_window_help_cb), ewl); gtk_container_add(GTK_CONTAINER(hbox), button); gtk_widget_set_can_default(button, TRUE); gtk_widget_show(button); button = pref_button_new(NULL, GTK_STOCK_NEW, NULL, FALSE, G_CALLBACK(editor_list_window_new_cb), ewl); gtk_container_add(GTK_CONTAINER(hbox), button); gtk_widget_set_can_default(button, TRUE); gtk_widget_show(button); button = pref_button_new(NULL, GTK_STOCK_EDIT, NULL, FALSE, G_CALLBACK(editor_list_window_edit_cb), ewl); gtk_container_add(GTK_CONTAINER(hbox), button); gtk_widget_set_can_default(button, TRUE); gtk_widget_set_sensitive(button, FALSE); gtk_widget_show(button); ewl->edit_button = button; button = pref_button_new(NULL, GTK_STOCK_DELETE, NULL, FALSE, G_CALLBACK(editor_list_window_delete_cb), ewl); gtk_container_add(GTK_CONTAINER(hbox), button); gtk_widget_set_can_default(button, TRUE); gtk_widget_set_sensitive(button, FALSE); gtk_widget_show(button); ewl->delete_button = button; button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE, G_CALLBACK(editor_list_window_close_cb), ewl); gtk_container_add(GTK_CONTAINER(hbox), button); gtk_widget_set_can_default(button, TRUE); gtk_widget_show(button); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(win_vbox), scrolled, TRUE, TRUE, 5); gtk_widget_show(scrolled); ewl->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(desktop_file_list)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view)); gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE); g_signal_connect(selection, "changed", G_CALLBACK(editor_list_window_selection_changed_cb), ewl); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ewl->view), FALSE); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Disabled")); gtk_tree_view_column_set_resizable(column, TRUE); renderer = gtk_cell_renderer_toggle_new(); g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(plugin_disable_cb), ewl); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, plugin_disable_set_func, NULL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column); gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_DISABLED); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Name")); gtk_tree_view_column_set_resizable(column, TRUE); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column); gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_NAME); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Hidden")); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_HIDDEN); gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column); gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_HIDDEN); gtk_tree_view_column_set_alignment(column, 0.5); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Desktop file")); gtk_tree_view_column_set_resizable(column, TRUE); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_KEY); gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column); gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_KEY); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Path")); gtk_tree_view_column_set_resizable(column, TRUE); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_PATH); gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column); gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_PATH); /* set up sorting */ store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view)); sortable = GTK_TREE_SORTABLE(store); gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_KEY, editor_list_window_sort_cb, GINT_TO_POINTER(DESKTOP_FILE_COLUMN_KEY), NULL); gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_HIDDEN, editor_list_window_sort_cb, GINT_TO_POINTER(DESKTOP_FILE_COLUMN_HIDDEN), NULL); gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_NAME, editor_list_window_sort_cb, GINT_TO_POINTER(DESKTOP_FILE_COLUMN_NAME), NULL); gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_PATH, editor_list_window_sort_cb, GINT_TO_POINTER(DESKTOP_FILE_COLUMN_PATH), NULL); gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_DISABLED, editor_list_window_sort_cb, GINT_TO_POINTER(DESKTOP_FILE_COLUMN_DISABLED), NULL); /* set initial sort order */ gtk_tree_sortable_set_sort_column_id(sortable, DESKTOP_FILE_COLUMN_NAME, GTK_SORT_ASCENDING); gtk_container_add(GTK_CONTAINER(scrolled), ewl->view); gtk_widget_show(ewl->view); gtk_widget_show(ewl->window); }
static void roster_view_gtk_init (G_GNUC_UNUSED RosterViewGtk* self) { GtkWidget *scrolled_window; GtkWidget *vbox = NULL; GtkTreeModel *filtered = NULL; GtkTreeSelection *selection = NULL; GtkTreeViewColumn *col = NULL; GtkCellRenderer *renderer = NULL; self->priv = new RosterViewGtkPrivate; self->priv->folded_groups = gm_conf_get_string_list (CONTACTS_KEY "roster_folded_groups"); self->priv->show_offline_contacts = gm_conf_get_bool (CONTACTS_KEY "show_offline_contacts"); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_set_border_width (GTK_CONTAINER (vbox), 0); gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 0); gtk_frame_set_shadow_type (GTK_FRAME (self), GTK_SHADOW_NONE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); self->priv->store = gtk_tree_store_new (COLUMN_NUMBER, G_TYPE_INT, // type G_TYPE_POINTER, // heap G_TYPE_POINTER, // presentity G_TYPE_STRING, // name G_TYPE_STRING, // status G_TYPE_STRING, // presence G_TYPE_STRING, // color if active G_TYPE_STRING, // group name (invisible) G_TYPE_STRING, // presence G_TYPE_BOOLEAN, // offline G_TYPE_INT); // timeout source gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->priv->store), COLUMN_NAME, GTK_SORT_ASCENDING); filtered = gtk_tree_model_filter_new (GTK_TREE_MODEL (self->priv->store), NULL); g_object_unref (self->priv->store); self->priv->tree_view = GTK_TREE_VIEW (gtk_tree_view_new_with_model (filtered)); g_object_unref (filtered); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filtered), tree_model_filter_hide_show_offline, self, NULL); gtk_tree_view_set_headers_visible (self->priv->tree_view, FALSE); gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (vbox)); gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (scrolled_window), TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (self->priv->tree_view)); /* Build the GtkTreeView */ // We hide the normal GTK+ expanders and use our own col = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_set_spacing (col, 0); gtk_tree_view_column_pack_start (col, renderer, TRUE); g_object_set (col, "visible", FALSE, NULL); gtk_tree_view_append_column (self->priv->tree_view, col); gtk_tree_view_set_expander_column (self->priv->tree_view, col); col = gtk_tree_view_column_new (); renderer = gm_cell_renderer_expander_new (); gtk_tree_view_column_pack_start (col, renderer, FALSE); g_object_set (renderer, "xalign", 0.0, "xpad", 0, "ypad", 0, "visible", TRUE, "expander-style", GTK_EXPANDER_COLLAPSED, NULL); gtk_tree_view_column_set_cell_data_func (col, renderer, expand_cell_data_func, NULL, NULL); gtk_tree_view_append_column (self->priv->tree_view, col); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_set_spacing (col, 0); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_add_attribute (col, renderer, "text", COLUMN_NAME); gtk_tree_view_column_set_alignment (col, 0.0); g_object_set (renderer, "xalign", 0.5, "ypad", 0, NULL); g_object_set (renderer, "weight", PANGO_WEIGHT_BOLD, NULL); gtk_tree_view_column_set_cell_data_func (col, renderer, show_cell_data_func, GINT_TO_POINTER (TYPE_HEAP), NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_add_attribute (col, renderer, "text", COLUMN_NAME); g_object_set (renderer, "weight", PANGO_WEIGHT_BOLD, NULL); gtk_tree_view_column_set_cell_data_func (col, renderer, show_cell_data_func, GINT_TO_POINTER (TYPE_GROUP), NULL); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "yalign", 0.5, "xpad", 5, NULL); gtk_tree_view_column_pack_start (col, renderer, FALSE); gtk_tree_view_column_add_attribute (col, renderer, "icon-name", COLUMN_PRESENCE_ICON); gtk_tree_view_column_set_cell_data_func (col, renderer, show_cell_data_func, GINT_TO_POINTER (TYPE_PRESENTITY), NULL); renderer = gm_cell_renderer_bitext_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, "width-chars", 30, NULL); gtk_tree_view_column_pack_start (col, renderer, FALSE); gtk_tree_view_column_add_attribute (col, renderer, "primary-text", COLUMN_NAME); gtk_tree_view_column_add_attribute (col, renderer, "secondary-text", COLUMN_STATUS); gtk_tree_view_column_add_attribute (col, renderer, "foreground", COLUMN_ACTIVE); gtk_tree_view_column_set_cell_data_func (col, renderer, show_cell_data_func, GINT_TO_POINTER (TYPE_PRESENTITY), NULL); /* Callback when the selection has been changed */ selection = gtk_tree_view_get_selection (self->priv->tree_view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (on_selection_changed), self); g_signal_connect (self->priv->tree_view, "event-after", G_CALLBACK (on_view_event_after), self); /* Notifiers */ self->priv->notifier = gm_conf_notifier_add (CONTACTS_KEY "show_offline_contacts", show_offline_contacts_changed_nt, self); }
static void set_up (EmpathyIndividualLinker *self) { EmpathyIndividualLinkerPriv *priv; EmpathyIndividualManager *individual_manager; GtkWidget *top_vbox; GtkPaned *paned; GtkWidget *label, *scrolled_window; GtkBox *vbox; EmpathyPersonaView *persona_view; gchar *tmp; GtkWidget *alignment; priv = GET_PRIV (self); top_vbox = gtk_vbox_new (FALSE, 6); /* Layout panes */ paned = GTK_PANED (gtk_hpaned_new ()); /* Left column heading */ alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 0, 6); gtk_widget_show (alignment); vbox = GTK_BOX (gtk_vbox_new (FALSE, 6)); label = gtk_label_new (NULL); tmp = g_strdup_printf ("<b>%s</b>", _("Select contacts to link")); gtk_label_set_markup (GTK_LABEL (label), tmp); g_free (tmp); gtk_box_pack_start (vbox, label, FALSE, TRUE, 0); gtk_widget_show (label); /* Individual selector */ individual_manager = empathy_individual_manager_dup_singleton (); priv->individual_store = empathy_individual_store_new (individual_manager); g_object_unref (individual_manager); empathy_individual_store_set_show_protocols (priv->individual_store, FALSE); priv->individual_view = empathy_individual_view_new (priv->individual_store, EMPATHY_INDIVIDUAL_VIEW_FEATURE_INDIVIDUAL_DRAG | EMPATHY_INDIVIDUAL_VIEW_FEATURE_INDIVIDUAL_DROP | EMPATHY_INDIVIDUAL_VIEW_FEATURE_PERSONA_DROP, EMPATHY_INDIVIDUAL_FEATURE_NONE); empathy_individual_view_set_show_offline (priv->individual_view, TRUE); empathy_individual_view_set_show_untrusted (priv->individual_view, FALSE); g_signal_connect (priv->individual_view, "row-activated", (GCallback) row_activated_cb, self); g_signal_connect (priv->individual_view, "drag-motion", (GCallback) individual_view_drag_motion_cb, self); g_signal_connect (priv->individual_view, "drag-persona-received", (GCallback) individual_view_drag_persona_received_cb, self); /* Add a checkbox column to the selector */ priv->toggle_renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (priv->toggle_renderer, "toggled", (GCallback) row_toggled_cb, self); priv->toggle_column = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (priv->toggle_column, priv->toggle_renderer, FALSE); gtk_tree_view_column_set_cell_data_func (priv->toggle_column, priv->toggle_renderer, (GtkTreeCellDataFunc) contact_toggle_cell_data_func, self, NULL); gtk_tree_view_insert_column (GTK_TREE_VIEW (priv->individual_view), priv->toggle_column, 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (priv->individual_view)); gtk_widget_show (GTK_WIDGET (priv->individual_view)); gtk_box_pack_start (vbox, scrolled_window, TRUE, TRUE, 0); gtk_widget_show (scrolled_window); /* Live search */ priv->search_widget = empathy_live_search_new ( GTK_WIDGET (priv->individual_view)); empathy_individual_view_set_live_search (priv->individual_view, EMPATHY_LIVE_SEARCH (priv->search_widget)); gtk_box_pack_end (vbox, priv->search_widget, FALSE, TRUE, 0); gtk_container_add (GTK_CONTAINER (alignment), GTK_WIDGET (vbox)); gtk_paned_pack1 (paned, alignment, TRUE, FALSE); gtk_widget_show (GTK_WIDGET (vbox)); /* Right column heading */ alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 6, 0); gtk_widget_show (alignment); vbox = GTK_BOX (gtk_vbox_new (FALSE, 6)); label = gtk_label_new (NULL); tmp = g_strdup_printf ("<b>%s</b>", _("New contact preview")); gtk_label_set_markup (GTK_LABEL (label), tmp); g_free (tmp); gtk_box_pack_start (vbox, label, FALSE, TRUE, 0); gtk_widget_show (label); /* New individual preview */ priv->preview_widget = empathy_individual_widget_new (priv->new_individual, EMPATHY_INDIVIDUAL_WIDGET_SHOW_DETAILS); gtk_box_pack_start (vbox, priv->preview_widget, FALSE, TRUE, 0); gtk_widget_show (priv->preview_widget); /* Persona list */ scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN); priv->persona_store = empathy_persona_store_new (priv->new_individual); empathy_persona_store_set_show_protocols (priv->persona_store, TRUE); persona_view = empathy_persona_view_new (priv->persona_store, EMPATHY_PERSONA_VIEW_FEATURE_ALL); empathy_persona_view_set_show_offline (persona_view, TRUE); g_signal_connect (persona_view, "drag-individual-received", (GCallback) persona_view_drag_individual_received_cb, self); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (persona_view)); gtk_widget_show (GTK_WIDGET (persona_view)); gtk_box_pack_start (vbox, scrolled_window, TRUE, TRUE, 0); gtk_widget_show (scrolled_window); gtk_container_add (GTK_CONTAINER (alignment), GTK_WIDGET (vbox)); gtk_paned_pack2 (paned, alignment, TRUE, FALSE); gtk_widget_show (GTK_WIDGET (vbox)); gtk_widget_show (GTK_WIDGET (paned)); /* Footer label */ label = gtk_label_new (NULL); tmp = g_strdup_printf ("<i>%s</i>", _("Contacts selected in the list on the left will be linked together.")); gtk_label_set_markup (GTK_LABEL (label), tmp); g_free (tmp); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (top_vbox), GTK_WIDGET (paned), TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (top_vbox), label, FALSE, TRUE, 0); /* Add the main vbox to the bin */ gtk_box_pack_start (GTK_BOX (self), GTK_WIDGET (top_vbox), TRUE, TRUE, 0); gtk_widget_show (GTK_WIDGET (top_vbox)); }
inline static void show_autorun_dlg(GVolume* vol, GMount* mount) { GtkBuilder* builder; GtkTreeIter it; GtkTreeViewColumn* col; GtkTreeSelection* tree_sel; GtkCellRenderer*render; GtkImage* icon; GIcon* gicon; AutoRun* data; data = g_slice_new(AutoRun); data->cancel = g_cancellable_new(); builder = gtk_builder_new(); gtk_builder_add_from_file(builder, PACKAGE_UI_DIR "/autorun.glade", NULL); data->dlg = GTK_DIALOG(gtk_builder_get_object(builder, "dlg")); data->view = GTK_TREE_VIEW(gtk_builder_get_object(builder, "listview")); data->type = GTK_LABEL(gtk_builder_get_object(builder, "type")); icon = GTK_IMAGE(gtk_builder_get_object(builder, "icon")); g_object_unref(builder); gicon = g_volume_get_icon(vol); gtk_image_set_from_gicon(icon, gicon, GTK_ICON_SIZE_DIALOG); g_object_unref(gicon); gtk_dialog_set_default_response(data->dlg, GTK_RESPONSE_OK); gtk_dialog_set_alternative_button_order(data->dlg, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); tree_sel = gtk_tree_view_get_selection(data->view); gtk_tree_selection_set_mode(tree_sel, GTK_SELECTION_BROWSE); col = gtk_tree_view_column_new(); render = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(col, render, FALSE); gtk_tree_view_column_set_attributes(col, render, "gicon", 0, NULL); render = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, render, FALSE); gtk_tree_view_column_set_attributes(col, render, "text", 1, NULL); gtk_tree_view_append_column(data->view, col); data->store = gtk_list_store_new(3, G_TYPE_ICON, G_TYPE_STRING, G_TYPE_OBJECT); data->mount = (GMount*)g_object_ref(mount); gtk_list_store_append(data->store, &it); gicon = g_themed_icon_new("system-file-manager"); gtk_list_store_set(data->store, &it, 0, gicon, 1, _("Open in File Manager"), -1); g_object_unref(gicon); gtk_tree_view_set_model(data->view, GTK_TREE_MODEL(data->store)); gtk_tree_model_get_iter_first(GTK_TREE_MODEL(data->store), &it); gtk_tree_selection_select_iter(tree_sel, &it); g_signal_connect(data->view, "row-activated", G_CALLBACK(on_row_activated), data); g_signal_connect(data->dlg, "response", G_CALLBACK(on_dlg_response), data); g_signal_connect(data->mount, "unmounted", G_CALLBACK(on_unmount), data); gtk_window_set_keep_above(GTK_WINDOW(data->dlg), TRUE); gtk_window_present(GTK_WINDOW(data->dlg)); g_mount_guess_content_type(mount, TRUE, data->cancel, on_content_type_finished, data); pcmanfm_ref(); }
/* * inits stack trace tree */ GtkWidget* stree_init(move_to_line_cb cb) { callback = cb; /* create tree view */ store = gtk_tree_store_new ( S_N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT); model = GTK_TREE_MODEL(store); tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store)); /* set tree view properties */ gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), 1); gtk_widget_set_has_tooltip(tree, TRUE); gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE); /* connect signals */ selection_callback = g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree))), "changed", G_CALLBACK (on_selection_changed), NULL); /* for clicking on already selected frame */ g_signal_connect(G_OBJECT(tree), "button-press-event", G_CALLBACK(on_msgwin_button_press), NULL); g_signal_connect(G_OBJECT(tree), "query-tooltip", G_CALLBACK (on_query_tooltip), NULL); /* creating columns */ GtkTreeViewColumn *column; /* address */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Address")); GtkCellRenderer *renderer_arrow = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start(column, renderer_arrow, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer_arrow, on_render_icon, NULL, NULL); GtkCellRenderer *renderer_address = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start(column, renderer_address, TRUE); gtk_tree_view_column_set_attributes(column, renderer_address, "text", S_ADRESS, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); /* function */ GtkCellRenderer *renderer_function = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Function"), renderer_function, "text", S_FUNCTION, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); /* file */ GtkCellRenderer *renderer_file = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("File"), renderer_file, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); gtk_tree_view_column_set_cell_data_func(column, renderer_file, on_render_filename, NULL, NULL); /* line */ GtkCellRenderer *renderer_line = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Line"), renderer_line, "text", S_LINE, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer_line, on_render_line, NULL, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); /* Last invisible column */ GtkCellRenderer *renderer_last = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("", renderer_last, "text", S_LAST_VISIBLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); /* create threads hash table */ threads = g_hash_table_new_full( g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)gtk_tree_row_reference_free ); return tree; }
static void pluma_documents_panel_init (PlumaDocumentsPanel *panel) { GtkWidget *sw; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkTreeSelection *selection; panel->priv = PLUMA_DOCUMENTS_PANEL_GET_PRIVATE (panel); panel->priv->adding_tab = FALSE; panel->priv->is_reodering = FALSE; /* Create the scrolled window */ sw = gtk_scrolled_window_new (NULL, NULL); g_return_if_fail (sw != NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_widget_show (sw); gtk_box_pack_start (GTK_BOX (panel), sw, TRUE, TRUE, 0); /* Create the empty model */ panel->priv->model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER)); /* Create the treeview */ panel->priv->treeview = gtk_tree_view_new_with_model (panel->priv->model); g_object_unref (G_OBJECT (panel->priv->model)); gtk_container_add (GTK_CONTAINER (sw), panel->priv->treeview); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (panel->priv->treeview), FALSE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (panel->priv->treeview), TRUE); g_object_set (panel->priv->treeview, "has-tooltip", TRUE, NULL); gtk_widget_show (panel->priv->treeview); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Documents")); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_add_attribute (column, cell, "pixbuf", PIXBUF_COLUMN); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "markup", NAME_COLUMN); gtk_tree_view_append_column (GTK_TREE_VIEW (panel->priv->treeview), column); selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW (panel->priv->treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (panel->priv->treeview, "cursor_changed", G_CALLBACK (treeview_cursor_changed), panel); g_signal_connect (panel->priv->treeview, "button-press-event", G_CALLBACK (panel_button_press_event), panel); g_signal_connect (panel->priv->treeview, "popup-menu", G_CALLBACK (panel_popup_menu), panel); g_signal_connect (panel->priv->treeview, "query-tooltip", G_CALLBACK (treeview_query_tooltip), NULL); g_signal_connect (panel->priv->model, "row-inserted", G_CALLBACK (treeview_row_inserted), panel); }
static void sdb_view_locals_init (SymbolDBViewLocals *dbvl) { GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeStore *store; SymbolDBViewLocalsPriv *priv; g_return_if_fail (dbvl != NULL); /*DEBUG_PRINT ("%s", "sdb_view_locals_init ()");*/ dbvl->priv = g_new0 (SymbolDBViewLocalsPriv, 1); priv = dbvl->priv; priv->current_db_file = NULL; priv->current_local_file_path = NULL; priv->nodes_displayed = NULL; priv->waiting_for = NULL; priv->nodes_not_yet_removed = g_tree_new_full ((GCompareDataFunc)&symbol_db_gtree_compare_func, NULL, NULL, NULL); priv->symbols_inserted_ids = NULL; priv->insert_handler = 0; priv->scan_end_handler = 0; priv->remove_handler = 0; priv->scope_update_handler = 0; priv->insertion_idle_handler = 0; priv->files_view_status = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify)file_view_status_destroy); priv->recv_signals = FALSE; priv->display_nothing = FALSE; /* initially set it to NULL */ store = NULL; gtk_tree_view_set_model (GTK_TREE_VIEW (dbvl), GTK_TREE_MODEL (store)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dbvl), FALSE); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dbvl)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /* search through the tree interactively */ gtk_tree_view_set_enable_search (GTK_TREE_VIEW (dbvl), TRUE); gtk_tree_view_set_search_column (GTK_TREE_VIEW (dbvl), COLUMN_NAME); gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (dbvl), sdb_view_locals_search_equal_func, NULL, NULL); /* Columns */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_title (column, _("Symbol")); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", COLUMN_PIXBUF); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "text", COLUMN_NAME); gtk_tree_view_append_column (GTK_TREE_VIEW (dbvl), column); gtk_tree_view_set_expander_column (GTK_TREE_VIEW (dbvl), column); /* gtk 2.12 * gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (dbvl), FALSE); */ }
static GtkWidget * create_field_page(GtkWidget *tree, const char* text) { GtkWidget *vbox; GtkWidget *scrolled; GtkWidget *label; GtkWidget *treeview; GList *it, *columns; GtkListStore *model; GtkTreeViewColumn *column; GtkCellRenderer *cell; vbox = gtk_vbox_new (FALSE, 6); label = gtk_label_new_with_mnemonic (text); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0); model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_container_add (GTK_CONTAINER (scrolled), treeview); g_object_unref (G_OBJECT (model)); gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview); column = gtk_tree_view_column_new (); cell = gtk_cell_renderer_toggle_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "active", 0, NULL); g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (field_toggled), model); gtk_tree_view_column_set_clickable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); column = gtk_tree_view_column_new (); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "text", 1, NULL); gtk_tree_view_column_set_title (column, "Not Shown"); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree)); for(it = columns; it; it = it->next) { GtkTreeViewColumn *column = static_cast<GtkTreeViewColumn*>(it->data); GtkTreeIter iter; const gchar *title; gboolean visible; title = gtk_tree_view_column_get_title (column); if (!title) title = _("Icon"); visible = gtk_tree_view_column_get_visible (column); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, 0, visible, 1, title, 2, column,-1); } g_list_free(columns); return vbox; }
GtkWidget * gimp_action_view_new (GimpUIManager *manager, const gchar *select_action, gboolean show_shortcuts) { GtkTreeView *view; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkTreeStore *store; GtkTreeModel *filter; GtkAccelGroup *accel_group; GList *list; GtkTreePath *select_path = NULL; g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), NULL); store = gtk_tree_store_new (GIMP_ACTION_VIEW_N_COLUMNS, G_TYPE_BOOLEAN, /* COLUMN_VISIBLE */ GTK_TYPE_ACTION, /* COLUMN_ACTION */ G_TYPE_STRING, /* COLUMN_STOCK_ID */ G_TYPE_STRING, /* COLUMN_LABEL */ G_TYPE_STRING, /* COLUMN_LABEL_CASEFOLD */ G_TYPE_STRING, /* COLUMN_NAME */ G_TYPE_UINT, /* COLUMN_ACCEL_KEY */ GDK_TYPE_MODIFIER_TYPE, /* COLUMN_ACCEL_MASK */ G_TYPE_CLOSURE); /* COLUMN_ACCEL_CLOSURE */ accel_group = gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (manager)); for (list = gtk_ui_manager_get_action_groups (GTK_UI_MANAGER (manager)); list; list = g_list_next (list)) { GimpActionGroup *group = list->data; GList *actions; GList *list2; GtkTreeIter group_iter; gtk_tree_store_append (store, &group_iter, NULL); gtk_tree_store_set (store, &group_iter, GIMP_ACTION_VIEW_COLUMN_STOCK_ID, group->stock_id, GIMP_ACTION_VIEW_COLUMN_LABEL, group->label, -1); actions = gtk_action_group_list_actions (GTK_ACTION_GROUP (group)); actions = g_list_sort (actions, (GCompareFunc) gimp_action_name_compare); for (list2 = actions; list2; list2 = g_list_next (list2)) { GtkAction *action = list2->data; const gchar *name = gtk_action_get_name (action); const gchar *stock_id = gtk_action_get_stock_id (action); gchar *label; gchar *label_casefold; guint accel_key = 0; GdkModifierType accel_mask = 0; GClosure *accel_closure = NULL; GtkTreeIter action_iter; const gchar *tooltip = gtk_action_get_tooltip (action); if (strstr (name, "-menu") || strstr (name, "-popup") || name[0] == '<') continue; label = gimp_strip_uline (gtk_action_get_label (action)); tito_search(name,label,tooltip,action); if (! (label && strlen (label))) { g_free (label); label = g_strdup (name); } label_casefold = g_utf8_casefold (label, -1); if (show_shortcuts) { accel_closure = gtk_action_get_accel_closure (action); if (accel_closure) { GtkAccelKey *key; key = gtk_accel_group_find (accel_group, gimp_action_view_accel_find_func, accel_closure); if (key && key->accel_key && key->accel_flags & GTK_ACCEL_VISIBLE) { accel_key = key->accel_key; accel_mask = key->accel_mods; } } } gtk_tree_store_append (store, &action_iter, &group_iter); gtk_tree_store_set (store, &action_iter, GIMP_ACTION_VIEW_COLUMN_VISIBLE, TRUE, GIMP_ACTION_VIEW_COLUMN_ACTION, action, GIMP_ACTION_VIEW_COLUMN_STOCK_ID, stock_id, GIMP_ACTION_VIEW_COLUMN_LABEL, label, GIMP_ACTION_VIEW_COLUMN_LABEL_CASEFOLD, label_casefold, GIMP_ACTION_VIEW_COLUMN_NAME, name, GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY, accel_key, GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK, accel_mask, GIMP_ACTION_VIEW_COLUMN_ACCEL_CLOSURE, accel_closure, -1); g_free (label); g_free (label_casefold); if (select_action && ! strcmp (select_action, name)) { select_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &action_iter); } } g_list_free (actions); } filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL); g_object_unref (store); view = g_object_new (GIMP_TYPE_ACTION_VIEW, "model", filter, "rules-hint", TRUE, NULL); g_object_unref (filter); gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter), GIMP_ACTION_VIEW_COLUMN_VISIBLE); GIMP_ACTION_VIEW (view)->manager = g_object_ref (manager); GIMP_ACTION_VIEW (view)->show_shortcuts = show_shortcuts; gtk_tree_view_set_search_column (GTK_TREE_VIEW (view), GIMP_ACTION_VIEW_COLUMN_LABEL); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Action")); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "stock-id", GIMP_ACTION_VIEW_COLUMN_STOCK_ID, NULL); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", GIMP_ACTION_VIEW_COLUMN_LABEL, NULL); gtk_tree_view_append_column (view, column); if (show_shortcuts) { g_signal_connect (view, "button-press-event", G_CALLBACK (gimp_action_view_button_press), NULL); g_signal_connect (accel_group, "accel-changed", G_CALLBACK (gimp_action_view_accel_changed), view); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Shortcut")); cell = gtk_cell_renderer_accel_new (); g_object_set (cell, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, "editable", TRUE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "accel-key", GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY, "accel-mods", GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK, NULL); g_signal_connect (cell, "accel-edited", G_CALLBACK (gimp_action_view_accel_edited), view); g_signal_connect (cell, "accel-cleared", G_CALLBACK (gimp_action_view_accel_cleared), view); gtk_tree_view_append_column (view, column); } column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Name")); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", GIMP_ACTION_VIEW_COLUMN_NAME, NULL); gtk_tree_view_append_column (view, column); if (select_path) { gimp_action_view_select_path (GIMP_ACTION_VIEW (view), select_path); gtk_tree_path_free (select_path); } return GTK_WIDGET (view); }