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;
}
