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); }
/* * Configure the GtkIconView: background color, visual columns, drag-and-drop, * and icon activation. */ static void set_up_icon_view(GtkWidget *icons, struct state *d) { /* Background color */ GdkRGBA transparent = {0, 0, 0, 0}; override_background_color(icons, &transparent); /* Columns */ gtk_icon_view_set_text_column(d->icon_view, FILE_NAME); gtk_icon_view_set_pixbuf_column(d->icon_view, FILE_ICON); /* 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(icons, "button-press-event", G_CALLBACK(on_desktop_icon_button_press_event), d); }
/** * Crée le GtkIconView * * \param nom de l'icône * * \return le GtkIconView rempli avec l'icône sélectionnée au premier plan * * */ GtkWidget * gsb_select_icon_create_icon_view ( gchar * name_icon ) { GtkTreePath * tree_path; /* construct the GtkIconView */ icon_view = gtk_icon_view_new (); gtk_icon_view_set_margin ( GTK_ICON_VIEW ( icon_view ), 0 ); gtk_icon_view_set_spacing (GTK_ICON_VIEW ( icon_view ), 0 ); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW ( icon_view ), GTK_SELECTION_SINGLE ); gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW ( icon_view ), PIXBUF_COLUMN); gtk_icon_view_set_text_column (GTK_ICON_VIEW ( icon_view ), TEXT_COLUMN); /* remplissage et positionnement initial du curseur dans le GtkIconView */ tree_path = gsb_select_icon_fill_icon_view ( name_icon ); gtk_icon_view_select_path ( GTK_ICON_VIEW ( icon_view ), tree_path ); gtk_icon_view_set_cursor (GTK_ICON_VIEW ( icon_view ), tree_path, NULL, TRUE); gtk_icon_view_scroll_to_path (GTK_ICON_VIEW ( icon_view ), tree_path, TRUE, 0.5, 0 ); return icon_view; }
JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkIconView_gtk_1icon_1view_1set_1pixbuf_1column ( JNIEnv* env, jclass cls, jlong _self, jint _column ) { GtkIconView* self; gint column; // convert parameter self self = (GtkIconView*) _self; // convert parameter column column = (gint) _column; // call function gtk_icon_view_set_pixbuf_column(self, column); // cleanup parameter self // cleanup parameter column }
// 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); } }
void addGroup (const gchar *name, const gchar *icon_path, const gchar *nick, const gchar *sort_key) { // calculate position int pos; { std::list <std::string>::iterator it; for (it = sort_keys.begin(), pos = 0; it != sort_keys.end(); it++, pos++) if (strcmp (it->c_str(), sort_key) >= 0) break; sort_keys.insert (it, sort_key); } // label widget GtkWidget *tab_label, *image, *label; GdkPixbuf *icon = NULL; if (icon_path) { GError *error = 0; std::string path = ICONS + std::string (icon_path) + ".png"; icon = gdk_pixbuf_new_from_file (path.c_str(), &error); if (!icon) g_warning ("Could not load icon: %s.\nReason: %s", icon_path, error->message); } tab_label = gtk_hbox_new (FALSE, 0); label = gtk_label_new (name); if (icon) image = gtk_image_new_from_pixbuf (icon); if (icon) gtk_box_pack_start (GTK_BOX (tab_label), image, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (tab_label), label, TRUE, TRUE, icon ? 6 : 0); // page widget GtkListStore *store = gtk_list_store_new (3, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING); m_stores [nick] = store; GtkWidget *icons_view; icons_view = gtk_icon_view_new_with_model (GTK_TREE_MODEL (store)); gtk_icon_view_set_text_column (GTK_ICON_VIEW (icons_view), 0); gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icons_view), 1); g_signal_connect(G_OBJECT (icons_view), "item-activated", G_CALLBACK (executeCommand), this); GtkWidget *page; page = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (page), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (page), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (page), icons_view); // add those to the notebook gtk_widget_show_all (tab_label); gtk_notebook_insert_page_menu (GTK_NOTEBOOK (m_widget), page, tab_label, NULL, pos); }
/* 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 fcitx_main_window_init(FcitxMainWindow* self) { GtkWidget* vbox = gtk_vbox_new(FALSE, 0); GtkWidget* hbox = gtk_hbox_new(FALSE, 0); self->pagestore = _fcitx_main_window_create_model(); self->pageview = gtk_icon_view_new_with_model(GTK_TREE_MODEL(self->pagestore)); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(self->pageview), PAGE_LIST_ICON); gtk_icon_view_set_text_column(GTK_ICON_VIEW(self->pageview), PAGE_LIST_NAME); #if GTK_CHECK_VERSION(2, 22, 0) gtk_icon_view_set_item_orientation(GTK_ICON_VIEW(self->pageview), GTK_ORIENTATION_VERTICAL); #endif _fcitx_main_window_add_im_page(self); _fcitx_main_window_add_config_file_page(self); _fcitx_main_window_add_addon_page(self); gtk_widget_set_size_request(GTK_WIDGET(self), -1, 500); self->vbox = gtk_vbox_new(FALSE, 0); self->pagelabel = gtk_label_new(""); gtk_label_set_use_markup(GTK_LABEL(self->pagelabel), true); gtk_misc_set_alignment(GTK_MISC(self->pagelabel), 0, 0.5); gtk_box_pack_start(GTK_BOX(self->vbox), self->pagelabel, FALSE, FALSE, 14); GtkWidget* scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_NEVER); gtk_container_add(GTK_CONTAINER(scrolledwindow), self->pageview); gtk_box_pack_start(GTK_BOX(hbox), scrolledwindow, FALSE, TRUE, 4); gtk_box_pack_start(GTK_BOX(hbox), self->vbox, TRUE, TRUE, 8); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 8); gtk_container_add(GTK_CONTAINER(self), vbox); gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(self->pageview), GTK_SELECTION_SINGLE); gtk_icon_view_set_item_padding(GTK_ICON_VIEW(self->pageview), 0); gtk_icon_view_set_margin(GTK_ICON_VIEW(self->pageview), 0); gtk_icon_view_set_column_spacing(GTK_ICON_VIEW(self->pageview), 0); gtk_icon_view_set_row_spacing(GTK_ICON_VIEW(self->pageview), 0); gtk_icon_view_set_item_width(GTK_ICON_VIEW(self->pageview), 96); g_signal_connect_swapped(G_OBJECT(self), "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(G_OBJECT(self->pageview), "selection-changed", G_CALLBACK(_fcitx_main_window_selection_changed_cb), self); GtkTreePath* path = gtk_tree_model_get_path(GTK_TREE_MODEL(self->pagestore), &self->impage->iter); gtk_icon_view_select_path(GTK_ICON_VIEW(self->pageview), path); gtk_tree_path_free(path); gtk_window_set_icon_name(GTK_WINDOW(self), "fcitx-configtool"); gtk_window_set_title(GTK_WINDOW(self), _("Fcitx Config")); }
static int _settings(void) { Settings settings; GtkAccelGroup * accel; GtkWidget * widget; GtkListStore * store; GtkTreeModel * model; accel = gtk_accel_group_new(); settings.window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_add_accel_group(GTK_WINDOW(settings.window), accel); desktop_accel_create(_settings_accel, &settings, accel); g_object_unref(accel); gtk_window_set_default_size(GTK_WINDOW(settings.window), 400, 300); gtk_window_set_icon_name(GTK_WINDOW(settings.window), GTK_STOCK_PREFERENCES); gtk_window_set_title(GTK_WINDOW(settings.window), _("System preferences")); g_signal_connect_swapped(settings.window, "delete-event", G_CALLBACK( _settings_on_closex), NULL); widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); store = gtk_list_store_new(SC_COUNT, GDK_TYPE_PIXBUF, /* SC_ICON */ G_TYPE_STRING, /* SC_NAME */ G_TYPE_STRING, /* SC_EXEC */ G_TYPE_BOOLEAN); /* SC_PRIVILEGED */ model = gtk_tree_model_filter_new(GTK_TREE_MODEL(store), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model), _settings_on_filter_view, &settings, NULL); model = gtk_tree_model_sort_new_with_model(model); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), SC_NAME, GTK_SORT_ASCENDING); settings.view = gtk_icon_view_new_with_model(model); gtk_icon_view_set_item_width(GTK_ICON_VIEW(settings.view), 96); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(settings.view), SC_ICON); gtk_icon_view_set_text_column(GTK_ICON_VIEW(settings.view), SC_NAME); gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(settings.view), GTK_SELECTION_SINGLE); #if GTK_CHECK_VERSION(2, 10, 0) g_signal_connect(settings.view, "item-activated", G_CALLBACK( _settings_on_item_activated), &settings); #endif gtk_container_add(GTK_CONTAINER(widget), settings.view); gtk_container_add(GTK_CONTAINER(settings.window), widget); gtk_widget_show_all(settings.window); g_idle_add(_settings_on_idle, &settings); gtk_main(); return 0; }
GtkWidget * create_icon_view(void) { GtkListStore *list_store; GtkWidget *widget; assert(list_store); list_store = gtk_list_store_new(N_COLS, G_TYPE_STRING, GDK_TYPE_PIXBUF); widget = gtk_icon_view_new_with_model(GTK_TREE_MODEL(list_store)); gtk_icon_view_set_text_column(GTK_ICON_VIEW(widget), COL_NAME); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(widget), COL_ICON); gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(widget), GTK_SELECTION_MULTIPLE); gtk_icon_view_set_margin(GTK_ICON_VIEW(widget), 4); gtk_icon_view_set_spacing(GTK_ICON_VIEW(widget), 5); gtk_icon_view_set_item_width(GTK_ICON_VIEW(widget), 80); g_signal_connect(G_OBJECT(widget), "item-activated", G_CALLBACK(handle_icon_view_item_activated), NULL); return widget; }
static void budgie_media_view_init(BudgieMediaView *self) { GtkWidget *icon_view, *scroll; /* Set up our icon view */ icon_view = gtk_icon_view_new(); self->icon_view = icon_view; scroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(scroll), icon_view); gtk_container_add(GTK_CONTAINER(self), scroll); /* Relevant columns */ gtk_icon_view_set_markup_column(GTK_ICON_VIEW(icon_view), ALBUM_TITLE); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(icon_view), ALBUM_PIXBUF); gtk_icon_view_set_item_width(GTK_ICON_VIEW(icon_view), 200); gtk_icon_view_set_item_orientation(GTK_ICON_VIEW(icon_view), GTK_ORIENTATION_HORIZONTAL); }
int main (int argc, char *argv[]) { GtkWidget *window; GtkWidget *icon_view; GtkWidget *sw; gtk_init (&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW (window), "Icon View"); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_container_set_border_width(GTK_CONTAINER(window), 10); gtk_widget_set_size_request(window, 350, 330); sw = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER (window), sw); 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); icon_view = gtk_icon_view_new_with_model(init_model()); gtk_container_add(GTK_CONTAINER(sw), icon_view); 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_selection_mode(GTK_ICON_VIEW(icon_view), GTK_SELECTION_MULTIPLE); g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL); gtk_widget_show_all(window); gtk_main(); return 0; }
int main(int argc, char** argv) { GtkWidget *window; GtkWidget *scroll_window; GtkWidget *iconview; gtk_init(&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "IconView"); gtk_widget_set_size_request(window, 500, 300); gtk_container_set_border_width(GTK_CONTAINER(window), 5); g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); scroll_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll_window), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(window), scroll_window); iconview = create_icon_view_widget(); //表示項目のラベル設定 gtk_icon_view_set_text_column(GTK_ICON_VIEW(iconview), COLUMN_NAME); //表示項目の画像設定 gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(iconview), COLUMN_PIXBUF); //アイテムの幅を設定 gtk_icon_view_set_item_width(GTK_ICON_VIEW(iconview), 128); //表示されているアイテムがダブルクリックされた時に発生するシグナル g_signal_connect(G_OBJECT(iconview), "item-activated", G_CALLBACK(cb_item_activated), NULL); gtk_container_add(GTK_CONTAINER(scroll_window), iconview); add_data(GTK_ICON_VIEW(iconview)); gtk_widget_show_all(window); gtk_main(); return 0; }
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 GtkIconView* graph_media_modelos_sentimientos_real_filtrar (GraphMediaModelosFiltrable* base, const gchar* consulta, gint lim) { GraphMediaModelosSentimientos * self; GtkIconView* result = NULL; Block9Data* _data9_; GeeArrayList* sentimientos = NULL; GeeArrayList* _tmp0_ = NULL; GtkListStore* _tmp1_ = NULL; GtkListStore* _tmp2_ = NULL; GtkIconView* _tmp3_ = NULL; GtkIconView* _tmp4_ = NULL; GtkIconView* _tmp5_ = NULL; GtkIconView* _tmp6_ = NULL; GtkIconView* _tmp28_ = NULL; GtkIconView* _tmp29_ = NULL; GtkIconView* _tmp30_ = NULL; self = (GraphMediaModelosSentimientos*) base; g_return_val_if_fail (consulta != NULL, NULL); _data9_ = g_slice_new0 (Block9Data); _data9_->_ref_count_ = 1; _data9_->self = g_object_ref (self); _tmp0_ = graph_media_modelos_sentimientos_lista_sentimientos (self); sentimientos = _tmp0_; _tmp1_ = gtk_list_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT64, -1); _data9_->model = _tmp1_; _tmp2_ = _data9_->model; _tmp3_ = (GtkIconView*) gtk_icon_view_new_with_model ((GtkTreeModel*) _tmp2_); g_object_ref_sink (_tmp3_); _data9_->vista = _tmp3_; _tmp4_ = _data9_->vista; gtk_icon_view_set_pixbuf_column (_tmp4_, 0); _tmp5_ = _data9_->vista; gtk_icon_view_set_text_column (_tmp5_, 1); _tmp6_ = _data9_->vista; gtk_icon_view_set_item_width (_tmp6_, 120); memset (&_data9_->iter, 0, sizeof (GtkTreeIter)); { GeeArrayList* _a_list = NULL; GeeArrayList* _tmp7_ = NULL; GeeArrayList* _tmp8_ = NULL; gint _a_size = 0; GeeArrayList* _tmp9_ = NULL; gint _tmp10_ = 0; gint _tmp11_ = 0; gint _a_index = 0; _tmp7_ = sentimientos; _tmp8_ = _g_object_ref0 (_tmp7_); _a_list = _tmp8_; _tmp9_ = _a_list; _tmp10_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp9_); _tmp11_ = _tmp10_; _a_size = _tmp11_; _a_index = -1; while (TRUE) { gint _tmp12_ = 0; gint _tmp13_ = 0; gint _tmp14_ = 0; GraphMediaModelosSentimiento* a = NULL; GeeArrayList* _tmp15_ = NULL; gint _tmp16_ = 0; gpointer _tmp17_ = NULL; GtkListStore* _tmp18_ = NULL; GtkTreeIter _tmp19_ = {0}; GtkListStore* _tmp20_ = NULL; GtkTreeIter _tmp21_ = {0}; GdkPixbuf* _tmp22_ = NULL; GdkPixbuf* _tmp23_ = NULL; GraphMediaModelosSentimiento* _tmp24_ = NULL; const gchar* _tmp25_ = NULL; GraphMediaModelosSentimiento* _tmp26_ = NULL; gint64 _tmp27_ = 0LL; _tmp12_ = _a_index; _a_index = _tmp12_ + 1; _tmp13_ = _a_index; _tmp14_ = _a_size; if (!(_tmp13_ < _tmp14_)) { break; } _tmp15_ = _a_list; _tmp16_ = _a_index; _tmp17_ = gee_abstract_list_get ((GeeAbstractList*) _tmp15_, _tmp16_); a = (GraphMediaModelosSentimiento*) _tmp17_; _tmp18_ = _data9_->model; gtk_list_store_append (_tmp18_, &_tmp19_); _data9_->iter = _tmp19_; _tmp20_ = _data9_->model; _tmp21_ = _data9_->iter; _tmp22_ = graph_media_modelos_filtrable_cargar_icono_ubicacion ((GraphMediaModelosFiltrable*) self, "sentimiento", GRAPH_MEDIA_MODELOS_APP_GUI_TAM_ICONO, GRAPH_MEDIA_MODELOS_APP_GUI_TAM_ICONO); _tmp23_ = _tmp22_; _tmp24_ = a; _tmp25_ = _tmp24_->nombre; _tmp26_ = a; _tmp27_ = _tmp26_->id; gtk_list_store_set (_tmp20_, &_tmp21_, 0, _tmp23_, 1, _tmp25_, 2, _tmp27_, -1); _g_object_unref0 (_tmp23_); _graph_media_modelos_sentimiento_unref0 (a); } _g_object_unref0 (_a_list); } _tmp28_ = _data9_->vista; g_signal_connect_data (_tmp28_, "selection-changed", (GCallback) ___lambda5__gtk_icon_view_selection_changed, block9_data_ref (_data9_), (GClosureNotify) block9_data_unref, 0); _tmp29_ = _data9_->vista; _tmp30_ = _g_object_ref0 (_tmp29_); result = _tmp30_; _g_object_unref0 (sentimientos); block9_data_unref (_data9_); _data9_ = NULL; return result; }
/* 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; }
Compose * compose_new(Config * config) { Compose * compose; GtkAccelGroup * group; GtkWidget * vbox; GtkWidget * toolbar; GtkToolItem * toolitem; GtkSizeGroup * sizegroup; GtkWidget * vpaned; GtkWidget * vbox2; GtkWidget * widget; GtkCellRenderer * renderer; GtkTreeViewColumn * column; GtkTreeIter iter; char const * headers[] = { "To:", "Cc:", "Bcc:", "Reply-To:", "Newsgroup:", "Followup-To:" }; size_t i; if((compose = malloc(sizeof(*compose))) == NULL) { compose_error(NULL, strerror(errno), 0); return NULL; } compose->mime = mime_new(NULL); /* check errors */ if(compose->mime == NULL) { free(compose); return NULL; } compose->config = config; compose->standalone = FALSE; /* window */ group = gtk_accel_group_new(); compose->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_add_accel_group(GTK_WINDOW(compose->window), group); #ifndef EMBEDDED gtk_window_set_default_size(GTK_WINDOW(compose->window), 512, 384); #else gtk_window_set_default_size(GTK_WINDOW(compose->window), 200, 300); #endif gtk_window_set_title(GTK_WINDOW(compose->window), _("Compose")); #if GTK_CHECK_VERSION(2, 6, 0) gtk_window_set_icon_name(GTK_WINDOW(compose->window), "mailer"); #endif g_signal_connect_swapped(G_OBJECT(compose->window), "delete-event", G_CALLBACK(_compose_on_closex), compose); vbox = gtk_vbox_new(FALSE, 0); /* menubar */ #ifndef EMBEDDED widget = desktop_menubar_create(_compose_menubar, compose, group); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); #endif /* toolbar */ toolbar = desktop_toolbar_create(_compose_toolbar, compose, group); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0); /* from */ sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); toolbar = gtk_toolbar_new(); widget = gtk_label_new(_("From: ")); gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5); gtk_widget_set_size_request(widget, 80, -1); gtk_size_group_add_widget(sizegroup, widget); toolitem = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(toolitem), widget); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); #if GTK_CHECK_VERSION(2, 24, 0) compose->from = gtk_combo_box_text_new_with_entry(); #else compose->from = gtk_combo_box_entry_new_text(); #endif toolitem = gtk_tool_item_new(); gtk_tool_item_set_expand(toolitem, TRUE); gtk_container_add(GTK_CONTAINER(toolitem), compose->from); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); /* paned */ vpaned = gtk_vpaned_new(); /* headers */ widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); compose->h_store = gtk_list_store_new(CHC_COUNT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); compose->h_store_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL( compose->h_store), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER( compose->h_store_filter), _compose_on_headers_filter, compose, NULL); compose->h_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL( compose->h_store_filter)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(compose->h_view), FALSE); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(compose->h_view), TRUE); compose->h_headers = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); for(i = 0; i < sizeof(headers) / sizeof(*headers); i++) { gtk_list_store_append(compose->h_headers, &iter); gtk_list_store_set(compose->h_headers, &iter, 0, headers[i], 1, headers[i], -1); } renderer = gtk_cell_renderer_combo_new(); g_object_set(renderer, "editable", TRUE, "model", compose->h_headers, "text-column", 1, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK( _on_header_field_edited), compose); column = gtk_tree_view_column_new_with_attributes("", renderer, "text", CHC_HEADER, NULL); gtk_tree_view_column_set_min_width(column, 80); gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK( _on_header_edited), compose); column = gtk_tree_view_column_new_with_attributes("", renderer, "text", CHC_VALUE, NULL); #if GTK_CHECK_VERSION(2, 4, 0) gtk_tree_view_column_set_expand(column, TRUE); #endif gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column); /* default to 8-bits transfers with UTF-8 encoding */ compose_set_header(compose, "Content-Transfer-Encoding:", "8bit", FALSE); compose_set_header(compose, "Content-Type:", "text/plain; charset=UTF-8", FALSE); compose_add_field(compose, "To:", NULL); gtk_container_add(GTK_CONTAINER(widget), compose->h_view); gtk_paned_add1(GTK_PANED(vpaned), widget); /* paned */ vbox2 = gtk_vbox_new(FALSE, 0); /* subject */ toolbar = gtk_toolbar_new(); widget = gtk_label_new(_("Subject: ")); gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5); gtk_size_group_add_widget(sizegroup, widget); toolitem = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(toolitem), widget); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); compose->subject = gtk_entry_new(); toolitem = gtk_tool_item_new(); gtk_tool_item_set_expand(toolitem, TRUE); gtk_container_add(GTK_CONTAINER(toolitem), compose->subject); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); gtk_box_pack_start(GTK_BOX(vbox2), toolbar, FALSE, TRUE, 0); /* view */ widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); compose->view = _new_text_view(compose); compose_set_font(compose, _compose_get_font(compose)); gtk_container_add(GTK_CONTAINER(widget), compose->view); gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0); gtk_paned_add2(GTK_PANED(vpaned), vbox2); gtk_box_pack_start(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0); /* attachments */ compose->a_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(compose->a_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER); compose->a_store = gtk_list_store_new(CAC_COUNT, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF); compose->a_view = gtk_icon_view_new_with_model(GTK_TREE_MODEL( compose->a_store)); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(compose->a_view), CAC_ICON); gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(compose->a_view), GTK_SELECTION_MULTIPLE); gtk_icon_view_set_text_column(GTK_ICON_VIEW(compose->a_view), CAC_BASENAME); gtk_container_add(GTK_CONTAINER(compose->a_window), compose->a_view); gtk_widget_show_all(compose->a_view); gtk_widget_set_no_show_all(compose->a_window, TRUE); gtk_box_pack_start(GTK_BOX(vbox), compose->a_window, FALSE, TRUE, 0); /* statusbar */ compose->statusbar = gtk_statusbar_new(); compose->statusbar_id = 0; gtk_box_pack_start(GTK_BOX(vbox), compose->statusbar, FALSE, TRUE, 0); gtk_container_add(GTK_CONTAINER(compose->window), vbox); /* about dialog */ compose->ab_window = NULL; /* signature */ compose_append_signature(compose); compose_set_modified(compose, FALSE); compose_scroll_to_offset(compose, 0); /* display */ gtk_widget_grab_focus(compose->view); gtk_widget_show_all(vbox); gtk_widget_show(compose->window); return compose; }
/* * 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; }
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; }
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); }
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 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; }
static void gimp_page_selector_init (GimpPageSelector *selector) { GimpPageSelectorPrivate *priv; GtkWidget *vbox; GtkWidget *sw; GtkWidget *hbox; GtkWidget *hbbox; GtkWidget *button; GtkWidget *label; GtkWidget *combo; selector->priv = G_TYPE_INSTANCE_GET_PRIVATE (selector, GIMP_TYPE_PAGE_SELECTOR, GimpPageSelectorPrivate); priv = GIMP_PAGE_SELECTOR_GET_PRIVATE (selector); priv->n_pages = 0; priv->target = GIMP_PAGE_SELECTOR_TARGET_LAYERS; gtk_orientable_set_orientation (GTK_ORIENTABLE (selector), GTK_ORIENTATION_VERTICAL); gtk_box_set_spacing (GTK_BOX (selector), 12); /* Pages */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_box_pack_start (GTK_BOX (selector), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); gtk_widget_show (sw); priv->store = gtk_list_store_new (4, G_TYPE_INT, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_BOOLEAN); priv->view = gtk_icon_view_new_with_model (GTK_TREE_MODEL (priv->store)); gtk_icon_view_set_text_column (GTK_ICON_VIEW (priv->view), COLUMN_LABEL); gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (priv->view), COLUMN_THUMBNAIL); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (priv->view), GTK_SELECTION_MULTIPLE); gtk_container_add (GTK_CONTAINER (sw), priv->view); gtk_widget_show (priv->view); g_signal_connect (priv->view, "selection-changed", G_CALLBACK (gimp_page_selector_selection_changed), selector); g_signal_connect (priv->view, "item-activated", G_CALLBACK (gimp_page_selector_item_activated), selector); /* Count label */ priv->count_label = gtk_label_new (_("Nothing selected")); gtk_misc_set_alignment (GTK_MISC (priv->count_label), 0.0, 0.5); gimp_label_set_attributes (GTK_LABEL (priv->count_label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_box_pack_start (GTK_BOX (vbox), priv->count_label, FALSE, FALSE, 0); gtk_widget_show (priv->count_label); /* Select all button & range entry */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (selector), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); hbbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (hbox), hbbox, FALSE, FALSE, 0); gtk_widget_show (hbbox); button = gtk_button_new_with_mnemonic (_("Select _All")); gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect_swapped (button, "clicked", G_CALLBACK (gimp_page_selector_select_all), selector); priv->range_entry = gtk_entry_new (); gtk_widget_set_size_request (priv->range_entry, 80, -1); gtk_box_pack_end (GTK_BOX (hbox), priv->range_entry, TRUE, TRUE, 0); gtk_widget_show (priv->range_entry); g_signal_connect (priv->range_entry, "focus-out-event", G_CALLBACK (gimp_page_selector_range_focus_out), selector); g_signal_connect (priv->range_entry, "activate", G_CALLBACK (gimp_page_selector_range_activate), selector); label = gtk_label_new_with_mnemonic (_("Select _range:")); gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->range_entry); /* Target combo */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (selector), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("Open _pages as")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); combo = gimp_prop_enum_combo_box_new (G_OBJECT (selector), "target", -1, -1); gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0); gtk_widget_show (combo); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); priv->default_thumbnail = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "text-x-generic", 32, 0, NULL); }