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); }
JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkIconView_gtk_1icon_1view_1set_1selection_1mode ( JNIEnv* env, jclass cls, jlong _self, jint _mode ) { GtkIconView* self; GtkSelectionMode mode; // convert parameter self self = (GtkIconView*) _self; // convert parameter mode mode = (GtkSelectionMode) _mode; // call function gtk_icon_view_set_selection_mode(self, mode); // cleanup parameter self // cleanup parameter mode }
/** * 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; }
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; }
static void gwy_app_file_chooser_add_preview(GwyAppFileChooser *chooser) { GtkListStore *store; GtkIconView *preview; GtkCellLayout *layout; GtkCellRenderer *renderer; GtkWidget *scwin; gint w; if (gtk_check_version(2, 8, 0)) { g_warning("File previews require Gtk+ 2.8"); return; } scwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scwin), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); store = gtk_list_store_new(2, G_TYPE_STRING, GDK_TYPE_PIXBUF); chooser->preview = gtk_icon_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref(store); preview = GTK_ICON_VIEW(chooser->preview); layout = GTK_CELL_LAYOUT(preview); gtk_icon_view_set_columns(preview, 1); renderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(preview), renderer, FALSE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(preview), renderer, "pixbuf", COLUMN_PIXBUF); renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "wrap-mode", PANGO_WRAP_WORD_CHAR, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(preview), renderer, FALSE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(preview), renderer, "markup", COLUMN_FILEINFO); chooser->renderer_fileinfo = G_OBJECT(renderer); gtk_icon_view_set_selection_mode(preview, GTK_SELECTION_NONE); gtk_icon_view_set_item_width(preview, TMS_NORMAL_THUMB_SIZE); w = TMS_NORMAL_THUMB_SIZE + 2*gtk_icon_view_get_margin(preview); gtk_widget_set_size_request(chooser->preview, w, -1); gtk_container_add(GTK_CONTAINER(scwin), chooser->preview); gtk_widget_show(chooser->preview); gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(chooser), scwin); g_signal_connect(chooser, "update-preview", G_CALLBACK(gwy_app_file_chooser_update_preview), NULL); }
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; }
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; }
/* 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; }
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); }
static void eog_thumb_view_constructed (GObject *object) { EogThumbView *thumbview; if (G_OBJECT_CLASS (eog_thumb_view_parent_class)->constructed) G_OBJECT_CLASS (eog_thumb_view_parent_class)->constructed (object); thumbview = EOG_THUMB_VIEW (object); thumbview->priv->pixbuf_cell = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (thumbview), thumbview->priv->pixbuf_cell, FALSE); g_object_set (thumbview->priv->pixbuf_cell, "follow-state", FALSE, "height", 100, "width", 115, "yalign", 0.5, "xalign", 0.5, NULL); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (thumbview), thumbview->priv->pixbuf_cell, "pixbuf", EOG_LIST_STORE_THUMBNAIL, NULL); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (thumbview), GTK_SELECTION_MULTIPLE); gtk_icon_view_set_column_spacing (GTK_ICON_VIEW (thumbview), EOG_THUMB_VIEW_SPACING); gtk_icon_view_set_row_spacing (GTK_ICON_VIEW (thumbview), EOG_THUMB_VIEW_SPACING); g_object_set (thumbview, "has-tooltip", TRUE, NULL); g_signal_connect (thumbview, "query-tooltip", G_CALLBACK (thumbview_on_query_tooltip_cb), NULL); thumbview->priv->start_thumb = 0; thumbview->priv->end_thumb = 0; thumbview->priv->menu = NULL; g_signal_connect (G_OBJECT (thumbview), "parent-set", G_CALLBACK (thumbview_on_parent_set_cb), NULL); gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW (thumbview), 0, NULL, 0, GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK); gtk_drag_source_add_uri_targets (GTK_WIDGET (thumbview)); g_signal_connect (G_OBJECT (thumbview), "drag-data-get", G_CALLBACK (thumbview_on_drag_data_get_cb), NULL); }
static void gwy_app_file_chooser_add_preview(GwyAppFileChooser *chooser) { GwyContainer *settings; GtkListStore *store; GtkIconView *preview; GtkCellLayout *layout; GtkCellRenderer *renderer; GtkTooltips *tips; GtkWidget *scwin, *vbox, *button, *toolbar; gboolean setting; gint w; scwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scwin), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); store = gtk_list_store_new(2, G_TYPE_STRING, GDK_TYPE_PIXBUF); chooser->preview = gtk_icon_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref(store); preview = GTK_ICON_VIEW(chooser->preview); layout = GTK_CELL_LAYOUT(preview); gtk_icon_view_set_columns(preview, 1); renderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start(layout, renderer, FALSE); gtk_cell_layout_add_attribute(layout, renderer, "pixbuf", COLUMN_PIXBUF); renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "wrap-mode", PANGO_WRAP_WORD_CHAR, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL); gtk_cell_layout_pack_start(layout, renderer, FALSE); gtk_cell_layout_add_attribute(layout, renderer, "markup", COLUMN_FILEINFO); chooser->renderer_fileinfo = G_OBJECT(renderer); gtk_icon_view_set_selection_mode(preview, GTK_SELECTION_NONE); /* In Gtk+ 2.14 and older, things work. 2.16 adds some padding that * breaks everything. And this padding together with the usual margin * meaks too much white space so we have to get rid of the margin in 2.16+. */ if (gtk_major_version == 2 && gtk_minor_version <= 14) { gtk_icon_view_set_item_width(preview, TMS_NORMAL_THUMB_SIZE); w = TMS_NORMAL_THUMB_SIZE + 2*gtk_icon_view_get_margin(preview); } else { gtk_icon_view_set_margin(preview, 0); gtk_icon_view_set_item_width(preview, PADDED_THUMBNAIL_SIZE); w = PADDED_THUMBNAIL_SIZE; } gtk_widget_set_size_request(chooser->preview, w, -1); gtk_container_add(GTK_CONTAINER(scwin), chooser->preview); vbox = gtk_vbox_new(FALSE, 2); chooser->preview_filename = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(chooser->preview_filename), 0.0, 0.5); gtk_label_set_single_line_mode(GTK_LABEL(chooser->preview_filename), TRUE); gtk_label_set_ellipsize(GTK_LABEL(chooser->preview_filename), PANGO_ELLIPSIZE_END); gtk_box_pack_start(GTK_BOX(vbox), chooser->preview_filename, FALSE, FALSE, 0); chooser->preview_type = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(chooser->preview_type), 0.0, 0.5); gtk_label_set_single_line_mode(GTK_LABEL(chooser->preview_type), TRUE); gtk_label_set_ellipsize(GTK_LABEL(chooser->preview_type), PANGO_ELLIPSIZE_END); gtk_box_pack_start(GTK_BOX(vbox), chooser->preview_type, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), scwin, TRUE, TRUE, 0); toolbar = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); settings = gwy_app_settings_get(); tips = gwy_app_get_tooltips(); setting = FALSE; gwy_container_gis_boolean_by_name(settings, "/app/file/preview/plane-level", &setting); button = gtk_toggle_button_new(); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), setting); GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); gtk_tooltips_set_tip(tips, button, _("Plane-level previewed data"), NULL); gtk_container_add(GTK_CONTAINER(button), gtk_image_new_from_stock(GWY_STOCK_LEVEL, GTK_ICON_SIZE_SMALL_TOOLBAR)); gtk_box_pack_start(GTK_BOX(toolbar), button, FALSE, FALSE, 0); g_signal_connect_swapped(button, "toggled", G_CALLBACK(plane_level_changed), chooser); setting = FALSE; gwy_container_gis_boolean_by_name(settings, "/app/file/preview/row-level", &setting); button = gtk_toggle_button_new(); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), setting); GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); gtk_tooltips_set_tip(tips, button, _("Row-level previewed data"), NULL); gtk_container_add(GTK_CONTAINER(button), gtk_image_new_from_stock(GWY_STOCK_LINE_LEVEL, GTK_ICON_SIZE_SMALL_TOOLBAR)); gtk_box_pack_start(GTK_BOX(toolbar), button, FALSE, FALSE, 0); g_signal_connect_swapped(button, "toggled", G_CALLBACK(row_level_changed), chooser); gtk_widget_show_all(vbox); gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(chooser), vbox); gtk_file_chooser_set_use_preview_label(GTK_FILE_CHOOSER(chooser), FALSE); g_signal_connect(chooser, "update-preview", G_CALLBACK(gwy_app_file_chooser_update_preview), NULL); toolbar = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); }
static gboolean remap_dialog (gint32 image_ID, guchar *map) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *box; GtkWidget *iconview; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeIter iter; guchar *cmap; gint ncols, i; gboolean valid; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Rearrange Colormap"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC_REMAP, GIMP_STOCK_RESET, RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), RESPONSE_RESET, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), vbox, TRUE, TRUE, 0); cmap = gimp_image_get_colormap (image_ID, &ncols); g_return_val_if_fail ((ncols > 0) && (ncols <= 256), FALSE); store = gtk_list_store_new (NUM_COLS, G_TYPE_INT, G_TYPE_STRING, GIMP_TYPE_RGB, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE); for (i = 0; i < ncols; i++) { GimpRGB rgb; GimpHSV hsv; gint index = map[i]; gchar *text = g_strdup_printf ("%d", index); gimp_rgb_set_uchar (&rgb, cmap[index * 3], cmap[index * 3 + 1], cmap[index * 3 + 2]); gimp_rgb_to_hsv (&rgb, &hsv); reverse_order[i] = ncols - i - 1; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COLOR_INDEX, index, COLOR_INDEX_TEXT, text, COLOR_RGB, &rgb, COLOR_H, hsv.h, COLOR_S, hsv.s, COLOR_V, hsv.v, -1); g_free (text); } g_free (cmap); remap_ui = remap_ui_manager_new (dialog, store); iconview = gtk_icon_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_box_pack_start (GTK_BOX (vbox), iconview, TRUE, TRUE, 0); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (iconview), GTK_SELECTION_SINGLE); gtk_icon_view_set_orientation (GTK_ICON_VIEW (iconview), GTK_ORIENTATION_VERTICAL); gtk_icon_view_set_columns (GTK_ICON_VIEW (iconview), 16); gtk_icon_view_set_row_spacing (GTK_ICON_VIEW (iconview), 0); gtk_icon_view_set_column_spacing (GTK_ICON_VIEW (iconview), 0); gtk_icon_view_set_reorderable (GTK_ICON_VIEW (iconview), TRUE); renderer = gimp_cell_renderer_color_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (iconview), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (iconview), renderer, "color", COLOR_RGB, NULL); g_object_set (renderer, "width", 24, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (iconview), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (iconview), renderer, "text", COLOR_INDEX_TEXT, NULL); g_object_set (renderer, "size-points", 6.0, "xalign", 0.5, "ypad", 0, NULL); g_signal_connect (iconview, "popup-menu", G_CALLBACK (remap_popup_menu), NULL); g_signal_connect (iconview, "button-press-event", G_CALLBACK (remap_button_press), NULL); box = gimp_hint_box_new (_("Drag and drop colors to rearrange the colormap. " "The numbers shown are the original indices. " "Right-click for a menu with sort options.")); gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 0); gtk_widget_show (box); g_signal_connect (dialog, "response", G_CALLBACK (remap_response), store); gtk_widget_show_all (dialog); gtk_main (); i = 0; for (valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter); valid; valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter)) { gint index; gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, COLOR_INDEX, &index, -1); map[i++] = index; } gtk_widget_destroy (dialog); return remap_run; }
void toolbar2___::with__(window___* w, void*shangji,void*ce,deque<string>* p, int addr_fmt, char*buf) { toolbar2_item___* item; if((*p)[1] == toolbar2_tag2_) { init__(w->box2__(), left_icon_item_); item = left_icon_item_; } else if((*p)[1] == toolbar2_tag3_) { init__(w->box2__(), tree_item_); item = tree_item_; } else if((*p)[1] == toolbar2_tag4_) { init__(w->box3__(), right_icon_item_); item = right_icon_item_; } else if((*p)[1] == toolbar2_tag5_) { init__(w->box4__(), bottom_icon_item_); item = bottom_icon_item_; } else if((*p)[1] == toolbar2_tag6_) { init__(w->box3__(), right_tree_item_); item = right_tree_item_; } else { init__(w->box__(), icon_item_); item = icon_item_; } for(size_t i2=2;i2<p->size();i2++){ const string& p2=(*p)[i2]; if(p2 == "选择") { GtkTreeModel *m = item->model__(); GtkTreeIter i; GtkTreePath *path; for(size_t i3 = i2;i3 < p->size() - 1;) { int id2 = 0; if(!set__(i3, p, id2)) return; if(!iter_by_id__(m, id2, &i)) { buzhichi__(i3, p); return; } switch(item->tag_) { case 'i': path = gtk_tree_model_get_path (m, &i); gtk_icon_view_select_path (item->icon_view__(), path); gtk_tree_path_free (path); break; } } return; } if(p2 == "遍历") { if(buzu__(++i2, p)) return; item->for__((*p)[i2], ce, shangji); continue; } if(p2 == "设") { int id = 0; if(!set__(i2, p, id)) return; callback_item___* cbi = callback_item__(id); if(!cbi) { wufa__(p->size(), p); return; } GtkTreeModel *m = item->model__(); GtkTreeIter i; for(i2++; i2 < p->size(); i2++) { const string& p3 = (*p)[i2]; if(p3 == "名") { if(set__(i2, p, cbi->title_)) { if(!iter_by_id__(m, cbi->id_, &i)) { buzhichi__(i2, p); return; } switch(item->tag_) { case 'i': gtk_list_store_set(((icon_item___*)item)->store_, &i, TITLE_COLUMN, cbi->title_.c_str(), -1); continue; } } return; } if(p3 == "提示") {if(set__(i2, p, cbi->tooltip_)) continue; return;} if(p3 == "图标") { string name; if(!set__(i2, p, name)) return; GdkPixbuf *pixbuf = item->get_icon__(name); switch(item->tag_) { case 'i': gtk_list_store_set(((icon_item___*)item)->store_, &i, PIXBUF_COLUMN, pixbuf, -1); break; } g_object_unref (pixbuf); continue; } buzhichi__(i2, p); } break; } if(p2 == "获取") { string code3; if(!set__(i2, p, code3)) return; switch(item->tag_) { case 'i': icon_view_select__(item->icon_view__(), code3.c_str(), shangji, ce); break; } continue; } #ifdef ver_gtk3_ if(p2 == "宽") { if(buzu__(++i2, p)) return; gtk_scrolled_window_set_min_content_width(item->scrolled__(), s2i__((*p)[i2])); continue; } if(p2 == "高") { if(buzu__(++i2, p)) return; gtk_scrolled_window_set_min_content_height(item->scrolled__(), s2i__((*p)[i2])); continue; } #endif if(p2 == "名") { if(buzu__(++i2, p)) return; if(item->label_) { gtk_label_set_markup(GTK_LABEL(item->label_), (*p)[i2].c_str()); } continue; } if(p2 == "钮宽") {if(set__(i2, p, item->btn_width_)) continue; return;} if(p2 == "钮高") {if(set__(i2, p, item->btn_height_)) continue; return;} if(p2 == "名提示") {item->title_tooltip_ = true; continue;} if(p2 == "可拖动") { switch(item->tag_) { case 'i': gtk_icon_view_set_reorderable(item->icon_view__(), true); break; case 't': gtk_tree_view_set_reorderable(item->tree_view__(), true); break; } continue; } if(p2 == "可选择") { int i; if(!set__(i2, p, i)) return; switch(item->tag_) { case 'i': gtk_icon_view_set_selection_mode(item->icon_view__(), (GtkSelectionMode)i); break; } continue; } if(p2 == "无标题") { if(item->tag_ == 'i') { //gtk_icon_view_set_text_column (item->icon_view__(), -1); gtk_icon_view_set_markup_column (item->icon_view__(), -1); continue; } buzhichi__(i2, p); return; } //gtk_icon_view_set_selection_mode (iconview__(), GTK_SELECTION_MULTIPLE); if(p2 == "列头") { if(buzu__(++i2, p)) return; if(item->tag_ == 't') { tree_item___* ti = (tree_item___*)item; gtk_tree_view_column_set_title(ti->col_, (*p)[i2].c_str()); continue; } buzhichi__(i2, p); return; } if(p2 == "删钮") { GtkTreeModel *m = item->model__(); GtkTreeIter i; for(size_t i3 = i2;i3 < p->size() - 1;) { int id2 = 0; if(!set__(i3, p, id2)) return; if(!iter_by_id__(m, id2, &i)) { buzhichi__(i3, p); return; } item->store_del__(&i); } break; } if(p2 == "加钮") { string title, tooltip, code, arg, code2, arg2, code3_2; string set_up; int posi = -1; for(i2++;i2<p->size();i2++){ const string& p3=(*p)[i2]; if(p3 == "名") {if(set__(i2, p, title)) continue; return;} if(p3 == "提示") {if(set__(i2, p, tooltip)) continue; return;} if(p3 == "代码") {if(set__(i2, p, code)) continue; return;} if(p3 == "附") {if(set__(i2, p, arg)) continue; return;} if(p3 == "位置") {if(set__(i2, p, posi)) continue; return;} if(p3 == "缺省代码") {if(set__(i2, p, item->def_code_)) continue; return;} if(p3 == "缺省附") {if(set__(i2, p, item->def_arg_)) continue; return;} if(p3 == "双击代码") {if(set__(i2, p, code2)) continue; return;} if(p3 == "双击附") {if(set__(i2, p, arg2)) continue; return;} if(p3 == "缺省双击代码") {if(set__(i2, p, item->def_code2_)) continue; return;} if(p3 == "缺省双击附") {if(set__(i2, p, item->def_arg2_)) continue; return;} if(p3 == "右击代码") {if(set__(i2, p, code3_2)) continue; return;} if(p3 == "缺省右击代码") {if(set__(i2, p, item->def_code3_2_)) continue; return;} if(p3 == "设置上") {if(set__(i2, p, set_up)) continue; return;} if(p3 == "恢复上") { if(item->tag_ == 't') { string restore_up; if(set__(i2, p, restore_up)) { int err; const char* ret = call4__(ce, restore_up, shangji, 0, NULL, &err); if(err) return; ((tree_item___*)item)->up_ = ret; } } else { buzhichi__(i2, p); } return; } if(p3 == "大小") { if(buzu__(++i2, p)) return; item->btn_width_ = item->btn_height_ = s2i__((*p)[i2]) * 8; continue; } if(p3 == "-") continue; GdkPixbuf *pixbuf = item->get_icon__(p3); callback_item___* si = new callback_item___(title, !code.empty() ? code : item->def_code_, !arg.empty() ? arg : item->def_arg_, tooltip.empty() && item->title_tooltip_ ? title : tooltip); si->add_code__(!code2.empty() ? code2 : item->def_code2_); si->add_arg__(!arg2.empty() ? arg2 : item->def_arg2_); si->add_code__(!code3_2.empty() ? code3_2 : item->def_code3_2_); item->store_add__(si, pixbuf, posi); g_object_unref (pixbuf); if(!set_up.empty()) { if(item->tag_ == 't') { tree_item___* ti = (tree_item___*)item; const char* argv[] = {ti->up_.c_str()}; int err; call4__(ce, set_up, shangji, 1, argv, &err); if(err) return; ti->up_ = ti->last_; } else { buzhichi__(i2, p); return; } set_up.clear(); } code.clear(); arg.clear(); tooltip.clear(); code2.clear(); arg2.clear(); code3_2.clear(); posi = -1; } break; } if(p2 == "清空") { switch(item->tag_) { case 'i': gtk_list_store_clear (((icon_item___*)item)->store_); continue; } } if(p2 == "地址") { if(addr_fmt == 16) l2x__((long)item->scrolled_, buf); else l2s__((long)item->scrolled_, buf); continue; } buzhichi__(i2, p); return; } }
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; }
GtkWidget * do_iconview_edit (GtkWidget *do_widget) { if (!window) { GtkWidget *icon_view; GtkListStore *store; GtkCellRenderer *renderer; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Editing and Drag-and-Drop"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); store = create_store (); fill_store (store); icon_view = gtk_icon_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (icon_view), GTK_SELECTION_SINGLE); gtk_icon_view_set_item_orientation (GTK_ICON_VIEW (icon_view), GTK_ORIENTATION_HORIZONTAL); gtk_icon_view_set_columns (GTK_ICON_VIEW (icon_view), 2); gtk_icon_view_set_reorderable (GTK_ICON_VIEW (icon_view), TRUE); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_view), renderer, TRUE); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (icon_view), renderer, set_cell_color, NULL, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_view), renderer, TRUE); g_object_set (renderer, "editable", TRUE, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (edited), icon_view); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_view), renderer, "text", COL_TEXT, NULL); gtk_container_add (GTK_CONTAINER (window), icon_view); } if (!gtk_widget_get_visible (window)) gtk_widget_show_all (window); else { gtk_widget_destroy (window); window = NULL; } return window; }