static void cheese_thumb_view_constructed (GObject *object) { CheeseThumbView *thumb_view = CHEESE_THUMB_VIEW (object); CheeseThumbViewPrivate *priv = cheese_thumb_view_get_instance_private (thumb_view); G_OBJECT_CLASS (cheese_thumb_view_parent_class)->constructed (object); gtk_icon_view_set_model (GTK_ICON_VIEW (thumb_view), GTK_TREE_MODEL (priv->store)); gtk_widget_set_size_request (GTK_WIDGET (thumb_view), THUMB_VIEW_MINIMUM_WIDTH, THUMB_VIEW_MINIMUM_HEIGHT); gtk_icon_view_set_margin (GTK_ICON_VIEW (thumb_view), 0); gtk_icon_view_set_row_spacing (GTK_ICON_VIEW (thumb_view), 0); gtk_icon_view_set_column_spacing (GTK_ICON_VIEW (thumb_view), 0); gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (thumb_view), 0); gtk_icon_view_set_columns (GTK_ICON_VIEW (thumb_view), -1); gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW (thumb_view), GDK_BUTTON1_MASK, target_table, G_N_ELEMENTS (target_table), GDK_ACTION_COPY); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (thumb_view), GTK_SELECTION_MULTIPLE); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (priv->store), THUMBNAIL_BASENAME_URL_COLUMN, GTK_SORT_ASCENDING); cheese_thumb_view_fill (thumb_view); cheese_thumb_view_set_vertical (thumb_view, FALSE); }
static void attachment_bar_set_store (EAttachmentBar *bar, EAttachmentStore *store) { g_return_if_fail (E_IS_ATTACHMENT_STORE (store)); bar->priv->model = g_object_ref (store); gtk_icon_view_set_model ( GTK_ICON_VIEW (bar->priv->icon_view), bar->priv->model); gtk_tree_view_set_model ( GTK_TREE_VIEW (bar->priv->tree_view), bar->priv->model); e_signal_connect_notify_object ( bar->priv->model, "notify::num-attachments", G_CALLBACK (attachment_bar_update_status), bar, G_CONNECT_SWAPPED); e_signal_connect_notify_object ( bar->priv->model, "notify::total-size", G_CALLBACK (attachment_bar_update_status), bar, G_CONNECT_SWAPPED); /* Initialize */ attachment_bar_update_status (bar); }
JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkIconView_gtk_1icon_1view_1set_1model ( JNIEnv* env, jclass cls, jlong _self, jlong _model ) { GtkIconView* self; GtkTreeModel* model; // convert parameter self self = (GtkIconView*) _self; // convert parameter model model = (GtkTreeModel*) _model; // call function gtk_icon_view_set_model(self, model); // cleanup parameter self // cleanup parameter model }
// Iconview Dialog static void mud_connections_show_icon_dialog(MudConnections *conn) { GladeXML *glade; gint result; glade = glade_xml_new(GLADEDIR "/muds.glade", "iconselect", NULL); conn->priv->icon_dialog = glade_xml_get_widget(glade, "iconselect"); conn->priv->icon_dialog_view = glade_xml_get_widget(glade, "view"); conn->priv->icon_dialog_chooser = glade_xml_get_widget(glade, "chooser"); g_object_unref(glade); conn->priv->icon_dialog_view_model = GTK_TREE_MODEL(gtk_list_store_new(MODEL_COLUMN_N, G_TYPE_STRING, GDK_TYPE_PIXBUF)); gtk_icon_view_set_model(GTK_ICON_VIEW(conn->priv->icon_dialog_view), conn->priv->icon_dialog_view_model); gtk_icon_view_set_text_column( GTK_ICON_VIEW(conn->priv->icon_dialog_view), MODEL_COLUMN_STRING); gtk_icon_view_set_pixbuf_column( GTK_ICON_VIEW(conn->priv->icon_dialog_view), MODEL_COLUMN_PIXBUF); if(conn->priv->icon_current != NULL) g_free(conn->priv->icon_current); conn->priv->icon_current = NULL; g_signal_connect( conn->priv->icon_dialog_chooser, "current-folder-changed", G_CALLBACK(mud_connections_icon_fileset_cb), conn); g_signal_connect(conn->priv->icon_dialog_view, "selection-changed", G_CALLBACK(mud_connections_icon_select_cb), conn); g_object_set(conn->priv->icon_dialog_view, "item-width", 64, NULL); gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(conn->priv->icon_dialog_chooser), "/usr/share/icons"); result = gtk_dialog_run(GTK_DIALOG(conn->priv->icon_dialog)); gtk_widget_destroy(conn->priv->icon_dialog); if(result == GTK_RESPONSE_OK) { if(conn->priv->icon_current == NULL) return; GdkPixbuf *icon = gdk_pixbuf_new_from_file_at_size( conn->priv->icon_current, 48, 48, NULL); gtk_image_set_from_pixbuf(GTK_IMAGE(conn->priv->icon_image), icon); g_object_unref(icon); } }
/* * Set up the model and attach it to the GtkIconView. */ static void populate_model(char *dir, GtkIconView *icon_view) { GtkListStore *model; model = populated_model(dir); gtk_icon_view_set_model(icon_view, GTK_TREE_MODEL(model)); g_object_unref(model); }
/* Add a page in the project notebook */ static void cb_druid_insert_project_page (gpointer value, gpointer user_data) { NPWDruid* druid = (NPWDruid*)user_data; GtkBuilder *builder; GtkWidget* label; GtkWidget* child; GtkWidget* assistant; GtkIconView* view; GtkNotebook *book; GtkListStore *store; GList *template_list = (GList *)value; const gchar* category; category = npw_header_get_category ((NPWHeader *)template_list->data); /* Build another complete wizard dialog from the gtk builder file * but keep only the project selection notebook page */ builder = gtk_builder_new (); if (!gtk_builder_add_from_file (builder, GTK_BUILDER_UI_FILE, NULL)) { g_warn_if_reached (); g_object_unref (builder); return; } /* Fill icon view */ view = GTK_ICON_VIEW (gtk_builder_get_object (builder, PROJECT_LIST)); gtk_icon_view_set_pixbuf_column (view, PIXBUF_COLUMN); gtk_icon_view_set_markup_column (view, TEXT_COLUMN); store = gtk_list_store_new (4, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); g_list_foreach (template_list, cb_druid_insert_project_icon, store); gtk_icon_view_set_model (view, GTK_TREE_MODEL (store)); /* Connect signal to update dialog */ g_signal_connect (G_OBJECT (view), "selection-changed", G_CALLBACK (on_druid_project_update_selected), druid); g_signal_connect (G_OBJECT (view), "map", G_CALLBACK (on_druid_project_update_selected), druid); g_signal_connect_swapped (G_OBJECT (view), "item-activated", G_CALLBACK (gtk_assistant_next_page), druid->window); /* Set new page label */ assistant = GTK_WIDGET (gtk_builder_get_object (builder, NEW_PROJECT_DIALOG)); book = GTK_NOTEBOOK (gtk_builder_get_object (builder, PROJECT_BOOK)); child = gtk_notebook_get_nth_page (book, 0); label = gtk_notebook_get_tab_label (book, child); gtk_label_set_text (GTK_LABEL(label), (const gchar *)category); /* Pick up the filled project selection page from the newly created dialog * add it to the wizard project notebook and destroy the dialog */ gtk_notebook_remove_page (book, 0); gtk_notebook_append_page (druid->project_book, child, label); gtk_widget_destroy (assistant); g_object_unref (builder); }
static void hcp_app_view_add_category (HCPCategory *category, HCPAppView *view) { /* If a group has items */ if (category->apps) { GtkWidget *grid, *separator; GtkListStore *store; GList *focus_chain = NULL; grid = hcp_app_view_create_grid (); store = hcp_app_view_create_store (); g_signal_connect (grid, "item-activated", G_CALLBACK (hcp_app_view_launch_app), NULL); /* If we are creating a group with a defined name, we use * it in the separator */ separator = hcp_app_view_create_separator (_(category->name)); gtk_box_pack_start (GTK_BOX (view), separator, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (view), GTK_WIDGET(grid), FALSE, FALSE, 0); gtk_container_get_focus_chain (GTK_CONTAINER (view), &focus_chain); focus_chain = g_list_append (focus_chain, grid); gtk_container_set_focus_chain (GTK_CONTAINER (view), focus_chain); g_list_free (focus_chain); gtk_icon_view_set_model (GTK_ICON_VIEW (grid), GTK_TREE_MODEL (store)); g_slist_foreach (category->apps, (GFunc) hcp_app_view_add_app, grid); hcp_grid_refresh_icons (HCP_GRID(grid)); /* first group */ if (!view->priv->first_grid) view->priv->first_grid = grid; } }
static void source_changed_cb (GtkComboBox *combo, CcBackgroundPanelPrivate *priv) { GtkTreeIter iter; GtkTreeModel *model; GtkIconView *view; guint type; BgSource *source; gtk_combo_box_get_active_iter (combo, &iter); model = gtk_combo_box_get_model (combo); gtk_tree_model_get (model, &iter, COL_SOURCE_TYPE, &type, COL_SOURCE, &source, -1); view = (GtkIconView *) gtk_builder_get_object (priv->builder, "backgrounds-iconview"); gtk_icon_view_set_model (view, GTK_TREE_MODEL (bg_source_get_liststore (source))); }
void toolbar2___::init__(GtkWidget* box1, icon_item___* item) { if(item->is_init_) return; item->is_init_ = true; init1__(box1, item); GtkWidget *view = gtk_icon_view_new(); item->widget_ = view; GtkIconView *view2 = item->icon_view__(); gtk_container_add(item->container__(),view); gtk_icon_view_set_item_width (view2, 0); g_signal_connect (view, "selection-changed", G_CALLBACK (selection_changed__), NULL); g_signal_connect (view, "item-activated", G_CALLBACK (item_activated__), NULL); init2__(item); GtkListStore *store = gtk_list_store_new (COLUMNS, G_TYPE_INT, GDK_TYPE_PIXBUF, G_TYPE_STRING); item->store_ = store; gtk_icon_view_set_model (view2, item->model__()); gtk_icon_view_set_pixbuf_column (view2, PIXBUF_COLUMN); //gtk_icon_view_set_text_column (view2, TITLE_COLUMN); gtk_icon_view_set_markup_column (view2, TITLE_COLUMN); }
static GtkWidget * simple_iconview (void) { GtkTreeModel *model; GtkWidget *iconview; GtkCellArea *area; GtkCellRenderer *renderer; iconview = gtk_icon_view_new (); gtk_widget_show (iconview); model = simple_list_model (); gtk_icon_view_set_model (GTK_ICON_VIEW (iconview), model); gtk_icon_view_set_item_orientation (GTK_ICON_VIEW (iconview), GTK_ORIENTATION_HORIZONTAL); area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (iconview)); cell_1 = renderer = gtk_cell_renderer_text_new (); gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, FALSE, FALSE, FALSE); gtk_cell_area_attribute_connect (area, renderer, "text", SIMPLE_COLUMN_NAME); cell_2 = renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (G_OBJECT (renderer), "xalign", 0.0F, NULL); gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, TRUE, FALSE, FALSE); gtk_cell_area_attribute_connect (area, renderer, "icon-name", SIMPLE_COLUMN_ICON); cell_3 = renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "wrap-mode", PANGO_WRAP_WORD, "wrap-width", 215, NULL); gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, FALSE, TRUE, FALSE); gtk_cell_area_attribute_connect (area, renderer, "text", SIMPLE_COLUMN_DESCRIPTION); return iconview; }
/* The main GUI function for saving multi-paged PDFs */ static gboolean gui_multi (void) { GtkWidget *window; GtkWidget *vbox; GtkWidget *file_label; GtkWidget *file_entry; GtkWidget *file_browse; GtkWidget *file_hbox; GtkWidget *vectorize_c; GtkWidget *ignore_hidden_c; GtkWidget *apply_c; GtkWidget *scroll; GtkWidget *page_view; GtkWidget *h_but_box; GtkWidget *del; GtkWidget *h_box; GtkWidget *img_combo; GtkWidget *add_image; gboolean run; const gchar *temp; gimp_ui_init (PLUG_IN_BINARY, FALSE); window = gimp_export_dialog_new ("PDF", PLUG_IN_ROLE, SAVE_MULTI_PROC); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10); gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (window)), vbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (window), 12); file_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); file_label = gtk_label_new (_("Save to:")); file_entry = gtk_entry_new (); if (file_name != NULL) gtk_entry_set_text (GTK_ENTRY (file_entry), file_name); file_browse = gtk_button_new_with_label (_("Browse...")); file_choose = gtk_file_chooser_dialog_new (_("Multipage PDF export"), GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_SAVE, "gtk-save", GTK_RESPONSE_OK, "gtk-cancel", GTK_RESPONSE_CANCEL, NULL); gtk_box_pack_start (GTK_BOX (file_hbox), file_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (file_hbox), file_entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (file_hbox), file_browse, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), file_hbox, TRUE, TRUE, 0); page_view = gtk_icon_view_new (); model = create_model (); gtk_icon_view_set_model (GTK_ICON_VIEW (page_view), model); gtk_icon_view_set_reorderable (GTK_ICON_VIEW (page_view), TRUE); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (page_view), GTK_SELECTION_MULTIPLE); gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (page_view), THUMB); gtk_icon_view_set_text_column (GTK_ICON_VIEW (page_view), PAGE_NUMBER); gtk_icon_view_set_tooltip_column (GTK_ICON_VIEW (page_view), IMAGE_NAME); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (scroll, -1, 300); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add (GTK_CONTAINER (scroll), page_view); gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 0); h_but_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout (GTK_BUTTON_BOX (h_but_box), GTK_BUTTONBOX_START); del = gtk_button_new_with_label (_("Remove the selected pages")); gtk_box_pack_start (GTK_BOX (h_but_box), del, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), h_but_box, FALSE, FALSE, 0); h_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); img_combo = gimp_image_combo_box_new (NULL, NULL); gtk_box_pack_start (GTK_BOX (h_box), img_combo, FALSE, FALSE, 0); add_image = gtk_button_new_with_label (_("Add this image")); gtk_box_pack_start (GTK_BOX (h_box), add_image, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), h_box, FALSE, FALSE, 0); ignore_hidden_c = gtk_check_button_new_with_label (_("Omit hidden layers and layers with zero opacity")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ignore_hidden_c), optimize.ignore_hidden); gtk_box_pack_end (GTK_BOX (vbox), ignore_hidden_c, FALSE, FALSE, 0); vectorize_c = gtk_check_button_new_with_label (_("Convert bitmaps to vector graphics where possible")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (vectorize_c), optimize.vectorize); gtk_box_pack_end (GTK_BOX (vbox), vectorize_c, FALSE, FALSE, 0); apply_c = gtk_check_button_new_with_label (_("Apply layer masks before saving")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (apply_c), optimize.apply_masks); gtk_box_pack_end (GTK_BOX (vbox), apply_c, FALSE, FALSE, 0); gimp_help_set_help_data (apply_c, _("Keeping the masks will not change the output"), NULL); gtk_widget_show_all (window); g_signal_connect (G_OBJECT (file_browse), "clicked", G_CALLBACK (choose_file_call), G_OBJECT (file_entry)); g_signal_connect (G_OBJECT (add_image), "clicked", G_CALLBACK (add_image_call), G_OBJECT (img_combo)); g_signal_connect (G_OBJECT (del), "clicked", G_CALLBACK (del_image_call), G_OBJECT (page_view)); g_signal_connect (G_OBJECT (model), "row-deleted", G_CALLBACK (remove_call), NULL); run = gtk_dialog_run (GTK_DIALOG (window)) == GTK_RESPONSE_OK; run &= get_image_list (); temp = gtk_entry_get_text (GTK_ENTRY (file_entry)); g_stpcpy (file_name, temp); optimize.ignore_hidden = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ignore_hidden_c)); optimize.vectorize = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (vectorize_c)); optimize.apply_masks = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (apply_c)); gtk_widget_destroy (window); return run; }
/** * remplit le modèle qu'il crée et attache au GtkIconView * * \param nom de l'icône initiale ou NULL * * \return un GtkTreePath qui donne la position de l'icône passée * en paramètre * */ GtkTreePath * gsb_select_icon_fill_icon_view ( gchar * name_icon ) { GDir *dir; GError *error = NULL; GtkTreePath *tree_path = NULL; devel_debug ( path_icon ); dir = g_dir_open ( path_icon, 0, &error ); if ( dir ) { GtkListStore *store; GtkTreeIter iter; GdkPixbuf *pixbuf; GSList *liste = NULL; gint i = 0; const gchar *name = NULL; while ( (name = g_dir_read_name ( dir ) ) ) { liste = g_slist_append ( liste, g_strdup ( name ) ); } liste = g_slist_sort ( liste, (GCompareFunc) my_strcasecmp ); store = gtk_list_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER); while ( liste ) { gchar *tmpstr = g_strconcat ( path_icon, G_DIR_SEPARATOR_S, liste -> data, NULL ); if ( g_strcmp0 ( tmpstr, name_icon ) == 0 ) { gchar *tmpstr = utils_str_itoa ( i ); tree_path = gtk_tree_path_new_from_string ( tmpstr ); g_free ( tmpstr ); } pixbuf = gdk_pixbuf_new_from_file_at_size ( tmpstr, 32, 32, NULL); if ( pixbuf ) { gchar *tmpstr; gtk_list_store_append ( store, &iter ); tmpstr = gsb_select_icon_troncate_name_icon ( liste -> data, 10 ); gtk_list_store_set (store, &iter, PIXBUF_COLUMN, pixbuf, TEXT_COLUMN, tmpstr, -1); g_free ( tmpstr ); g_object_unref (pixbuf); } g_free ( tmpstr ); liste = liste -> next; i++; } gtk_icon_view_set_model (GTK_ICON_VIEW ( icon_view ), GTK_TREE_MODEL (store)); g_dir_close ( dir ); } else { dialogue_error ( error -> message ); g_error_free ( error ); } if ( tree_path == NULL ) tree_path = gtk_tree_path_new_from_string ( "0" ); return tree_path; }
/* * Set up the window: build the interface, connect the signals, insert the * file icons. */ static GtkWidget * prepare_window(char *dir, struct geometry *geometry, struct state *d) { GtkBuilder *builder; GtkWidget *icons, *window, *directory_close, *file_open; GtkWidget *directory_up, *directory_open, *help_about; GtkListStore *model; builder = gtk_builder_new_from_file(INTERFACE_PATH); window = GTK_WIDGET(gtk_builder_get_object(builder, "window")); icons = GTK_WIDGET(gtk_builder_get_object(builder, "icons")); directory_up = GTK_WIDGET(gtk_builder_get_object(builder, "directory-up-menu-item")); directory_open = GTK_WIDGET(gtk_builder_get_object(builder, "directory-open-menu-item")); directory_close = GTK_WIDGET(gtk_builder_get_object(builder, "directory-close-menu-item")); file_open = GTK_WIDGET(gtk_builder_get_object(builder, "file-open-menu-item")); help_about = GTK_WIDGET(gtk_builder_get_object(builder, "help-about-menu-item")); d->icon_view = GTK_ICON_VIEW(icons); g_object_unref(builder); gtk_window_set_default_size(GTK_WINDOW(window), geometry->w, geometry->h); gtk_window_move(GTK_WINDOW(window), geometry->x, geometry->y); gtk_window_set_title(GTK_WINDOW(window), dir); model = gtk_list_store_new(MODEL_CNT, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT); if (populate(model, dir) == -1) err(66, "failed to populate icon model from %s", dir); watch_dir(model, dir); gtk_icon_view_set_text_column(GTK_ICON_VIEW(icons), 0); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(icons), 1); gtk_icon_view_set_model(GTK_ICON_VIEW(icons), GTK_TREE_MODEL(model)); g_object_unref(model); gtk_widget_set_sensitive(directory_up, strlen(d->dir) > 1); /* Drag */ gtk_drag_source_set(icons, GDK_BUTTON1_MASK, dnd_targets, TARGET_COUNT, GDK_ACTION_COPY | GDK_ACTION_MOVE); gtk_drag_source_add_text_targets(icons); gtk_drag_source_add_uri_targets(icons); g_signal_connect(icons, "drag-begin", G_CALLBACK(on_icons_drag_begin), d); g_signal_connect(icons, "drag-data-get", G_CALLBACK(on_icons_drag_data_get), d); g_signal_connect(icons, "drag-end", G_CALLBACK(on_icons_drag_end), d); /* Drop */ gtk_drag_dest_set(icons, GTK_DEST_DEFAULT_ALL, dnd_targets, TARGET_COUNT, GDK_ACTION_COPY | GDK_ACTION_MOVE); gtk_drag_dest_add_text_targets(icons); gtk_drag_dest_add_uri_targets(icons); g_signal_connect(icons, "drag-motion", G_CALLBACK(on_icons_drag_motion), d); g_signal_connect(icons, "drag-leave", G_CALLBACK(on_icons_data_leave), d); g_signal_connect(icons, "drag-data-received", G_CALLBACK(on_icons_drag_data_received), d); /* Activations */ g_signal_connect(icons, "item-activated", G_CALLBACK(on_icons_item_activated), d); g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(window, "configure-event", G_CALLBACK(on_window_configure_event), dir); g_signal_connect(directory_up, "activate", G_CALLBACK(on_directory_up_menu_item_activate), d); g_signal_connect(directory_open, "activate", G_CALLBACK(on_directory_open_menu_item_activate), d); g_signal_connect(directory_close, "activate", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(file_open, "activate", G_CALLBACK(on_file_open_menu_item_activate), d); g_signal_connect(help_about, "activate", G_CALLBACK(on_help_about_menu_item_activate), NULL); g_signal_connect(icons, "button-press-event", G_CALLBACK(on_icons_button_press_event), d); return window; }
void desktop_init (AppearanceData *data, const gchar **uris) { GtkWidget *add_button, *w; GtkCellRenderer *cr; char *url; data->wp_update_settings = TRUE; data->wp_uris = NULL; if (uris != NULL) { while (*uris != NULL) { data->wp_uris = g_slist_append (data->wp_uris, g_strdup (*uris)); uris++; } } w = appearance_capplet_get_widget (data, "more_backgrounds_linkbutton"); url = g_settings_get_string (data->settings, MORE_BACKGROUNDS_URL_KEY); if (url != NULL && url[0] != '\0') { gtk_link_button_set_uri (GTK_LINK_BUTTON (w), url); gtk_widget_show (w); } else { gtk_widget_hide (w); } g_free (url); data->wp_hash = g_hash_table_new (g_str_hash, g_str_equal); g_signal_connect (data->wp_settings, "changed::" WP_FILE_KEY, G_CALLBACK (wp_file_changed), data); g_signal_connect (data->wp_settings, "changed::" WP_OPTIONS_KEY, G_CALLBACK (wp_options_changed), data); g_signal_connect (data->wp_settings, "changed::" WP_SHADING_KEY, G_CALLBACK (wp_shading_changed), data); g_signal_connect (data->wp_settings, "changed::" WP_PCOLOR_KEY, G_CALLBACK (wp_color1_changed), data); g_signal_connect (data->wp_settings, "changed::" WP_SCOLOR_KEY, G_CALLBACK (wp_color2_changed), data); data->wp_model = GTK_TREE_MODEL (gtk_list_store_new (2, GDK_TYPE_PIXBUF, G_TYPE_POINTER)); data->wp_view = GTK_ICON_VIEW (appearance_capplet_get_widget (data, "wp_view")); gtk_icon_view_set_model (data->wp_view, GTK_TREE_MODEL (data->wp_model)); g_signal_connect_after (data->wp_view, "realize", (GCallback) wp_select_after_realize, data); gtk_cell_layout_clear (GTK_CELL_LAYOUT (data->wp_view)); cr = gtk_cell_renderer_pixbuf_new (); g_object_set (cr, "xpad", 5, "ypad", 5, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->wp_view), cr, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->wp_view), cr, "pixbuf", 0, NULL); cr = gtk_cell_renderer_pixbuf_new (); create_button_images (data); g_object_set (cr, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, "pixbuf", buttons[0], NULL); g_object_set_data (G_OBJECT (cr), "buttons", GINT_TO_POINTER (TRUE)); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->wp_view), cr, FALSE); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (data->wp_view), cr, buttons_cell_data_func, data, NULL); g_signal_connect (data->wp_view, "selection-changed", (GCallback) wp_selected_changed_cb, data); g_signal_connect (data->wp_view, "button-press-event", G_CALLBACK (wp_button_press_cb), data); data->frame = -1; gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (data->wp_model), 1, (GtkTreeIterCompareFunc) wp_list_sort, data, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->wp_model), 1, GTK_SORT_ASCENDING); gtk_drag_dest_set (GTK_WIDGET (data->wp_view), GTK_DEST_DEFAULT_ALL, drop_types, G_N_ELEMENTS (drop_types), GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect (data->wp_view, "drag_data_received", (GCallback) wp_drag_received, data); gtk_drag_source_set (GTK_WIDGET (data->wp_view), GDK_BUTTON1_MASK, drag_types, G_N_ELEMENTS (drag_types), GDK_ACTION_COPY); g_signal_connect (data->wp_view, "drag-data-get", (GCallback) wp_drag_get_data, data); data->wp_style_menu = appearance_capplet_get_widget (data, "wp_style_menu"); g_signal_connect (data->wp_style_menu, "changed", (GCallback) wp_scale_type_changed, data); data->wp_color_menu = appearance_capplet_get_widget (data, "wp_color_menu"); g_signal_connect (data->wp_color_menu, "changed", (GCallback) wp_shade_type_changed, data); data->wp_scpicker = appearance_capplet_get_widget (data, "wp_scpicker"); g_signal_connect (data->wp_scpicker, "color-set", (GCallback) wp_scolor_changed, data); data->wp_pcpicker = appearance_capplet_get_widget (data, "wp_pcpicker"); g_signal_connect (data->wp_pcpicker, "color-set", (GCallback) wp_scolor_changed, data); add_button = appearance_capplet_get_widget (data, "wp_add_button"); gtk_button_set_image (GTK_BUTTON (add_button), gtk_image_new_from_stock ("gtk-add", GTK_ICON_SIZE_BUTTON)); g_signal_connect (add_button, "clicked", (GCallback) wp_file_open_dialog, data); data->wp_rem_button = appearance_capplet_get_widget (data, "wp_rem_button"); g_signal_connect (data->wp_rem_button, "clicked", (GCallback) wp_remove_wallpaper, data); data->screen_monitors_handler = g_signal_connect (gtk_widget_get_screen (GTK_WIDGET (data->wp_view)), "monitors-changed", G_CALLBACK (screen_monitors_changed), data); data->screen_size_handler = g_signal_connect (gtk_widget_get_screen (GTK_WIDGET (data->wp_view)), "size-changed", G_CALLBACK (screen_monitors_changed), data); g_signal_connect (data->wp_view, "selection-changed", (GCallback) wp_props_wp_selected, data); g_signal_connect (data->wp_view, "query-tooltip", (GCallback) wp_view_tooltip_cb, data); gtk_widget_set_has_tooltip (GTK_WIDGET (data->wp_view), TRUE); wp_set_sensitivities (data); /* create the file selector later to save time on startup */ data->wp_filesel = NULL; }
int main(int argc, char** argv) { //gtk wdiget init start... GtkWidget *window, *icon_view, *notebook; GtkWidget *current_user_name, *current_time, *network_speed; GtkWidget *home_button, *access_token_entry, *access_token_ok_button; GtkWidget *access_token_cancel_button; GtkWidget *get_access_token_button, *post_blog_title_entry; GtkWidget *post_blog_content_text_view, *post_blog_content_text_buffer; GtkWidget *post_blog_ok_button, *post_blog_cancel_button; GtkWidget *blog_access_permission, *blog_password; GList *post_blog_page = NULL; GtkBuilder *builder; GError *error = NULL; //widget init gtk_init(&argc, &argv); builder = gtk_builder_new(); if(!gtk_builder_add_from_file(builder, "./sources/glade.glade", &error)) { g_print("Error occured while loading UI files\n"); g_print("Message: %s\n", error->message); g_free(error); return 1; } //widget get from builder(glade files) window = GTK_WIDGET(gtk_builder_get_object(builder, "window")); notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook1")); icon_view = GTK_WIDGET(gtk_builder_get_object(builder, "iconview1")); current_user_name = GTK_WIDGET(gtk_builder_get_object(builder,"label4")); current_time = GTK_WIDGET(gtk_builder_get_object(builder, "label5")); network_speed = GTK_WIDGET(gtk_builder_get_object(builder, "label6")); access_token_ok_button = GTK_WIDGET(gtk_builder_get_object(builder, "button3")); access_token_cancel_button = GTK_WIDGET(gtk_builder_get_object(builder, "button6")); get_access_token_button = GTK_WIDGET(gtk_builder_get_object(builder, "button2")); home_button = GTK_WIDGET(gtk_builder_get_object(builder, "button1")); access_token_entry = GTK_WIDGET(gtk_builder_get_object(builder, "entry1")); post_blog_content_text_view= GTK_WIDGET(gtk_builder_get_object(builder, "textview1")); post_blog_ok_button = GTK_WIDGET(gtk_builder_get_object(builder, "button4")); post_blog_title_entry = GTK_WIDGET(gtk_builder_get_object(builder, "entry2")); blog_access_permission = GTK_WIDGET(gtk_builder_get_object(builder, "comboboxtext1")); blog_password = GTK_WIDGET(gtk_builder_get_object(builder, "entry4")); //set object attributes gtk_window_set_title(GTK_WINDOW(window), "Xiao nei Gtk App"); gtk_window_set_default_size(GTK_WINDOW(window), 800, 400); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_icon_view_set_model(GTK_ICON_VIEW(icon_view), create_model()); gtk_icon_view_set_text_column(GTK_ICON_VIEW(icon_view), COL_DISPLAY_NAME); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(icon_view), COL_PIXBUF); gtk_icon_view_set_columns(GTK_ICON_VIEW(icon_view), 4); gtk_label_set_text(GTK_LABEL(current_user_name), "Current user:fengtianba"); g_timeout_add_seconds(1, (GSourceFunc)set_label_time, current_time); gtk_label_set_text(GTK_LABEL(network_speed), "Network Speed:100M"); gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE); int n = gtk_notebook_page_num(GTK_NOTEBOOK(notebook), icon_view); //gtk_combo_box_set_model(GTK_COMBO_BOX(blog_access_permission), create_combo_box_tree_model()); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "private", "PRIVATE"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "public", "PUBLIC"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "password", "PASSWORD"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "friend", "FRIEND"); printf("n is %d\n", n); struct tm *time_ptr; time_t the_time; char *time_malloc; (void)time(&the_time); time_ptr = localtime(&the_time); time_malloc = malloc(sizeof(struct tm)); memset(time_malloc, 0, sizeof(struct tm)); sprintf(time_malloc, "%d/%d/%d/%d:%d:%d", 1900 + time_ptr->tm_year, time_ptr->tm_mon, time_ptr->tm_mday, time_ptr->tm_hour, time_ptr->tm_min, time_ptr->tm_sec); gtk_label_set_text(GTK_LABEL(current_time), time_malloc); post_blog_page = g_list_append(post_blog_page, post_blog_title_entry); post_blog_page = g_list_append(post_blog_page, post_blog_content_text_view); post_blog_page = g_list_append(post_blog_page, blog_access_permission); post_blog_page = g_list_append(post_blog_page, blog_password); //signal to connect to widget g_signal_connect(window, "delete-event", gtk_main_quit, NULL); g_signal_connect(GTK_BUTTON(get_access_token_button), "clicked", G_CALLBACK(get_access_token_button_clicked), NULL); g_signal_connect(GTK_ICON_VIEW(icon_view), "item-activated", G_CALLBACK(icon_view_item_select), notebook); g_signal_connect(GTK_BUTTON(home_button), "clicked", G_CALLBACK(home_button_clicked), notebook); g_signal_connect(GTK_BUTTON(access_token_ok_button), "clicked", G_CALLBACK(access_token_ok_button_clicked), access_token_entry); g_signal_connect(GTK_BUTTON(post_blog_ok_button), "clicked", G_CALLBACK(post_blog_ok_button_clicked), post_blog_page); //object unref g_object_unref(G_OBJECT(builder)); //show widget gtk_widget_show_all(window); gtk_main(); int i = 100; char *decode_string; /*CURL *curl; curl_global_init(CURL_GLOBAL_ALL); curl = curl_easy_init(); decode_string = curl_easy_unescape(curl, ACCESS_TOKEN, 0, &i); printf("origin url: %s\n", ACCESS_TOKEN); printf("new url: %s\n", decode_string); curl_easy_cleanup(curl);*/ //puts("enter access token\n"); //scanf("%s", accesstoken); //调用自己写的SDK xiaonei_gtk_get_blog_list(accesstoken); xiaonei_gtk_get_one_blog(accesstoken); return (EXIT_SUCCESS); }
static GtkWidget* create_icon_view () { GtkWidget *scroll = gtk_scrolled_window_new (NULL, NULL); GtkWidget *icon_view = gtk_icon_view_new (); int col_text = 0,col_icon = 1; GtkTreeModel *list_model = gtk_list_store_new (2, G_TYPE_STRING, GDK_TYPE_PIXBUF ); gtk_icon_view_set_model (GTK_ICON_VIEW (icon_view), list_model); gtk_icon_view_set_text_column (GTK_ICON_VIEW (icon_view), col_text); gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icon_view), col_icon); gtk_icon_view_set_item_width (GTK_ICON_VIEW (icon_view), 100); GtkTreeIter iter; GtkIconTheme *icon_theme = gtk_icon_theme_get_default (); GList *contxt_list, *icon_names_list, *ctx, *icn; gint max_icons = 100; gint icon_size = 32; ctx = contxt_list = gtk_icon_theme_list_contexts (icon_theme); while (ctx && max_icons) { gchar *context = ctx->data; icn = icon_names_list = gtk_icon_theme_list_icons (icon_theme, context); g_debug ("Context %s: %d icons listed", context, g_list_length (icn)); while (icn && max_icons) { gchar *icon_name = icn->data; g_debug (" - %s", icon_name); GdkPixbuf *pixbuf = NULL; pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name, icon_size, GTK_ICON_LOOKUP_FORCE_SVG, NULL); if (pixbuf != NULL){ gtk_list_store_append (list_model, &iter); gtk_list_store_set (list_model, &iter, col_text, icon_name, col_icon, pixbuf, -1); --max_icons; }else{ g_free (icon_name); } icn = g_list_next (icn); } g_list_free (icon_names_list); g_free (context); ctx = g_list_next (ctx); } g_list_free (contxt_list); gtk_container_add (GTK_CONTAINER (scroll), icon_view); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_name (scroll, "Icon View"); return scroll; }
void img_load_slideshow( img_window_struct *img, const gchar *input ) { GdkPixbuf *thumb; slide_struct *slide_info; GtkTreeIter iter; GKeyFile *img_key_file; gchar *dummy, *slide_filename, *time; GtkWidget *dialog; gint number,i,transition_id, duration, no_points, previous_nr_of_slides; guint speed; GtkTreeModel *model; void (*render); GHashTable *table; gchar *spath, *conf; gdouble *color, *font_color, *font_bgcolor; gboolean old_file = FALSE; gboolean first_slide = TRUE; gchar *video_config_name, *aspect_ratio, *fps; gint old_video_size, bitrate; /* Cretate new key file */ img_key_file = g_key_file_new(); if( ! g_key_file_load_from_file( img_key_file, input, G_KEY_FILE_KEEP_COMMENTS, NULL ) ) { g_key_file_free( img_key_file ); return; } /* Are we able to load this project? */ dummy = g_key_file_get_comment( img_key_file, NULL, NULL, NULL); if( strncmp( dummy, comment_string, strlen( comment_string ) ) != 0 ) { /* Enable loading of old projects too */ if( strncmp( dummy, old_comment_string, strlen( old_comment_string ) ) != 0 ) { dialog = gtk_message_dialog_new( GTK_WINDOW( img->imagination_window ), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("This is not an Imagination project file!") ); gtk_window_set_title( GTK_WINDOW( dialog ), "Imagination" ); gtk_dialog_run( GTK_DIALOG( dialog ) ); gtk_widget_destroy( GTK_WIDGET( dialog ) ); g_free( dummy ); return; } old_file = TRUE; } g_free( dummy ); /* Create hash table for efficient searching */ table = g_hash_table_new_full( g_direct_hash, g_direct_equal, NULL, g_free ); model = gtk_combo_box_get_model( GTK_COMBO_BOX( img->transition_type ) ); gtk_tree_model_foreach( model, (GtkTreeModelForeachFunc)img_populate_hash_table, &table ); /* Set the slideshow options */ /* Video Format, first check if we have a buggy, old file format (imagination <= 3.0) */ old_video_size = g_key_file_get_integer(img_key_file, "slideshow settings", "video format", NULL); if (old_video_size != 0) { img_message(img, FALSE, "Old imagination project file, guessing format as VOB"); img->video_format_index = 0; /* index for VOB format*/ for (i = 0; video_format_list[0].sizelist[i].name != NULL && video_format_list[0].sizelist[i].y != old_video_size; i++); if (video_format_list[0].sizelist[i].name != NULL) { img->video_size[0] = video_format_list[0].sizelist[i].x; img->video_size[1] = old_video_size; } else /* we could not find the appropriate format, so we guess 4:3 format */ { img->video_size[0] = old_video_size * 4 / 3; img->video_size[1] = old_video_size; } /* Guess fps from video size */ if (img->video_size[1] == 576) img->fps_index = 1; /* NTSC */ else img->fps_index = 0; /* PAL */ img->export_fps = video_format_list[img->video_format_index].fps_list[img->fps_index].value; /* set other parameters to defaults, as they can't be checked */ img->aspect_ratio_index = 0; /* 4:3 */ img->bitrate_index = 0; /* Not used in vob */ } else { /* Video Codec */ video_config_name = g_key_file_get_string(img_key_file, "slideshow settings", "video codec", NULL); i = 0; while (video_config_name != NULL && video_format_list[i].name != NULL && strcmp (video_format_list[i].config_name, video_config_name) != 0) i++; if (video_config_name == NULL || video_format_list[i].name == NULL) { img_message(img, FALSE, "Could not find a video format, guessing VOB\n"); img->video_format_index = 0; /* index for VOB format*/ } else img->video_format_index = i; /* Video Size */ img->video_size[0] = g_key_file_get_integer(img_key_file, "slideshow settings", "video width", NULL); img->video_size[1] = g_key_file_get_integer(img_key_file, "slideshow settings", "video height", NULL); /* fps */ fps = g_key_file_get_string(img_key_file, "slideshow settings", "fps", NULL); i = 0; while (fps != NULL && strcmp (video_format_list[img->video_format_index].fps_list[i].name, fps) != 0) i++; if (fps == NULL || video_format_list[img->video_format_index].fps_list[i].name == NULL) { img_message(img, FALSE, "Could not find a fps, set to default\n"); img->fps_index = 0; /* index for VOB format*/ } else img->fps_index = i; img->export_fps = video_format_list[img->video_format_index].fps_list[img->fps_index].value; /* Aspect ratio */ if (NULL != video_format_list[img->video_format_index].aspect_ratio_list) { aspect_ratio = g_key_file_get_string(img_key_file, "slideshow settings", "aspect ratio", NULL); i = 0; while (aspect_ratio != NULL && video_format_list[img->video_format_index].aspect_ratio_list[i].name != NULL && strcmp (video_format_list[img->video_format_index].aspect_ratio_list[i].name, aspect_ratio) != 0) i++; if (aspect_ratio == NULL || video_format_list[img->video_format_index].aspect_ratio_list[i].name == NULL) { img_message(img, FALSE, "Could not find an aspect ratio, set to default\n"); img->aspect_ratio_index = 0; /* index for VOB format*/ } else img->aspect_ratio_index = i; } /* Bitrate */ if (NULL != video_format_list[img->video_format_index].bitratelist) { bitrate = g_key_file_get_integer(img_key_file, "slideshow settings", "bitrate", NULL); i = 0; while (video_format_list[img->video_format_index].bitratelist[i].name != NULL && video_format_list[img->video_format_index].bitratelist[i].value != bitrate) i++; if (video_format_list[img->video_format_index].bitratelist[i].name == NULL) { img_message(img, FALSE, "Could not find a bitrate, set to default\n"); img->bitrate_index = 0; /* index for VOB format*/ } else img->bitrate_index = i; } } img_zoom_fit(NULL, img); /* Make loading more efficient by removing model from icon view */ g_object_ref( G_OBJECT( img->thumbnail_model ) ); gtk_icon_view_set_model( GTK_ICON_VIEW( img->thumbnail_iconview ), NULL ); gtk_icon_view_set_model( GTK_ICON_VIEW( img->over_icon ), NULL ); /* Enable loading of old projects too */ if( old_file ) { guint32 tmp; dummy = g_key_file_get_string( img_key_file, "slideshow settings", "background color", NULL ); tmp = (guint32)strtoul( dummy, NULL, 16 ); img->background_color[0] = (gdouble)( ( tmp >> 24 ) & 0xff ) / 0xff; img->background_color[1] = (gdouble)( ( tmp >> 16 ) & 0xff ) / 0xff; img->background_color[2] = (gdouble)( ( tmp >> 8 ) & 0xff ) / 0xff; /* Loads the thumbnails and set the slides info */ number = g_key_file_get_integer(img_key_file,"images","number", NULL); /* Store the previous number of slides and set img->slides_nr so to have the correct number of slides displayed on the status bar */ previous_nr_of_slides = img->slides_nr; img->slides_nr = number; gtk_widget_show(img->progress_bar); for (i = 1; i <= number; i++) { dummy = g_strdup_printf("image_%d",i); slide_filename = g_key_file_get_string(img_key_file,"images",dummy, NULL); if( img_scale_image( slide_filename, img->video_ratio, 88, 0, img->distort_images, img->background_color, &thumb, NULL ) ) { GdkPixbuf *pix; speed = g_key_file_get_integer(img_key_file, "transition speed", dummy, NULL); duration= g_key_file_get_integer(img_key_file, "slide duration", dummy, NULL); transition_id = g_key_file_get_integer(img_key_file, "transition type", dummy, NULL); /* Get the mem address of the transition */ spath = (gchar *)g_hash_table_lookup( table, GINT_TO_POINTER( transition_id ) ); if (spath) { gtk_tree_model_get_iter_from_string( model, &iter, spath ); gtk_tree_model_get( model, &iter, 2, &render, 0, &pix, -1 ); } slide_info = img_create_new_slide(); if( slide_info ) { img_set_slide_file_info( slide_info, slide_filename ); gtk_list_store_append( img->thumbnail_model, &iter ); gtk_list_store_set( img->thumbnail_model, &iter, 0, thumb, 1, slide_info, -1 ); g_object_unref( G_OBJECT( thumb ) ); /* Set non-default data */ img_set_slide_still_info( slide_info, duration, img ); img_set_slide_transition_info( slide_info, img->thumbnail_model, &iter, pix, spath, transition_id, render, speed, img ); g_object_unref( G_OBJECT( pix ) ); /* Increment slide counter */ img->slides_nr++; /* If we're loading the first slide, apply some of it's * data to final pseudo-slide */ if( first_slide ) { first_slide = FALSE; img->final_transition.speed = slide_info->speed; img->final_transition.render = slide_info->render; } } } img_increase_progressbar(img, i); g_free(slide_filename); g_free(dummy); } } else {
gint main (gint argc, gchar **argv) { GtkWidget *paned, *tv; GtkWidget *window, *icon_list, *scrolled_window; GtkWidget *vbox, *bbox; GtkWidget *button; GtkWidget *prop_editor; GtkTreeModel *model; GtkCellRenderer *cell; GtkTreeViewColumn *tvc; gtk_init (&argc, &argv); /* to test rtl layout, set RTL=1 in the environment */ if (g_getenv ("RTL")) gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 700, 400); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), vbox); paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0); icon_list = gtk_icon_view_new (); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (icon_list), GTK_SELECTION_MULTIPLE); tv = gtk_tree_view_new (); tvc = gtk_tree_view_column_new (); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), tvc); g_signal_connect_after (icon_list, "button_press_event", G_CALLBACK (button_press_event_handler), NULL); g_signal_connect (icon_list, "selection_changed", G_CALLBACK (selection_changed), NULL); g_signal_connect (icon_list, "popup_menu", G_CALLBACK (popup_menu_handler), NULL); g_signal_connect (icon_list, "item_activated", G_CALLBACK (item_activated), NULL); model = create_model (); gtk_icon_view_set_model (GTK_ICON_VIEW (icon_list), model); gtk_tree_view_set_model (GTK_TREE_VIEW (tv), model); fill_model (model); #if 0 gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icon_list), 0); gtk_icon_view_set_text_column (GTK_ICON_VIEW (icon_list), 1); #else cell = gtk_cell_renderer_toggle_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE); g_object_set (cell, "activatable", TRUE, NULL); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list), cell, "active", 4, NULL); g_signal_connect (cell, "toggled", G_CALLBACK (toggled), model); cell = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE); g_object_set (cell, "follow-state", TRUE, NULL); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list), cell, "pixbuf", 0, NULL); cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE); g_object_set (cell, "editable", TRUE, "xalign", 0.5, "wrap-mode", PANGO_WRAP_WORD_CHAR, "wrap-width", 100, NULL); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list), cell, "text", 1, NULL); g_signal_connect (cell, "edited", G_CALLBACK (edited), model); /* now the tree view... */ cell = gtk_cell_renderer_toggle_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE); g_object_set (cell, "activatable", TRUE, NULL); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc), cell, "active", 4, NULL); g_signal_connect (cell, "toggled", G_CALLBACK (toggled), model); cell = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE); g_object_set (cell, "follow-state", TRUE, NULL); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc), cell, "pixbuf", 0, NULL); cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE); g_object_set (cell, "editable", TRUE, NULL); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc), cell, "text", 1, NULL); g_signal_connect (cell, "edited", G_CALLBACK (edited), model); #endif /* Allow DND between the icon view and the tree view */ gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW (icon_list), GDK_BUTTON1_MASK, item_targets, G_N_ELEMENTS (item_targets), GDK_ACTION_MOVE); gtk_icon_view_enable_model_drag_dest (GTK_ICON_VIEW (icon_list), item_targets, G_N_ELEMENTS (item_targets), GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv), GDK_BUTTON1_MASK, item_targets, G_N_ELEMENTS (item_targets), GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv), item_targets, G_N_ELEMENTS (item_targets), GDK_ACTION_MOVE); prop_editor = create_prop_editor (G_OBJECT (icon_list), 0); gtk_widget_show_all (prop_editor); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolled_window), icon_list); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add1 (GTK_PANED (paned), scrolled_window); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolled_window), tv); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add2 (GTK_PANED (paned), scrolled_window); bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START); gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Add some"); g_signal_connect (button, "clicked", G_CALLBACK (add_some), icon_list); gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Add many"); g_signal_connect (button, "clicked", G_CALLBACK (add_many), icon_list); gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Add large"); g_signal_connect (button, "clicked", G_CALLBACK (add_large), icon_list); gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Remove selected"); g_signal_connect (button, "clicked", G_CALLBACK (foreach_selected_remove), icon_list); gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Swap"); g_signal_connect (button, "clicked", G_CALLBACK (swap_rows), icon_list); gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START); gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Select all"); g_signal_connect (button, "clicked", G_CALLBACK (select_all), icon_list); gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Unselect all"); g_signal_connect (button, "clicked", G_CALLBACK (unselect_all), icon_list); gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Select nonexisting"); g_signal_connect (button, "clicked", G_CALLBACK (select_nonexisting), icon_list); gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); icon_list = gtk_icon_view_new (); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolled_window), icon_list); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add2 (GTK_PANED (paned), scrolled_window); gtk_widget_show_all (window); gtk_main (); return 0; }
static void update_db(BudgieMediaView *self) { GtkIconTheme *theme; GtkListStore *model; GPtrArray *albums = NULL; GPtrArray *results = NULL; GdkPixbuf *pixbuf; GtkTreeIter iter; gchar *album = NULL; gchar *markup = NULL; MediaInfo *current; const gchar *cache; gchar *album_id = NULL, *path = NULL; int i; /* No albums */ if (!budgie_db_get_all_by_field(self->db, MEDIA_QUERY_ALBUM, &albums)) return; cache = g_get_user_cache_dir(); /* We don't *yet* support album art, use generic symbol */ theme = gtk_icon_theme_get_default(); model = gtk_list_store_new(ALBUM_COLUMNS, G_TYPE_STRING, GDK_TYPE_PIXBUF); for (i=0; i < albums->len; i++) { album = (gchar *)albums->pdata[i]; /* Try to gain at least one artist */ if (!budgie_db_search_field(self->db, MEDIA_QUERY_ALBUM, MATCH_QUERY_EXACT, album, 1, &results)) goto fail; current = results->pdata[0]; if (current->album == NULL) goto albumfail; album_id = albumart_name_for_media(current, "jpeg"); path = g_strdup_printf("%s/media-art/%s", cache, album_id); g_free(album_id); pixbuf = gdk_pixbuf_new_from_file_at_size(path, 64, 64, NULL); if (!pixbuf) pixbuf = gtk_icon_theme_load_icon(theme, "folder-music-symbolic", 64, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL); /* Pretty label */ markup = g_markup_printf_escaped("<big><b>%s</b>\n<span color='grey'>%s</span></big>", current->album, current->artist); gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, ALBUM_TITLE, markup, -1); gtk_list_store_set(model, &iter, ALBUM_PIXBUF, pixbuf, -1); g_object_unref(pixbuf); albumfail: free_media_info(current); g_ptr_array_free(results, TRUE); fail: g_free(album); } gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), ALBUM_TITLE, GTK_SORT_ASCENDING); gtk_icon_view_set_model(GTK_ICON_VIEW(self->icon_view), GTK_TREE_MODEL(model)); g_ptr_array_free(albums, TRUE); }
static GtkWidget * focus_iconview (gboolean color_bg, GtkCellRenderer **focus, GtkCellRenderer **sibling) { GtkTreeModel *model; GtkWidget *iconview; GtkCellArea *area; GtkCellRenderer *renderer, *toggle; iconview = gtk_icon_view_new (); gtk_widget_show (iconview); model = focus_list_model (); gtk_icon_view_set_model (GTK_ICON_VIEW (iconview), model); gtk_icon_view_set_item_orientation (GTK_ICON_VIEW (iconview), GTK_ORIENTATION_HORIZONTAL); area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (iconview)); renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "editable", TRUE, NULL); gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, TRUE, FALSE, FALSE); gtk_cell_area_attribute_connect (area, renderer, "text", FOCUS_COLUMN_NAME); if (color_bg) g_object_set (G_OBJECT (renderer), "cell-background", "red", NULL); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (cell_edited), iconview); toggle = renderer = gtk_cell_renderer_toggle_new (); g_object_set (G_OBJECT (renderer), "xalign", 0.0F, NULL); gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, FALSE, TRUE, FALSE); gtk_cell_area_attribute_connect (area, renderer, "active", FOCUS_COLUMN_CHECK); if (color_bg) g_object_set (G_OBJECT (renderer), "cell-background", "green", NULL); if (focus) *focus = renderer; g_signal_connect (G_OBJECT (renderer), "toggled", G_CALLBACK (cell_toggled), iconview); renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "wrap-mode", PANGO_WRAP_WORD, "wrap-width", 150, NULL); if (color_bg) g_object_set (G_OBJECT (renderer), "cell-background", "blue", NULL); if (sibling) *sibling = renderer; gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, FALSE, TRUE, FALSE); gtk_cell_area_attribute_connect (area, renderer, "text", FOCUS_COLUMN_STATIC_TEXT); gtk_cell_area_add_focus_sibling (area, toggle, renderer); return iconview; }
void themes_init(AppearanceData* data) { GtkWidget *w, *del_button; GList *theme_list, *l; GtkListStore *theme_store; GtkTreeModel *sort_model; MateThemeMetaInfo *meta_theme = NULL; GtkIconView *icon_view; GtkCellRenderer *renderer; GtkSettings *settings; char *url; /* initialise some stuff */ mate_theme_init (); mate_wm_manager_init (); data->revert_application_font = NULL; data->revert_documents_font = NULL; data->revert_desktop_font = NULL; data->revert_windowtitle_font = NULL; data->revert_monospace_font = NULL; data->theme_save_dialog = NULL; data->theme_message_area = NULL; data->theme_info_icon = NULL; data->theme_error_icon = NULL; data->theme_custom = mate_theme_meta_info_new (); data->theme_icon = gdk_pixbuf_new_from_file (MATECC_PIXMAP_DIR "/theme-thumbnailing.png", NULL); data->theme_store = theme_store = gtk_list_store_new (NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); /* set up theme list */ theme_list = mate_theme_meta_info_find_all (); mate_theme_info_register_theme_change ((ThemeChangedCallback) theme_changed_on_disk_cb, data); data->theme_custom = theme_load_from_mateconf (data->client); data->theme_custom->name = g_strdup (CUSTOM_THEME_NAME); data->theme_custom->readable_name = g_strdup_printf ("<i>%s</i>", _("Custom")); for (l = theme_list; l; l = l->next) { MateThemeMetaInfo *info = l->data; gtk_list_store_insert_with_values (theme_store, NULL, 0, COL_LABEL, info->readable_name, COL_NAME, info->name, COL_THUMBNAIL, data->theme_icon, -1); if (!meta_theme && theme_is_equal (data->theme_custom, info)) meta_theme = info; } if (!meta_theme) { /* add custom theme */ meta_theme = data->theme_custom; gtk_list_store_insert_with_values (theme_store, NULL, 0, COL_LABEL, meta_theme->readable_name, COL_NAME, meta_theme->name, COL_THUMBNAIL, data->theme_icon, -1); theme_thumbnail_generate (meta_theme, data); } theme_list = g_list_sort (theme_list, (GCompareFunc) theme_list_sort_func); g_list_foreach (theme_list, (GFunc) theme_thumbnail_generate, data); g_list_free (theme_list); icon_view = GTK_ICON_VIEW (appearance_capplet_get_widget (data, "theme_list")); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "xpad", 5, "ypad", 5, "xalign", 0.5, "yalign", 1.0, NULL); gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (icon_view), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_view), renderer, "pixbuf", COL_THUMBNAIL, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "alignment", PANGO_ALIGN_CENTER, "wrap-mode", PANGO_WRAP_WORD_CHAR, "wrap-width", gtk_icon_view_get_item_width (icon_view), "width", gtk_icon_view_get_item_width (icon_view), "xalign", 0.0, "yalign", 0.0, NULL); gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (icon_view), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_view), renderer, "markup", COL_LABEL, NULL); sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (theme_store)); gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model), COL_LABEL, theme_store_sort_func, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model), COL_LABEL, GTK_SORT_ASCENDING); gtk_icon_view_set_model (icon_view, GTK_TREE_MODEL (sort_model)); g_signal_connect (icon_view, "selection-changed", (GCallback) theme_selection_changed_cb, data); g_signal_connect_after (icon_view, "realize", (GCallback) theme_select_name, meta_theme->name); w = appearance_capplet_get_widget (data, "theme_install"); gtk_button_set_image (GTK_BUTTON (w), gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON)); g_signal_connect (w, "clicked", (GCallback) theme_install_cb, data); w = appearance_capplet_get_widget (data, "theme_save"); gtk_button_set_image (GTK_BUTTON (w), gtk_image_new_from_stock (GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_BUTTON)); g_signal_connect (w, "clicked", (GCallback) theme_save_cb, data); w = appearance_capplet_get_widget (data, "theme_custom"); gtk_button_set_image (GTK_BUTTON (w), gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON)); g_signal_connect (w, "clicked", (GCallback) theme_custom_cb, data); del_button = appearance_capplet_get_widget (data, "theme_delete"); g_signal_connect (del_button, "clicked", (GCallback) theme_delete_cb, data); w = appearance_capplet_get_widget (data, "theme_vbox"); gtk_drag_dest_set (w, GTK_DEST_DEFAULT_ALL, drop_types, G_N_ELEMENTS (drop_types), GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_MOVE); g_signal_connect (w, "drag-data-received", (GCallback) theme_drag_data_received_cb, data); if (is_locked_down (data->client)) gtk_widget_set_sensitive (w, FALSE); w = appearance_capplet_get_widget (data, "more_themes_linkbutton"); url = mateconf_client_get_string (data->client, MORE_THEMES_URL_KEY, NULL); if (url != NULL && url[0] != '\0') { gtk_link_button_set_uri (GTK_LINK_BUTTON (w), url); gtk_widget_show (w); } else { gtk_widget_hide (w); } g_free (url); /* listen to mateconf changes, too */ mateconf_client_add_dir (data->client, "/apps/marco/general", MATECONF_CLIENT_PRELOAD_NONE, NULL); mateconf_client_add_dir (data->client, "/desktop/mate/interface", MATECONF_CLIENT_PRELOAD_NONE, NULL); mateconf_client_notify_add (data->client, MARCO_THEME_KEY, (MateConfClientNotifyFunc) theme_mateconf_changed, data, NULL, NULL); mateconf_client_notify_add (data->client, CURSOR_THEME_KEY, (MateConfClientNotifyFunc) theme_mateconf_changed, data, NULL, NULL); #ifdef HAVE_XCURSOR mateconf_client_notify_add (data->client, CURSOR_SIZE_KEY, (MateConfClientNotifyFunc) theme_mateconf_changed, data, NULL, NULL); #endif mateconf_client_notify_add (data->client, BACKGROUND_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL); mateconf_client_notify_add (data->client, APPLICATION_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL); mateconf_client_notify_add (data->client, DOCUMENTS_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL); mateconf_client_notify_add (data->client, DESKTOP_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL); mateconf_client_notify_add (data->client, WINDOWTITLE_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL); mateconf_client_notify_add (data->client, MONOSPACE_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL); settings = gtk_settings_get_default (); g_signal_connect (settings, "notify::gtk-color-scheme", (GCallback) theme_setting_changed_cb, data); g_signal_connect (settings, "notify::gtk-theme-name", (GCallback) theme_setting_changed_cb, data); g_signal_connect (settings, "notify::gtk-icon-theme-name", (GCallback) theme_setting_changed_cb, data); /* monitor individual font choice buttons, so "revert font" option (if any) can be cleared */ w = appearance_capplet_get_widget (data, "application_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); w = appearance_capplet_get_widget (data, "document_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); w = appearance_capplet_get_widget (data, "desktop_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); w = appearance_capplet_get_widget (data, "window_title_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); w = appearance_capplet_get_widget (data, "monospace_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); }
static GObject * mud_connections_constructor (GType gtype, guint n_properties, GObjectConstructParam *properties) { MudConnections *conn; GladeXML *glade; GConfClient *client; GtkWidget *main_window; GObject *obj; MudConnectionsClass *klass; GObjectClass *parent_class; /* Chain up to parent constructor */ klass = MUD_CONNECTIONS_CLASS( g_type_class_peek(MUD_TYPE_CONNECTIONS) ); parent_class = G_OBJECT_CLASS( g_type_class_peek_parent(klass) ); obj = parent_class->constructor(gtype, n_properties, properties); conn = MUD_CONNECTIONS(obj); if(!conn->parent_window) g_error("Tried to instantiate MudConnections without passing parent MudWindow\n"); g_object_get(conn->parent_window, "window", &conn->priv->winwidget, "tray", &conn->priv->tray, NULL); glade = glade_xml_new(GLADEDIR "/muds.glade", "mudviewwindow", NULL); conn->priv->window = glade_xml_get_widget(glade, "mudviewwindow"); conn->priv->iconview = glade_xml_get_widget(glade, "iconview"); conn->priv->qconnect_host_entry = glade_xml_get_widget(glade, "qconnect_host_entry"); conn->priv->qconnect_port_entry = glade_xml_get_widget(glade, "qconnect_port_entry"); conn->priv->qconnect_connect_button = glade_xml_get_widget(glade, "qconnect_connect_button"); conn->priv->icon_model = GTK_TREE_MODEL(gtk_list_store_new(MODEL_COLUMN_N, G_TYPE_STRING, GDK_TYPE_PIXBUF)); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(conn->priv->icon_model), MODEL_COLUMN_STRING, GTK_SORT_ASCENDING); gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(conn->priv->icon_model), MODEL_COLUMN_STRING, mud_connections_compare_func, NULL, NULL); conn->priv->original_name = NULL; conn->priv->original_char_name = NULL; gtk_icon_view_set_model(GTK_ICON_VIEW(conn->priv->iconview), conn->priv->icon_model); g_object_unref(conn->priv->icon_model); gtk_icon_view_set_text_column(GTK_ICON_VIEW(conn->priv->iconview), MODEL_COLUMN_STRING); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(conn->priv->iconview), MODEL_COLUMN_PIXBUF); client = gconf_client_get_default(); gconf_client_add_dir(client, "/apps/gnome-mud/muds", GCONF_CLIENT_PRELOAD_NONE, NULL); conn->priv->connection = gconf_client_notify_add(client, "/apps/gnome-mud/muds", (GConfClientNotifyFunc) mud_connections_gconf_notify_cb, conn, NULL, NULL); g_signal_connect(conn->priv->iconview, "item-activated", G_CALLBACK(mud_connections_iconview_activate_cb), conn); g_signal_connect(conn->priv->iconview, "button-press-event", G_CALLBACK(mud_connections_button_press_cb), conn); g_signal_connect(conn->priv->window, "destroy", G_CALLBACK(mud_connections_close_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "connect_button"), "clicked", G_CALLBACK(mud_connections_connect_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "add_button"), "clicked", G_CALLBACK(mud_connections_add_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "delete_button"), "clicked", G_CALLBACK(mud_connections_delete_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "properties_button"), "clicked", G_CALLBACK(mud_connections_properties_cb), conn); g_signal_connect(conn->priv->qconnect_connect_button, "clicked", G_CALLBACK(mud_connections_qconnect_cb), conn); mud_connections_populate_iconview(conn); g_object_get(conn->parent_window, "window", &main_window, NULL); g_object_set(conn->priv->window, "transient-for", GTK_WINDOW(main_window), NULL); gtk_widget_show_all(conn->priv->window); g_object_unref(glade); g_object_unref(client); return obj; }