自学教程：C++ GTK_BUTTON函数代码示例

static void _set_playPauseImage (CustomData *data, const gchar *stockid) {        gtk_image_set_from_stock(                        GTK_IMAGE (gtk_button_get_image (GTK_BUTTON (data->playPauseButton))),                        stockid, GTK_ICON_SIZE_BUTTON);}

/****************************************************************  Worklist editor shell.*****************************************************************/GtkWidget *create_worklist(void){  GtkWidget *editor, *table, *sw, *bbox;  GtkWidget *src_view, *dst_view, *label, *button;  GtkWidget *menubar, *item, *menu, *image;  GtkWidget *table2, *arrow, *check;  GtkSizeGroup *group;  GtkListStore *src_store, *dst_store;  struct worklist_data *ptr;  ptr = fc_malloc(sizeof(*ptr));  src_store = gtk_list_store_new(1, G_TYPE_INT);  dst_store = gtk_list_store_new(1, G_TYPE_INT);  ptr->global_worklist_id = -1;  ptr->pcity = NULL;  ptr->src = src_store;  ptr->dst = dst_store;  ptr->future = FALSE;  /* create shell. */   editor = gtk_grid_new();  gtk_grid_set_row_spacing(GTK_GRID(editor), 6);  gtk_orientable_set_orientation(GTK_ORIENTABLE(editor),                                 GTK_ORIENTATION_VERTICAL);  g_signal_connect(editor, "destroy", G_CALLBACK(worklist_destroy), ptr);  g_object_set_data(G_OBJECT(editor), "data", ptr);  ptr->editor = editor;  /* add source and target lists.  */  table = gtk_grid_new();  gtk_container_add(GTK_CONTAINER(editor), table);  group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);  sw = gtk_scrolled_window_new(NULL, NULL);  gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),				      GTK_SHADOW_ETCHED_IN);  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),				 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);  gtk_grid_attach(GTK_GRID(table), sw, 3, 1, 2, 1);  src_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(src_store));  gtk_widget_set_hexpand(src_view, TRUE);  gtk_widget_set_vexpand(src_view, TRUE);  g_object_unref(src_store);  gtk_size_group_add_widget(group, src_view);  gtk_widget_set_name(src_view, "small_font");  populate_view(GTK_TREE_VIEW(src_view), &ptr->pcity, &ptr->src_col);  gtk_container_add(GTK_CONTAINER(sw), src_view);  label = g_object_new(GTK_TYPE_LABEL,		       "use-underline", TRUE,		       "mnemonic-widget", src_view,		       "label", _("Source _Tasks:"),		       "xalign", 0.0, "yalign", 0.5, NULL);  gtk_grid_attach(GTK_GRID(table), label, 3, 0, 1, 1);  check = gtk_check_button_new_with_mnemonic(_("Show _Future Targets"));  gtk_grid_attach(GTK_GRID(table), check, 4, 0, 1, 1);  g_signal_connect(check, "toggled", G_CALLBACK(future_callback), ptr);  table2 = gtk_grid_new();  gtk_grid_attach(GTK_GRID(table), table2, 2, 1, 1, 1);  button = gtk_button_new();  gtk_widget_set_margin_top(button, 24);  gtk_widget_set_margin_bottom(button, 24);  ptr->prepend_cmd = button;  gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);  gtk_grid_attach(GTK_GRID(table2), button, 0, 0, 1, 1);  arrow = gtk_arrow_new(GTK_ARROW_LEFT, GTK_SHADOW_NONE);  gtk_container_add(GTK_CONTAINER(button), arrow);  g_signal_connect_swapped(button, "clicked",			   G_CALLBACK(queue_prepend), ptr);  gtk_widget_set_sensitive(ptr->prepend_cmd, FALSE);  button = gtk_button_new();  ptr->up_cmd = button;  gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);  gtk_grid_attach(GTK_GRID(table2), button, 0, 1, 1, 1);  arrow = gtk_arrow_new(GTK_ARROW_UP, GTK_SHADOW_NONE);  gtk_container_add(GTK_CONTAINER(button), arrow);  g_signal_connect_swapped(button, "clicked",			   G_CALLBACK(queue_bubble_up), ptr);  gtk_widget_set_sensitive(ptr->up_cmd, FALSE);  button = gtk_button_new();  ptr->down_cmd = button;  gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);//.........这里部分代码省略.........

voidcaja_x_content_bar_set_x_content_type (CajaXContentBar *bar, const char *x_content_type){    char *message;    char *description;    GAppInfo *default_app;    g_free (bar->priv->x_content_type);    bar->priv->x_content_type = g_strdup (x_content_type);    description = g_content_type_get_description (x_content_type);    /* Customize greeting for well-known x-content types */    if (strcmp (x_content_type, "x-content/audio-cdda") == 0)    {        message = g_strdup (_("These files are on an Audio CD."));    }    else if (strcmp (x_content_type, "x-content/audio-dvd") == 0)    {        message = g_strdup (_("These files are on an Audio DVD."));    }    else if (strcmp (x_content_type, "x-content/video-dvd") == 0)    {        message = g_strdup (_("These files are on a Video DVD."));    }    else if (strcmp (x_content_type, "x-content/video-vcd") == 0)    {        message = g_strdup (_("These files are on a Video CD."));    }    else if (strcmp (x_content_type, "x-content/video-svcd") == 0)    {        message = g_strdup (_("These files are on a Super Video CD."));    }    else if (strcmp (x_content_type, "x-content/image-photocd") == 0)    {        message = g_strdup (_("These files are on a Photo CD."));    }    else if (strcmp (x_content_type, "x-content/image-picturecd") == 0)    {        message = g_strdup (_("These files are on a Picture CD."));    }    else if (strcmp (x_content_type, "x-content/image-dcf") == 0)    {        message = g_strdup (_("The media contains digital photos."));    }    else if (strcmp (x_content_type, "x-content/audio-player") == 0)    {        message = g_strdup (_("These files are on a digital audio player."));    }    else if (strcmp (x_content_type, "x-content/software") == 0)    {        message = g_strdup (_("The media contains software."));    }    else    {        /* fallback to generic greeting */        message = g_strdup_printf (_("The media has been detected as /"%s/"."), description);    }    gtk_label_set_text (GTK_LABEL (bar->priv->label), message);    gtk_widget_show (bar->priv->label);    /* TODO: We really need a GtkBrowserBackButton-ish widget here.. until then, we only     *       show the default application. */    default_app = g_app_info_get_default_for_type (x_content_type, FALSE);    if (default_app != NULL)    {        char *button_text;        const char *name;        GIcon *icon;        GtkWidget *image;        icon = g_app_info_get_icon (default_app);        if (icon != NULL)        {            GdkPixbuf *pixbuf;            int icon_size;            CajaIconInfo *icon_info;            icon_size = caja_get_icon_size_for_stock_size (GTK_ICON_SIZE_BUTTON);            icon_info = caja_icon_info_lookup (icon, icon_size);            pixbuf = caja_icon_info_get_pixbuf_at_size (icon_info, icon_size);            image = gtk_image_new_from_pixbuf (pixbuf);            g_object_unref (pixbuf);            g_object_unref (icon_info);        }        else        {            image = NULL;        }        name = g_app_info_get_display_name (default_app);        button_text = g_strdup_printf (_("Open %s"), name);        gtk_button_set_image (GTK_BUTTON (bar->priv->button), image);        gtk_button_set_label (GTK_BUTTON (bar->priv->button), button_text);        gtk_widget_show (bar->priv->button);        g_free (button_text);        g_object_unref (default_app);//.........这里部分代码省略.........

//.........这里部分代码省略.........    if(dir)    {        while((d_name = g_dir_read_name(dir)))        {            snprintf(filename, DT_MAX_PATH_LEN, "%s/%s", dirname, d_name);            tmpprof = cmsOpenProfileFromFile(filename, "r");            if(tmpprof)            {                char *lang = getenv("LANG");                if (!lang) lang = "en_US";                dt_lib_export_profile_t *prof = (dt_lib_export_profile_t *)g_malloc0(sizeof(dt_lib_export_profile_t));                char name[1024];                cmsGetProfileInfoASCII(tmpprof, cmsInfoDescription, lang, lang+3, name, 1024);                g_strlcpy(prof->name, name, sizeof(prof->name));                g_strlcpy(prof->filename, d_name, sizeof(prof->filename));                prof->pos = ++pos;                cmsCloseProfile(tmpprof);                d->profiles = g_list_append(d->profiles, prof);            }        }        g_dir_close(dir);    }    GList *l = d->profiles;    label = gtk_label_new(_("profile"));    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);    gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 9, 10, GTK_EXPAND|GTK_FILL, 0, 0, 0);    d->profile = GTK_COMBO_BOX(gtk_combo_box_new_text());    dt_ellipsize_combo(d->profile);    gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->profile), 1, 2, 9, 10, GTK_SHRINK|GTK_EXPAND|GTK_FILL, 0, 0, 0);    // gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->profile), 1, 2, 9, 10, GTK_EXPAND|GTK_FILL, 0, 0, 0);    gtk_combo_box_append_text(d->profile, _("image settings"));    while(l)    {        dt_lib_export_profile_t *prof = (dt_lib_export_profile_t *)l->data;        if(!strcmp(prof->name, "X profile"))            gtk_combo_box_append_text(d->profile, _("system display profile"));        else            gtk_combo_box_append_text(d->profile, prof->name);        l = g_list_next(l);    }    gtk_combo_box_set_active(d->profile, 0);    char tooltip[1024];    snprintf(tooltip, 1024, _("output icc profiles in %s/color/out or %s/color/out"), confdir, datadir);    g_object_set(G_OBJECT(d->profile), "tooltip-text", tooltip, (char *)NULL);    //  Add style combo    label = gtk_label_new(_("style"));    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);    gtk_table_attach(GTK_TABLE(self->widget), label, 0, 1, 10, 11, GTK_EXPAND|GTK_FILL, 0, 0, 0);    d->style = GTK_COMBO_BOX(gtk_combo_box_new_text());    dt_ellipsize_combo(d->style);    gtk_combo_box_append_text(d->style, _("none"));    GList *styles = dt_styles_get_list("");    while (styles)    {        dt_style_t *style=(dt_style_t *)styles->data;        gtk_combo_box_append_text(d->style, style->name);        styles=g_list_next(styles);    }    gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(d->style), 1, 2, 10, 11, GTK_EXPAND|GTK_FILL, 0, 0, 0);    g_object_set(G_OBJECT(d->style), "tooltip-text", _("temporary style to append while exporting"), (char *)NULL);    //  Set callback signals    g_signal_connect (G_OBJECT (d->intent), "changed",                      G_CALLBACK (intent_changed),                      (gpointer)d);    g_signal_connect (G_OBJECT (d->profile), "changed",                      G_CALLBACK (profile_changed),                      (gpointer)d);    g_signal_connect (G_OBJECT (d->style), "changed",                      G_CALLBACK (style_changed),                      (gpointer)d);    // Export button    GtkButton *button = GTK_BUTTON(gtk_button_new_with_label(_("export")));    d->export_button = button;    g_object_set(G_OBJECT(button), "tooltip-text", _("export with current settings (ctrl-e)"), (char *)NULL);    gtk_table_attach(GTK_TABLE(self->widget), GTK_WIDGET(button), 1, 2, 11, 12, GTK_EXPAND|GTK_FILL, 0, 0, 0);    g_signal_connect (G_OBJECT (button), "clicked",                      G_CALLBACK (export_button_clicked),                      (gpointer)self);    g_signal_connect (G_OBJECT (d->width), "value-changed",                      G_CALLBACK (width_changed),                      (gpointer)0);    g_signal_connect (G_OBJECT (d->height), "value-changed",                      G_CALLBACK (height_changed),                      (gpointer)0);    self->gui_reset(self);}

static voids_typeslist_changed (GtkWidget *w, gpointer d){	AP_UnixDialog_Styles * dlg = static_cast <AP_UnixDialog_Styles *>(d);	dlg->event_ListClicked (gtk_button_get_label (GTK_BUTTON(w)));}

static void wibuti_prefs_init(WibutiPrefs *self) {	GError *err = NULL;	char *markup = "";	GtkBox *main_box = GTK_BOX(gtk_vbox_new(FALSE, 5));	GtkNotebook *notebook = GTK_NOTEBOOK(gtk_notebook_new());	GtkButton *btn_close = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_CLOSE));	GtkButtonBox *btnbox = GTK_BUTTON_BOX(gtk_hbutton_box_new());	GtkLabel *label_layout_tip = GTK_LABEL(gtk_label_new(""));	self->builder = gtk_builder_new();#ifdef WIBUTI_WITH_BUTTONS	GtkAlignment *alignment_theme, *alignment_buttons;	GtkLabel *label_theme, *label_buttons;	gtk_builder_add_from_file(self->builder, WIBUTI_PATH_BUTTONS_UI, &err);	if (err != NULL) {		g_fprintf(stderr, "%s/n", err->message);		g_error_free(err);	} else {		alignment_theme = GTK_ALIGNMENT(gtk_builder_get_object(self->builder, "alignment_theme"));		alignment_buttons = GTK_ALIGNMENT(gtk_builder_get_object(self->builder, "alignment_buttons"));		self->combo_theme = GTK_COMBO_BOX(gtk_builder_get_object(self->builder, CFG_THEME));		self->chkb_hover_effect = GTK_TOGGLE_BUTTON(gtk_builder_get_object(self->builder, CFG_HOVER_EFFECT));		self->chkb_click_effect = GTK_TOGGLE_BUTTON(gtk_builder_get_object(self->builder, CFG_CLICK_EFFECT));		// fill themes combo		GtkListStore *list_store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);		GtkCellRenderer *renderer = gtk_cell_renderer_text_new();		gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(self->combo_theme), renderer, TRUE);		gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(self->combo_theme), renderer, "text", 0, NULL);		gtk_combo_box_set_model(self->combo_theme, GTK_TREE_MODEL(list_store));		const gchar *subdir;		GDir *dir = g_dir_open(WIBUTI_PATH_THEMES, 0, NULL);		while ((subdir = g_dir_read_name(dir)) != NULL) {			GtkTreeIter iter;			gtk_list_store_append(list_store, &iter);			gtk_list_store_set(list_store, &iter, 0, subdir, 1, 0, -1);		}		g_dir_close(dir);		// pack to notebook		label_theme = GTK_LABEL(gtk_label_new("Themes"));		gtk_notebook_append_page(notebook, GTK_WIDGET(alignment_theme), GTK_WIDGET(label_theme));		label_buttons = GTK_LABEL(gtk_label_new("Buttons"));		gtk_notebook_append_page(notebook, GTK_WIDGET(alignment_buttons), GTK_WIDGET(label_buttons));				markup = g_strconcat(markup, "<b>M</b> - ", "minimize", "/n<b>R</b> - ", "maximize/restore", 		                             "/n<b>X</b> - ", "close", "/n", NULL);	}#endif // WIBUTI_WITH_BUTTONS#ifdef WIBUTI_WITH_TITLE	GtkAlignment *alignment_title;	GtkLabel *label_title;	gtk_builder_add_from_file(self->builder, WIBUTI_PATH_TITLE_UI, &err);	if (err != NULL) {		g_fprintf(stderr, "%s/n", err->message);		g_error_free(err);	} else {		alignment_title = GTK_ALIGNMENT(gtk_builder_get_object(self->builder, "alignment_title"));				self->chkb_expand_title = GTK_TOGGLE_BUTTON(gtk_builder_get_object(self->builder, CFG_EXPAND_TITLE));		self->chkb_custom_style = GTK_TOGGLE_BUTTON(gtk_builder_get_object(self->builder, CFG_CUSTOM_STYLE));				self->btn_font_active = GTK_FONT_BUTTON(gtk_builder_get_object(self->builder, "btn_font_active"));		self->btn_font_inactive = GTK_FONT_BUTTON(gtk_builder_get_object(self->builder, "btn_font_inactive"));		self->btn_color_active = GTK_COLOR_BUTTON(gtk_builder_get_object(self->builder, "btn_color_active"));		self->btn_color_inactive = GTK_COLOR_BUTTON(gtk_builder_get_object(self->builder, "btn_color_inactive"));		self->scale_alignment = GTK_SCALE(gtk_builder_get_object(self->builder, "scale_alignment"));		// pack to notebook		label_title = GTK_LABEL(gtk_label_new("Title"));		gtk_notebook_append_page(notebook, GTK_WIDGET(alignment_title), GTK_WIDGET(label_title));				markup = g_strconcat(markup, "<b>I</b> - ", "icon", "/n<b>T</b> - ", "title", "/n", NULL);	}#endif // WIBUTI_WITH_TITLE		GtkAlignment *alignment_general;	GtkLabel *label_general;	gtk_builder_add_from_file(self->builder, WIBUTI_PATH_GENERAL_UI, &err);	if (err != NULL) {		g_fprintf(stderr, "%s/n", err->message);		g_error_free(err);	} else {		alignment_general = GTK_ALIGNMENT(gtk_builder_get_object(self->builder, "alignment_general"));		label_layout_tip = GTK_LABEL(gtk_builder_get_object(self->builder, "label_layout_tip"));		self->chkb_only_maximized = GTK_TOGGLE_BUTTON(gtk_builder_get_object(self->builder, CFG_ONLY_MAXIMIZED));		self->chkb_hide_unmaximized = GTK_TOGGLE_BUTTON(gtk_builder_get_object(self->builder, CFG_HIDE_ON_UNMAXIMIZED));		self->btn_reload_layout = GTK_BUTTON(gtk_builder_get_object(self->builder, "btn_reload_layout"));		self->entry_layout = GTK_ENTRY(gtk_builder_get_object(self->builder, "entry_layout"));				// pack to notebook//.........这里部分代码省略.........

static voidappend_widget(GtkTreeStore *model,              GtkWidget *widget,              GtkTreeIter *parent_iter){    GtkTreeIter iter;    const char *class_name = G_OBJECT_CLASS_NAME(GTK_WIDGET_GET_CLASS(widget));    const char *name;    char *row_color = NULL;    char *window_info;    char *address;    gboolean realized;    gboolean mapped;    gboolean visible;    GList *l;    name = gtk_widget_get_name(widget);    if (name == NULL || strcmp(name, class_name) == 0) {        if (GTK_IS_LABEL(widget))        {            name = gtk_label_get_text(GTK_LABEL(widget));        }        else if (GTK_IS_BUTTON(widget))        {            name = gtk_button_get_label(GTK_BUTTON(widget));        }        else if (GTK_IS_WINDOW(widget))        {            name = gtk_window_get_title(GTK_WINDOW(widget));        }        else        {            name = "";        }    }    if (gtk_widget_get_window(widget))    {#if HAVE_X11	window_info = g_strdup_printf("%p (XID 0x%x)", widget->window,	                              (int)GDK_WINDOW_XID(widget->window));#else	window_info = g_strdup("");#endif    }    else    {        window_info = g_strdup("");    }    address = g_strdup_printf("%p", widget);    realized = gtk_widget_get_realized(widget);    mapped = gtk_widget_get_mapped(widget);    visible = gtk_widget_get_visible(widget);    if (!realized || !mapped || !visible)    {        GtkStyle* style = gtk_widget_get_style(GTK_WIDGET(widget));        GdkColor color = style->fg[GTK_STATE_INSENSITIVE];        row_color = gdk_color_to_string(&color);    }    gtk_tree_store_append(model, &iter, parent_iter);    gtk_tree_store_set(model, &iter,                       WIDGET, widget,                       WIDGET_TYPE, class_name,                       WIDGET_NAME, name,                       WIDGET_REALIZED, realized,                       WIDGET_MAPPED, mapped,                       WIDGET_VISIBLE, visible,                       WIDGET_WINDOW, window_info,                       WIDGET_ADDRESS, address,                       ROW_COLOR, row_color,                       -1);    g_free(window_info);    g_free(address);    g_free(row_color);    if (GTK_IS_CONTAINER(widget))    {        GList* children = NULL;        /* Pick up all children, including those that are internal. */        gtk_container_forall(GTK_CONTAINER(widget),                             on_container_forall, &children);        for (l = children; l != NULL; l = l->next)        {            append_widget(model, GTK_WIDGET(l->data), &iter);        }        g_list_free(children);    }}

/* construct widget above */void gui_init(struct dt_imageio_module_storage_t *self){  self->gui_data = g_malloc0(sizeof(dt_storage_facebook_gui_data_t));  dt_storage_facebook_gui_data_t *ui = self->gui_data;  ui->facebook_api = fb_api_init();  self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);  // create labels  ui->label_album_title = GTK_LABEL(gtk_label_new(_("title")));  ui->label_album_summary = GTK_LABEL(gtk_label_new(_("summary")));  ui->label_album_privacy = GTK_LABEL(gtk_label_new(_("privacy")));  ui->label_status = GTK_LABEL(gtk_label_new(NULL));  gtk_widget_set_halign(GTK_WIDGET(ui->label_album_title), GTK_ALIGN_START);  gtk_widget_set_halign(GTK_WIDGET(ui->label_album_summary), GTK_ALIGN_START);  gtk_widget_set_halign(GTK_WIDGET(ui->label_album_privacy), GTK_ALIGN_START);  // create entries  GtkListStore *model_username = gtk_list_store_new(COMBO_USER_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING,                                                    G_TYPE_STRING); // text, token, id  ui->comboBox_username = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_username)));  GtkCellRenderer *p_cell = gtk_cell_renderer_text_new();  gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->comboBox_username), p_cell, FALSE);  gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->comboBox_username), p_cell, "text", 0, NULL);  ui->entry_album_title = GTK_ENTRY(gtk_entry_new());  ui->entry_album_summary = GTK_ENTRY(gtk_entry_new());  dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->comboBox_username));  dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_title));  dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_summary));  gtk_entry_set_width_chars(GTK_ENTRY(ui->entry_album_title), 0);  gtk_entry_set_width_chars(GTK_ENTRY(ui->entry_album_summary), 0);  // retrieve saved accounts  ui_refresh_users(ui);  //////// album list /////////  GtkWidget *albumlist = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);  GtkListStore *model_album      = gtk_list_store_new(COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING); // name, id  ui->comboBox_album = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_album)));  p_cell = gtk_cell_renderer_text_new();  gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->comboBox_album), p_cell, FALSE);  gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->comboBox_album), p_cell, "text", 0, NULL);  gtk_widget_set_sensitive(GTK_WIDGET(ui->comboBox_album), FALSE);  gtk_combo_box_set_row_separator_func(ui->comboBox_album, combobox_separator, ui->comboBox_album, NULL);  gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox_album), TRUE, TRUE, 0);  ui->comboBox_privacy = GTK_COMBO_BOX(gtk_combo_box_text_new());  GtkListStore *list_store = gtk_list_store_new(COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_INT);  GtkTreeIter iter;  gtk_list_store_append(list_store, &iter);  gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("only me"),                     COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_SELF, -1);  gtk_list_store_append(list_store, &iter);  gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends"),                     COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_ALL_FRIENDS, -1);  gtk_list_store_append(list_store, &iter);  gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("public"),                     COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_EVERYONE, -1);  gtk_list_store_append(list_store, &iter);  gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends of friends"),                     COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_FRIENDS_OF_FRIENDS, -1);  gtk_combo_box_set_model(ui->comboBox_privacy, GTK_TREE_MODEL(list_store));  gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox_privacy), 1); // Set default permission to private  ui->button_login = GTK_BUTTON(gtk_button_new_with_label(_("login")));  ui->connected = FALSE;  // pack the ui  ////the auth box  GtkWidget *hbox_auth = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);  GtkWidget *vbox_auth_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);  GtkWidget *vbox_auth_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);  gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_labels, FALSE, FALSE, 0);  gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_fields, TRUE, TRUE, 0);  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox_auth), TRUE, FALSE, 2);  gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->comboBox_username), TRUE, FALSE, 2);  gtk_box_pack_start(GTK_BOX(vbox_auth_labels), GTK_WIDGET(gtk_label_new("")), TRUE, TRUE, 2);  gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->button_login), TRUE, FALSE, 2);  gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(albumlist), TRUE, FALSE, 2);  ////the album creation box  ui->hbox_album = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));  gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox_album), TRUE); // hide it by default  GtkWidget *vbox_album_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);  GtkWidget *vbox_album_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox_album), TRUE, FALSE, 5);  gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_labels, FALSE, FALSE, 0);  gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_fields, TRUE, TRUE, 0);  gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_title), TRUE, TRUE, 0);//.........这里部分代码省略.........

void _fcitx_main_window_add_addon_page(FcitxMainWindow* self){    /* load addon */    FcitxAddon* addon;    utarray_new(self->addons, &addonicd);    FcitxAddonsLoad(self->addons);    GtkWidget* vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);    /* advance check box */    self->advancecheckbox = gtk_check_button_new_with_label(_("Advance"));    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->advancecheckbox), FALSE);    g_signal_connect(G_OBJECT(self->advancecheckbox), "toggled", G_CALLBACK(_fcitx_main_window_checkbox_changed), self);    /* filter entry */    self->filterentry = gtk_entry_new();    gtk_entry_set_icon_from_gicon (GTK_ENTRY (self->filterentry),                                    GTK_ENTRY_ICON_SECONDARY,                                    g_themed_icon_new_with_default_fallbacks("edit-clear"));    g_object_set(G_OBJECT(self->filterentry), "margin", 5, NULL);#if GTK_CHECK_VERSION(3,2,0)    gtk_entry_set_placeholder_text(GTK_ENTRY (self->filterentry), _("Search Addon"));#endif    g_signal_connect(G_OBJECT(self->filterentry), "icon-press", G_CALLBACK (icon_press_cb), NULL);    /* list view */    self->addonstore = gtk_list_store_new(N_COLUMNS, G_TYPE_POINTER);    for (addon = (FcitxAddon *) utarray_front(self->addons);         addon != NULL;         addon = (FcitxAddon *) utarray_next(self->addons, addon)) {        GtkTreeIter iter;        gtk_list_store_append(self->addonstore, &iter);        gtk_list_store_set(self->addonstore, &iter, LIST_ADDON, addon, -1);    }    self->filtermodel = gtk_tree_model_filter_new(GTK_TREE_MODEL(self->addonstore), NULL);    gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(self->filtermodel),                                           (GtkTreeModelFilterVisibleFunc) _filter_addon_func,                                           self,                                           NULL);    self->addonview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(self->filtermodel));    /* add column check box */    self->togglecell = gtk_cell_renderer_toggle_new();    self->checkboxcolumn = gtk_tree_view_column_new_with_attributes("Enable", self->togglecell, NULL);    gtk_tree_view_column_set_visible(self->checkboxcolumn, FALSE);    gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), self->checkboxcolumn);    gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(self->checkboxcolumn),                                       self->togglecell,                                       _fcitx_main_window_enabled_data_func,                                       NULL,                                       NULL);    /* add column text */    GtkCellRenderer* renderer = gtk_cell_renderer_text_new();    GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Name", renderer, NULL);    gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), column);    gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(column),                                       renderer,                                       _fcitx_main_window_name_data_func,                                       NULL,                                       NULL);    /* add addon list to vbox */    GtkWidget* swin = gtk_scrolled_window_new(NULL, NULL);    g_object_set(swin, "hscrollbar-policy", GTK_POLICY_NEVER, NULL);    g_object_set(self->addonview, "headers-visible", FALSE, NULL);    gtk_container_add(GTK_CONTAINER(swin), self->addonview);    gtk_box_pack_start(GTK_BOX(vbox), swin, TRUE, TRUE, 0);    g_object_set(G_OBJECT(swin), "margin-left", 5, "margin-right", 5, "shadow-type", GTK_SHADOW_IN, NULL);    g_signal_connect(G_OBJECT(self->togglecell), "toggled",                     G_CALLBACK(_fcitx_main_window_toggled_cb), GTK_TREE_MODEL(self->addonstore));    gtk_box_pack_start(GTK_BOX(vbox), self->advancecheckbox, FALSE, TRUE, 0);    g_object_set(G_OBJECT(self->advancecheckbox), "margin-left", 5, "margin-right", 5, NULL);    gtk_box_pack_start(GTK_BOX(vbox), self->filterentry, FALSE, TRUE, 5);    /* configure button */    GtkWidget* hbuttonbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);    gtk_box_pack_start(GTK_BOX(vbox), hbuttonbox, FALSE, TRUE, 0);    g_object_set(G_OBJECT(hbuttonbox), "margin", 5, NULL);    self->button = gtk_button_new_with_label(_("Configure"));    gtk_widget_set_sensitive(self->button, FALSE);    gtk_button_set_image(GTK_BUTTON(self->button), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("preferences-system"), GTK_ICON_SIZE_BUTTON));    gtk_box_pack_start(GTK_BOX(hbuttonbox), self->button, TRUE, TRUE, 0);    g_signal_connect(G_OBJECT(self->button), "clicked", G_CALLBACK(_fcitx_main_window_configure_button_clicked), self);    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->addonview));    gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);    g_signal_connect(G_OBJECT(selection), "changed",                     G_CALLBACK(_fcitx_main_window_addon_selection_changed), self);    g_signal_connect(G_OBJECT(self->filterentry), "changed", G_CALLBACK(_fcitx_main_window_filtertext_changed), self);    gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(self->filtermodel));    g_signal_connect(G_OBJECT(self->addonview),                     "row-activated",                     G_CALLBACK(_fcitx_main_window_addon_row_activated), self);//.........这里部分代码省略.........

voidprepare_controls_for_state (MafwPlayState state){        gboolean play_possible;        gboolean pause_possible;        gboolean stop_possible;        switch (state) {        case Stopped:		/* Disable the seekbar when the state is stopped */		gtk_widget_set_sensitive(position_hscale, FALSE);                play_possible = TRUE;                pause_possible = FALSE;                stop_possible = TRUE;		in_state_stopped = TRUE;                remove_timeout ();		g_signal_handlers_block_by_func (G_OBJECT(position_hscale),						on_position_hscale_value_changed, NULL);		gtk_range_set_value (GTK_RANGE (position_hscale), 0.0);		gtk_label_set_text(GTK_LABEL(position_label), "00:00");		g_signal_handlers_unblock_by_func(G_OBJECT(position_hscale),						  on_position_hscale_value_changed, NULL);                break;        case Paused:                play_possible = TRUE;                pause_possible = FALSE;                stop_possible = TRUE;		in_state_stopped = FALSE;                remove_timeout ();                update_position (NULL);                break;        case Playing:                play_possible = FALSE;                pause_possible = TRUE;                stop_possible = TRUE;		in_state_stopped = FALSE;                /* Start tracking media position in playing state */                add_timeout ();                break;        case Transitioning:                play_possible = FALSE;                pause_possible = FALSE;                stop_possible = TRUE;		in_state_stopped = FALSE;                remove_timeout ();                break;       default:                play_possible = TRUE;                pause_possible = FALSE;                stop_possible = TRUE;		in_state_stopped = FALSE;                remove_timeout ();                break;        }        if (!stop_possible) {                g_signal_handlers_block_by_func                                        (position_hscale,                                         on_position_hscale_value_changed,                                         NULL);                gtk_range_set_value (GTK_RANGE (position_hscale), 0.0);		gtk_label_set_text(GTK_LABEL(position_label), "00:00");                g_signal_handlers_unblock_by_func                                        (position_hscale,                                         on_position_hscale_value_changed,                                         NULL);        }        if (play_possible == TRUE) {                GtkWidget *image;                image = gtk_image_new_from_icon_name("camera_playback",                                                     HILDON_ICON_SIZE_SMALL);                gtk_button_set_image(GTK_BUTTON(play_button), image);        }        if (pause_possible == TRUE) {                GtkWidget *image;                image = gtk_image_new_from_icon_name("camera_video_pause",                                                     HILDON_ICON_SIZE_SMALL);                gtk_button_set_image(GTK_BUTTON(play_button), image);        }	if (play_possible == FALSE && pause_possible == FALSE) {		gtk_widget_set_sensitive (play_button, FALSE);//.........这里部分代码省略.........

voidsetup_renderer_controls (GtkBuilder *builder){	GtkWidget* image;        volume_vscale = GTK_WIDGET(gtk_builder_get_object(builder,                                                          "volume-vscale"));        g_assert (volume_vscale != NULL);        position_hscale = GTK_WIDGET(gtk_builder_get_object(builder,                                                            "position-hscale"));        g_assert (position_hscale != NULL);	position_label = GTK_WIDGET(gtk_builder_get_object(builder,                                                           "position-label"));        g_assert (position_label != NULL);	/* Previous */        prev_button = GTK_WIDGET(gtk_builder_get_object(builder,                                                        "previous-button"));        g_assert (prev_button != NULL);	/* Seek backwards */        seek_backwards_button =                GTK_WIDGET(gtk_builder_get_object(builder,                                                  "seek-backwards-button"));        g_assert (seek_backwards_button != NULL);	/* Play */        play_button = GTK_WIDGET(gtk_builder_get_object(builder,                                                        "play-button"));        g_assert (play_button != NULL);        gtk_button_set_label(GTK_BUTTON(play_button), NULL);        image = gtk_image_new_from_icon_name("camera_playback",                                             HILDON_ICON_SIZE_SMALL);        gtk_button_set_image(GTK_BUTTON(play_button), image);	/* Stop */        stop_button = GTK_WIDGET(gtk_builder_get_object(builder,                                                        "stop-button"));        g_assert (stop_button != NULL);	/* Seek forwards */        seek_forwards_button =                GTK_WIDGET(gtk_builder_get_object(builder,                                                  "seek-forwards-button"));        g_assert (seek_forwards_button != NULL);	/* Next */        next_button = GTK_WIDGET(gtk_builder_get_object(builder,                                                        "next-button"));        g_assert (next_button != NULL);	/* Mute */	mute_toggle = GTK_WIDGET(gtk_builder_get_object(builder,                                                        "mute-button"));        g_assert (mute_toggle != NULL);#ifndef MAFW_TEST_GUI_ENABLE_MUTE	gtk_widget_set_sensitive(mute_toggle, FALSE);#endif        timeout_id = 0;	/* Seeking is disabled by default */	enable_seek_buttons(FALSE);        g_object_weak_ref (G_OBJECT (position_hscale),                           (GWeakNotify) remove_timeout,                           NULL);}

GdkWindow *wxCheckBox::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const{    return GTK_BUTTON(m_widgetCheckbox)->event_window;}

static GtkWidget *nimf_settings_page_key_build_string_array (NimfSettingsPageKey *page_key){  GtkListStore      *store;  GtkWidget         *treeview;  GtkCellRenderer   *renderer;  GtkTreeViewColumn *column;  GtkWidget         *scrolled_w;  GtkWidget         *hbox;  GtkWidget         *vbox;  GtkWidget         *button1;  GtkWidget         *button2;  gchar            **strv;  gchar             *detailed_signal;  GtkTreeIter        iter;  gint               j;  button1 = gtk_button_new_from_icon_name ("list-add",    GTK_ICON_SIZE_SMALL_TOOLBAR);  button2 = gtk_button_new_from_icon_name ("list-remove", GTK_ICON_SIZE_SMALL_TOOLBAR);  gtk_button_set_relief (GTK_BUTTON (button1), GTK_RELIEF_NONE);  gtk_button_set_relief (GTK_BUTTON (button2), GTK_RELIEF_NONE);  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);#if GTK_CHECK_VERSION (3, 12, 0)  gtk_widget_set_margin_end   (page_key->label, 15);#else  gtk_widget_set_margin_right (page_key->label, 15);#endif  gtk_box_pack_start (GTK_BOX (hbox), page_key->label,   FALSE, FALSE, 0);  gtk_box_pack_end   (GTK_BOX (hbox), button2, FALSE, FALSE, 0);  gtk_box_pack_end   (GTK_BOX (hbox), button1, FALSE, FALSE, 0);  store = gtk_list_store_new (1, G_TYPE_STRING);  strv = g_settings_get_strv (page_key->gsettings, page_key->key);  for (j = 0; strv[j] != NULL; j++)  {    gtk_list_store_append (store, &iter);    gtk_list_store_set    (store, &iter, 0, strv[j], -1);  }  treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));  g_object_unref (store);  renderer = gtk_cell_renderer_text_new ();  column = gtk_tree_view_column_new_with_attributes ("Hotkeys", renderer,                                                     "text", 0, NULL);  gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);  scrolled_w = gtk_scrolled_window_new (NULL, NULL);  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_w),                                       GTK_SHADOW_ETCHED_IN);  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_w),                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);  gtk_container_add (GTK_CONTAINER (scrolled_w), treeview);  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);  gtk_box_pack_start (GTK_BOX (vbox), hbox,       FALSE, FALSE, 0);  gtk_box_pack_end   (GTK_BOX (vbox), scrolled_w, FALSE, FALSE, 0);  page_key->treeview = treeview;  detailed_signal = g_strdup_printf ("changed::%s", page_key->key);  g_signal_connect (treeview, "realize",                    G_CALLBACK (on_tree_view_realize), scrolled_w);  g_signal_connect (button1, "clicked", G_CALLBACK (on_button_clicked_add), page_key);  g_signal_connect (button2, "clicked", G_CALLBACK (on_button_clicked_remove), page_key);  g_signal_connect (page_key->gsettings, detailed_signal,                    G_CALLBACK (on_gsettings_changed), page_key->treeview);  g_strfreev (strv);  g_free (detailed_signal);  return vbox;}

//.........这里部分代码省略.........  ThunarVfsMimeInfo        *info;  ThunarIconFactory        *icon_factory;  GtkIconTheme             *icon_theme;  const gchar              *icon_name;  GdkPixbuf                *icon;  GtkWidget                *image;  GtkWidget                *item;  GtkWidget                *menu;  GList                    *applications;  GList                    *lp;  gint                      icon_size;  _thunar_return_if_fail (THUNAR_IS_CHOOSER_BUTTON (chooser_button));  _thunar_return_if_fail (chooser_button->button == button);  _thunar_return_if_fail (GTK_IS_BUTTON (button));  /* verify that we have a valid file */  if (G_UNLIKELY (chooser_button->file == NULL))    return;  /* determine the mime info for the file */  info = thunar_file_get_mime_info (chooser_button->file);  /* determine the default application */  default_application = thunar_vfs_mime_database_get_default_application (chooser_button->database, info);  if (G_UNLIKELY (default_application == NULL))    {      /* no default application, just popup the application chooser */      thunar_chooser_button_activate_other (chooser_button);      return;    }  /* determine all applications that claim to be able to handle the file */  applications = thunar_vfs_mime_database_get_applications (chooser_button->database, info);  /* make sure the default application comes first */  lp = g_list_find (applications, default_application);  if (G_LIKELY (lp != NULL))    {      applications = g_list_delete_link (applications, lp);      g_object_unref (G_OBJECT (default_application));    }  applications = g_list_prepend (applications, default_application);  /* allocate a new popup menu */  menu = gtk_menu_new ();  /* determine the icon size for menus */  gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &icon_size, &icon_size);  /* determine the icon factory for our screen */  icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (button));  icon_factory = thunar_icon_factory_get_for_icon_theme (icon_theme);  /* add the other possible applications */  for (lp = applications; lp != NULL; lp = lp->next)    {      item = gtk_image_menu_item_new_with_label (thunar_vfs_mime_handler_get_name (lp->data));      g_object_set_data_full (G_OBJECT (item), I_("thunar-vfs-mime-application"), lp->data, g_object_unref);      g_signal_connect_swapped (G_OBJECT (item), "activate", G_CALLBACK (thunar_chooser_button_activate), chooser_button);      gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);      gtk_widget_show (item);      /* setup the icon for the application */      icon_name = thunar_vfs_mime_handler_lookup_icon_name (lp->data, icon_theme);      icon = thunar_icon_factory_load_icon (icon_factory, icon_name, icon_size, NULL, FALSE);      image = gtk_image_new_from_pixbuf (icon);      gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);      gtk_widget_show (image);      if (G_LIKELY (icon != NULL))        g_object_unref (icon);    }  /* cleanup */  g_object_unref (G_OBJECT (icon_factory));  /* append a separator */  item = gtk_separator_menu_item_new ();  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);  gtk_widget_show (item);  /* release the applications list */  g_list_free (applications);  /* add the "Other Application..." choice */  item = gtk_image_menu_item_new_with_mnemonic (_("_Other Application..."));  g_signal_connect_swapped (G_OBJECT (item), "activate", G_CALLBACK (thunar_chooser_button_activate_other), chooser_button);  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);  gtk_widget_show (item);  /* make sure the menu has atleast the same width as the chooser */  if (menu->allocation.width < button->allocation.width)    gtk_widget_set_size_request (menu, button->allocation.width, -1);  /* run the menu on the button's screen (takes over the floating reference of menu) */  thunar_gtk_menu_run (GTK_MENU (menu), button, menu_position, button, 0, gtk_get_current_event_time ());  /* yeppa, that's a requirement */  gtk_button_released (GTK_BUTTON (button));}

int main (int argc, char *argv[]){    GDeviceSetup gds = { NULL, NULL, NULL, NULL, 0};    GtkWidget *window;    GtkWidget *scrollwin;    GtkWidget *bt_new;    GtkWidget *icon;    GtkWidget *message;    int response;    int loop = TRUE;    gds.dpy = dpy_init();    if (!gds.dpy)    {        fprintf(stderr, "Cannot connect to X server, or X server does not "                        "support XI 2.");        return 1;    }    gtk_init(&argc, &argv);    gds.display = gdk_display_get_default();    /* init dialog window */    window = gtk_dialog_new();    gtk_window_set_default_size (GTK_WINDOW(window), 10, 500);    gds.window = window;    gtk_container_set_border_width(GTK_CONTAINER(window), 10);    gtk_dialog_add_buttons(GTK_DIALOG(window),                           GTK_STOCK_HELP, GTK_RESPONSE_HELP,                           GTK_STOCK_UNDO, GTK_RESPONSE_CANCEL,                           GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,                           NULL);    toggle_undo_button(&gds, FALSE);    /* main dialog area */    gds.treeview = get_tree_view(&gds);    scrollwin = gtk_scrolled_window_new(NULL, NULL);    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),				   GTK_POLICY_NEVER,				   GTK_POLICY_AUTOMATIC);    gtk_container_add(GTK_CONTAINER(scrollwin), GTK_WIDGET(gds.treeview));    bt_new = gtk_button_new_with_mnemonic("_Create Cursor/Keyboard Focus");    icon   = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON);    gtk_button_set_image(GTK_BUTTON(bt_new), icon);    gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(window))),                       GTK_WIDGET(scrollwin), TRUE, TRUE, 0);    gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(window))), bt_new, 0, 0, 10);    g_signal_connect(G_OBJECT(bt_new), "clicked",                     G_CALLBACK(signal_new_md), &gds);    g_signal_connect (gdk_display_get_device_manager (gds.display), "device-added",		      G_CALLBACK (on_device_change), &gds);    g_signal_connect (gdk_display_get_device_manager (gds.display), "device-removed",		      G_CALLBACK (on_device_change), &gds);    g_signal_connect (gdk_display_get_device_manager (gds.display), "device-changed",		      G_CALLBACK (on_device_change), &gds);    gtk_widget_show_all(window);    do {        response = gtk_dialog_run(GTK_DIALOG(window));        switch(response)        {            case GTK_RESPONSE_HELP:                break;            case GTK_RESPONSE_CANCEL:	      g_printerr("undo !/n");	      /*query_devices(&gds);                g_list_free(gds.changes);                gds.changes = NULL;                */	        toggle_undo_button(&gds, FALSE);                break;            case GTK_RESPONSE_CLOSE:                if (gds.changes)                {                    message = gtk_message_dialog_new(GTK_WINDOW(window),                                                     GTK_DIALOG_MODAL,                                                     GTK_MESSAGE_QUESTION,                                                     GTK_BUTTONS_YES_NO,                                                     "You have unapplied "                                                     "changes. Are you sure "                                                     "you want to quit?");                    response = gtk_dialog_run(GTK_DIALOG(message));                    gtk_widget_destroy(message);                    loop = (response == GTK_RESPONSE_NO);                } else                    loop = FALSE;                break;            case GTK_RESPONSE_DELETE_EVENT:                loop = FALSE;                break;        }    } while (loop);//.........这里部分代码省略.........

//.........这里部分代码省略.........	renderer=gtk_cell_renderer_text_new();	gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(priv->addDomainPolicyCombo), renderer, TRUE);	gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(priv->addDomainPolicyCombo), renderer, "text", 1);	priv->addDomainButton=gtk_button_new_from_stock(GTK_STOCK_ADD);	gtk_widget_set_sensitive(priv->addDomainButton, FALSE);	gtk_container_add(GTK_CONTAINER(hbox), priv->addDomainButton);	g_signal_connect_swapped(priv->addDomainButton, "clicked", G_CALLBACK(_nojs_preferences_on_add_domain_clicked), self);	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5);	/* Set up domain list view */	priv->list=gtk_tree_view_new_with_model(GTK_TREE_MODEL(priv->listStore));#if !GTK_CHECK_VERSION (3, 0, 0)	gtk_widget_set_size_request(priv->list, -1, 300);#endif	priv->listSelection=gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->list));	gtk_tree_selection_set_mode(priv->listSelection, GTK_SELECTION_MULTIPLE);	g_signal_connect_swapped(priv->listSelection, "changed", G_CALLBACK(_nojs_preferences_changed_selection), self);	renderer=gtk_cell_renderer_text_new();	column=gtk_tree_view_column_new_with_attributes(_("Domain"),													renderer,													"text", DOMAIN_COLUMN,													NULL);	gtk_tree_view_column_set_sort_column_id(column, DOMAIN_COLUMN);	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->list), column);	renderer=gtk_cell_renderer_combo_new();	g_object_set(G_OBJECT(renderer), "model", list, "text-column", 1, "has-entry", false, "editable", true, NULL);	g_signal_connect_swapped(renderer, "editing-started", G_CALLBACK(_nojs_preferences_on_policy_editing_started), self);	g_signal_connect_swapped(renderer, "editing-canceled", G_CALLBACK(_nojs_preferences_on_policy_editing_canceled), self);	g_signal_connect_swapped(renderer, "edited", G_CALLBACK(_nojs_preferences_on_policy_edited), self);	column=gtk_tree_view_column_new_with_attributes(_("Policy"),													renderer,													"text", POLICY_COLUMN,													NULL);	gtk_tree_view_column_set_sort_column_id(column, POLICY_COLUMN);	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->list), column);	scrolled=gtk_scrolled_window_new(NULL, NULL);#if GTK_CHECK_VERSION (3, 0, 0)	gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), height*10);#endif	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);	gtk_container_add(GTK_CONTAINER(scrolled), priv->list);	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);	gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 5);	/* Set up JavaScript domain list management buttons */#if GTK_CHECK_VERSION (3, 0, 0)	hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);	gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE);#else	hbox=gtk_hbox_new(FALSE, 0);#endif	priv->deleteButton=gtk_button_new_from_stock(GTK_STOCK_DELETE);	gtk_widget_set_sensitive(priv->deleteButton, FALSE);	gtk_container_add(GTK_CONTAINER(hbox), priv->deleteButton);	g_signal_connect_swapped(priv->deleteButton, "clicked", G_CALLBACK(_nojs_preferences_on_delete_selection), self);	priv->deleteAllButton=gtk_button_new_with_mnemonic(_("Delete _all"));	gtk_button_set_image(GTK_BUTTON(priv->deleteAllButton), gtk_image_new_from_stock(GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON));	gtk_widget_set_sensitive(priv->deleteAllButton, FALSE);	gtk_container_add(GTK_CONTAINER(hbox), priv->deleteAllButton);	g_signal_connect_swapped(priv->deleteAllButton, "clicked", G_CALLBACK(_nojs_preferences_on_delete_all), self);	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5);	/* Add "allow-all-sites" checkbox */	priv->allowAllSitesCheckbox=gtk_check_button_new_with_mnemonic(_("A_llow scripts at all sites"));	priv->signalAllowAllSitesToggledID=g_signal_connect_swapped(priv->allowAllSitesCheckbox,																"toggled",																G_CALLBACK(_nojs_preferences_on_allow_all_sites_changed),																self);	gtk_box_pack_start(GTK_BOX(vbox), priv->allowAllSitesCheckbox, FALSE, TRUE, 5);	/* Add "block-unknown-domains" checkbox */	priv->blockUnknownDomainsCheckbox=gtk_check_button_new_with_mnemonic(_("Bloc_k scripts at unknown domains by default"));	priv->signalBlockUnknownDomainsToggledID=g_signal_connect_swapped(priv->blockUnknownDomainsCheckbox,																		"toggled",																		G_CALLBACK(_nojs_preferences_on_block_unknown_domains_changed),																		self);	gtk_box_pack_start(GTK_BOX(vbox), priv->blockUnknownDomainsCheckbox, FALSE, TRUE, 5);	/* Add "check-second-level-only" checkbox */	priv->checkSecondLevelOnlyCheckbox=gtk_check_button_new_with_mnemonic(_("S_et permissions on second-level domain"));	priv->signalCheckSecondLevelOnlyToggledID=g_signal_connect_swapped(priv->checkSecondLevelOnlyCheckbox,																		"toggled",																		G_CALLBACK(_nojs_preferences_on_check_second_level_only_changed),																		self);	gtk_box_pack_start(GTK_BOX(vbox), priv->checkSecondLevelOnlyCheckbox, FALSE, TRUE, 5);	/* Finalize setup of content area */	gtk_box_pack_start(GTK_BOX(priv->contentArea), vbox, TRUE, TRUE, 0);}

//.........这里部分代码省略.........	gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER);	gtk_label_set_selectable(GTK_LABEL(label_info), TRUE);	gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE);	g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE"));	gtk_label_set_markup(GTK_LABEL(label_info), buffer);	gtk_misc_set_padding(GTK_MISC(label_info), 2, 11);	gtk_widget_show(label_info);	gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0);	/* Codename label */	codename_label = gtk_label_new(NULL);	gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER);	gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE);	gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE);	gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME);	gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8);	gtk_widget_show(codename_label);	gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0);	/* build date label */	builddate_label = gtk_label_new(NULL);	gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER);	gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE);	gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE);	g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), __DATE__);	g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2);	gtk_label_set_markup(GTK_LABEL(builddate_label), buffer);	gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2);	gtk_widget_show(builddate_label);	gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0);	box = gtk_hbutton_box_new();	url_button = gtk_button_new();	gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE);	g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE);	label = gtk_label_new(NULL);	gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE);	gtk_widget_show(label);	gtk_container_add(GTK_CONTAINER(url_button), label);	gtk_widget_show(url_button);	gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0);	gtk_widget_show(box);	gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10);	/* copyright label */	cop_label = gtk_label_new(NULL);	gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER);	gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE);	gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE);	gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT);	gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10);	gtk_widget_show(cop_label);	gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0);	/*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */	label = gtk_label_new(_("Info"));	gtk_widget_show(label);	gtk_widget_show_all(info_box);	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label);	/* create "Credits" tab */	credits_scrollwin = gtk_scrolled_window_new(NULL, NULL);	gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 10);	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin),		GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

//.........这里部分代码省略.........    /* window */    if(prefs->embedded == 0)    {        download->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);        snprintf(buf, sizeof(buf), "%s %s", _("Download"),                 download->url);#if GTK_CHECK_VERSION(2, 6, 0)        gtk_window_set_icon_name(GTK_WINDOW(download->window),                                 "stock_download");#endif        gtk_window_set_resizable(GTK_WINDOW(download->window), FALSE);        gtk_window_set_title(GTK_WINDOW(download->window), buf);        g_signal_connect_swapped(download->window, "delete-event",                                 G_CALLBACK(_download_on_closex), download);    }    else    {        download->window = gtk_plug_new(0);        g_signal_connect_swapped(download->window, "embedded",                                 G_CALLBACK(_download_on_embedded), download);    }#if GTK_CHECK_VERSION(3, 0, 0)    vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);#else    vbox = gtk_vbox_new(FALSE, 2);#endif    bold = pango_font_description_new();    pango_font_description_set_weight(bold, PANGO_WEIGHT_BOLD);    left = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);    /* address */#if GTK_CHECK_VERSION(3, 0, 0)    hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);#else    hbox = gtk_hbox_new(FALSE, 4);#endif    widget = gtk_label_new(_("Address: "));#if GTK_CHECK_VERSION(3, 0, 0)    gtk_widget_override_font(widget, bold);    g_object_set(widget, "halign", GTK_ALIGN_START, NULL);#else    gtk_widget_modify_font(widget, bold);    gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);#endif    gtk_size_group_add_widget(left, widget);    gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);    download->address = gtk_entry_new();    gtk_entry_set_text(GTK_ENTRY(download->address), download->url);    gtk_editable_set_editable(GTK_EDITABLE(download->address), FALSE);    gtk_box_pack_start(GTK_BOX(hbox), download->address, TRUE, TRUE, 0);    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);    /* labels */    _download_label(vbox, bold, left, _("File: "), &download->filename,                    download->prefs.output);    _download_label(vbox, bold, left, _("Status: "), &download->status,                    _("Resolving..."));    _download_label(vbox, bold, left, _("Received: "), &download->received,                    _("0.0 kB"));    _download_label(vbox, bold, left, _("Remaining: "),                    &download->remaining, _("Unknown"));    /* progress bar */    download->progress = gtk_progress_bar_new();    gtk_box_pack_start(GTK_BOX(vbox), download->progress, FALSE, FALSE, 0);    /* checkbox */    download->check = gtk_check_button_new_with_label(                          _("Close window when the download is complete"));    gtk_box_pack_start(GTK_BOX(vbox), download->check, FALSE, FALSE, 0);    /* button */#if GTK_CHECK_VERSION(3, 0, 0)    hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);#else    hbox = gtk_hbox_new(FALSE, 4);#endif    download->cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);    g_signal_connect_swapped(download->cancel, "clicked", G_CALLBACK(                                 _download_on_cancel), download);    gtk_box_pack_end(GTK_BOX(hbox), download->cancel, FALSE, TRUE, 0);    download->browse = gtk_button_new_with_mnemonic("_Open folder");    gtk_widget_set_no_show_all(download->browse, TRUE);    widget = gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);    gtk_button_set_image(GTK_BUTTON(download->browse), widget);    g_signal_connect_swapped(download->browse, "clicked", G_CALLBACK(                                 _download_on_browse), download);    gtk_box_pack_end(GTK_BOX(hbox), download->browse, FALSE, TRUE, 0);    gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);    gtk_container_set_border_width(GTK_CONTAINER(download->window), 4);    gtk_container_add(GTK_CONTAINER(download->window), vbox);    download->timeout = g_idle_add(_download_on_idle, download);    _download_refresh(download);    gtk_widget_show_all(vbox);    if(prefs->embedded == 0)        gtk_widget_show(download->window);    else    {        id = gtk_plug_get_id(GTK_PLUG(download->window));        printf("%lu/n", id);        fclose(stdout);    }    _download_cnt++;    return download;}

GtkWidget *plugin_configure(GtkDialog *dialog){	GtkWidget *vbox, *label, *notebook_vbox, *checkbox_enable;	GtkWidget *notebook, *inner_vbox;	vbox = gtk_vbox_new(FALSE, 6);	notebook = gtk_notebook_new();	GTK_WIDGET_UNSET_FLAGS(notebook, GTK_CAN_FOCUS);	gtk_container_set_border_width(GTK_CONTAINER(notebook), 5);	gtk_box_pack_start(GTK_BOX(vbox), notebook, FALSE, TRUE, 0);	/*	 * Auto Save	 */	{		GtkWidget *spin, *hbox, *checkbox, *radio1, *radio2;		notebook_vbox = gtk_vbox_new(FALSE, 2);		inner_vbox = gtk_vbox_new(FALSE, 5);		gtk_container_set_border_width(GTK_CONTAINER(inner_vbox), 5);		gtk_box_pack_start(GTK_BOX(notebook_vbox), inner_vbox, TRUE, TRUE, 5);		gtk_notebook_insert_page(GTK_NOTEBOOK(notebook),			notebook_vbox, gtk_label_new(_("Auto Save")), NOTEBOOK_PAGE_AUTOSAVE);		checkbox_enable = gtk_check_button_new_with_mnemonic(_("_Enable"));		gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_enable), FALSE);		pref_widgets.checkbox_enable_autosave = checkbox_enable;		gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox_enable, FALSE, FALSE, 6);		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_enable), enable_autosave);		g_signal_connect(checkbox_enable, "toggled",			G_CALLBACK(checkbox_toggled_cb), GINT_TO_POINTER(NOTEBOOK_PAGE_AUTOSAVE));		label = gtk_label_new_with_mnemonic(_("Auto save _interval:"));		gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);		gtk_container_add(GTK_CONTAINER(inner_vbox), label);		pref_widgets.autosave_interval_spin = spin = gtk_spin_button_new_with_range(1, 1800, 1);		gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), autosave_interval);		gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin);		label = gtk_label_new(_("seconds"));		hbox = gtk_hbox_new(FALSE, 5);		gtk_box_pack_start(GTK_BOX(hbox), spin, TRUE, TRUE, 0);		gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);		gtk_box_pack_start(GTK_BOX(inner_vbox), hbox, FALSE, FALSE, 5);		checkbox = gtk_check_button_new_with_mnemonic(			_("_Print status message if files have been automatically saved"));		gtk_button_set_focus_on_click(GTK_BUTTON(checkbox), FALSE);		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), autosave_print_msg);		gtk_label_set_mnemonic_widget(GTK_LABEL(label), checkbox);		gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox, FALSE, FALSE, 5);		pref_widgets.autosave_print_msg_checkbox = checkbox;		radio1 = gtk_radio_button_new_with_mnemonic(NULL,			_("Save only current open _file"));		pref_widgets.autosave_save_all_radio1 = radio1;		gtk_label_set_mnemonic_widget(GTK_LABEL(label), radio1);		gtk_button_set_focus_on_click(GTK_BUTTON(radio1), FALSE);		gtk_container_add(GTK_CONTAINER(inner_vbox), radio1);		radio2 = gtk_radio_button_new_with_mnemonic_from_widget(			GTK_RADIO_BUTTON(radio1), _("Sa_ve all open files"));		pref_widgets.autosave_save_all_radio2 = radio2;		gtk_label_set_mnemonic_widget(GTK_LABEL(label), radio2);		gtk_button_set_focus_on_click(GTK_BUTTON(radio2), FALSE);		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio2), autosave_save_all);		gtk_container_add(GTK_CONTAINER(inner_vbox), radio2);	}	/*	 * Instant Save	 */	{		GtkWidget *combo;		guint i;		const GSList *node;		notebook_vbox = gtk_vbox_new(FALSE, 2);		inner_vbox = gtk_vbox_new(FALSE, 5);		gtk_container_set_border_width(GTK_CONTAINER(inner_vbox), 5);		gtk_box_pack_start(GTK_BOX(notebook_vbox), inner_vbox, TRUE, TRUE, 5);		gtk_notebook_insert_page(GTK_NOTEBOOK(notebook),			notebook_vbox, gtk_label_new(_("Instant Save")), NOTEBOOK_PAGE_INSTANTSAVE);		checkbox_enable = gtk_check_button_new_with_mnemonic(_("_Enable"));		pref_widgets.checkbox_enable_instantsave = checkbox_enable;		gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_enable), FALSE);		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_enable), enable_instantsave);		gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox_enable, FALSE, FALSE, 6);		g_signal_connect(checkbox_enable, "toggled",			G_CALLBACK(checkbox_toggled_cb), GINT_TO_POINTER(NOTEBOOK_PAGE_INSTANTSAVE));		label = gtk_label_new_with_mnemonic(_("_Filetype to use for newly opened files:"));		gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);		gtk_box_pack_start(GTK_BOX(inner_vbox), label, FALSE, FALSE, 0);		pref_widgets.instantsave_ft_combo = combo = gtk_combo_box_new_text();//.........这里部分代码省略.........

void gui_create_search_sidebar(void){	GtkWidget *vbox1;	GtkWidget *vbox90;	GtkWidget *vbox5;	GtkWidget *frame2;	GtkWidget *vbox2;	GtkWidget *frame3;	GtkWidget *vbox3;	GtkWidget *frame4;	GtkWidget *vbox4;	GtkWidget *table1;	GtkWidget *label1;	GtkWidget *label2;	GtkWidget *scrolledwindow_search;	GtkWidget *viewport_search;	gchar *header;	//GtkListStore *store;	//ss = &sss;	scrolledwindow_search = gtk_scrolled_window_new(NULL, NULL);	gtk_widget_show(scrolledwindow_search);	gtk_container_add(GTK_CONTAINER(widgets.notebook_sidebar),			  scrolledwindow_search);	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow_search),					    settings.shadow_type);	gtk_container_set_border_width(GTK_CONTAINER(scrolledwindow_search), 2);	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow_search),				       GTK_POLICY_AUTOMATIC,				       GTK_POLICY_AUTOMATIC);	viewport_search = gtk_viewport_new(NULL, NULL);	gtk_widget_show(viewport_search);	gtk_container_add(GTK_CONTAINER(scrolledwindow_search),			  viewport_search);	UI_VBOX(vbox1, FALSE, 4);	gtk_widget_show(vbox1);	gtk_container_add(GTK_CONTAINER(viewport_search), vbox1);	UI_VBOX(vbox5, FALSE, 0);	gtk_widget_show(vbox5);	gtk_box_pack_start(GTK_BOX(vbox1), vbox5, FALSE, TRUE, 0);	/* text entry */	ss.entrySearch = gtk_entry_new();	gtk_widget_show(ss.entrySearch);	gtk_box_pack_start(GTK_BOX(vbox5), ss.entrySearch, TRUE, TRUE, 0);	gtk_widget_set_size_request(ss.entrySearch, 130, -1);	;/* find button */#ifdef HAVE_GTK_310	remember_search =	    gtk_button_new_from_icon_name("edit-find-symbolic",					  GTK_ICON_SIZE_BUTTON);#else	remember_search = gtk_button_new_from_stock(GTK_STOCK_FIND);#endif	gtk_widget_show(remember_search);	gtk_box_pack_start(GTK_BOX(vbox5), remember_search, TRUE, FALSE,			   0);	gtk_widget_set_tooltip_text(remember_search,				    _("This is an inclusive (/"AND/") search:/nFind matches showing all words."));	gtk_button_set_relief(GTK_BUTTON(remember_search),			      GTK_RELIEF_HALF);	/* progress bar */	ss.progressbar_search = gtk_progress_bar_new();	gtk_widget_show(ss.progressbar_search);	gtk_box_pack_start(GTK_BOX(vbox5), ss.progressbar_search, FALSE,			   TRUE, 0);	/* button to open advanced search */	ss.advanced_search =	    gtk_button_new_with_mnemonic(_("_Open Advanced Search"));	gtk_widget_show(ss.advanced_search);	gtk_box_pack_start(GTK_BOX(vbox5), ss.advanced_search, TRUE, FALSE,			   0);	gtk_widget_set_tooltip_text(ss.advanced_search,				    _("Open the separate Advanced Search dialog."));	gtk_button_set_relief(GTK_BUTTON(ss.advanced_search),			      GTK_RELIEF_HALF);	ss.frame_module = gtk_frame_new(NULL);	gtk_widget_show(ss.frame_module);	gtk_box_pack_start(GTK_BOX(vbox1), ss.frame_module, FALSE, FALSE,			   0);	gtk_container_set_border_width(GTK_CONTAINER(ss.frame_module), 2);	gtk_frame_set_shadow_type(GTK_FRAME(ss.frame_module),				  GTK_SHADOW_NONE);	label1 = gtk_label_new(NULL);	header =	    g_strdup_printf("<span weight=/"bold/">%s</span>",			    _("Search Module"));	gtk_label_set_markup(GTK_LABEL(label1), header);//.........这里部分代码省略.........

static void messageview_show_cb(GObject *obj, gpointer msgview,				MsgInfo *msginfo, gboolean all_headers){  MessageView *messageview;  HeaderView *headerview;  GtkWidget *hbox;  gchar *msg_path;  GtkWidget *copy_btn;  GdkPixbuf* pbuf;  GtkWidget* image;  GtkTooltips *tip;  GList* wl;  gint i;  gboolean bfound = FALSE;  gpointer gdata;  #if DEBUG  g_print("[DEBUG] test: %p: messageview_show (%p), all_headers: %d: %s/n",	  obj, msgview, all_headers,	  msginfo && msginfo->subject ? msginfo->subject : "");#endif    if (!msgview) {    g_print("[DEBUG] msgview is NULL/n");    return;  }  messageview = (MessageView*)msgview;  if (!messageview) {    g_print("[DEBUG] messageview is NULL/n");    return;  }  headerview = messageview->headerview;  if (!headerview) {    g_print("[DEBUG] headerview is NULL/n");    return;  }    hbox = headerview->hbox;  if (!hbox) {    g_print("[DEBUG] hbox is NULL/n");    return;  }  wl = gtk_container_get_children(GTK_CONTAINER(hbox));  i = g_list_length(wl)-1;  /* search recently added GtkImage */  while (i >= 0) {    gdata = g_list_nth_data(wl, i);    if (GTK_IS_BUTTON(gdata) && gdata != headerview->image) {      /* remove from hbox */      g_print("[DEBUG] GTK_IS_BUTTON %p/n", gdata);#if DEBUG      g_print("[DEBUG] remove button: %p/n", gicon);#endif      gtk_container_remove(GTK_CONTAINER(hbox), GTK_WIDGET(gdata));    }    i--;  }  msg_path = procmsg_get_message_file_path(msginfo);                      debug_print("[DEBUG] msg_path:%s/n", msg_path);  if (bfound != TRUE){    copy_btn = gtk_button_new_from_stock(GTK_STOCK_FILE);    gtk_box_pack_end(GTK_BOX(hbox), copy_btn, FALSE, FALSE, 0);    pbuf = gdk_pixbuf_new_from_xpm_data((const char**)page_save);    image = gtk_image_new_from_pixbuf(pbuf);        gtk_button_set_image(GTK_BUTTON(copy_btn), image);    gtk_button_set_label(GTK_BUTTON(copy_btn), "");    tip = gtk_tooltips_new();    gtk_tooltips_set_tip(tip, copy_btn, _("Copy this mail to clipboard."), NULL);    g_signal_connect(G_OBJECT(copy_btn), "clicked",		     G_CALLBACK(copy_btn_clicked), msginfo);        gtk_widget_show(image);    gtk_widget_show_all(copy_btn);    debug_print("[DEBUG] copy mail to clipboard icon: %p/n", copy_btn);  }}

static voidabi_table_init (AbiTable* table){	UT_UTF8String prText =  "%d x %d ";	char* text = g_strdup_printf(prText.utf8_str(), init_rows, init_cols);	register_stock_icon();		table->button_box = gtk_vbox_new(FALSE, 0);	table->window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_POPUP));	table->window_vbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));	table->area = GTK_DRAWING_AREA(gtk_drawing_area_new());	table->handlers = 0;	table->window_label = GTK_LABEL(gtk_label_new(text));	g_free(text);	table->szTable = NULL;	table->szCancel = NULL;	gtk_container_add(GTK_CONTAINER(table->window), GTK_WIDGET(table->window_vbox));	gtk_box_pack_end(GTK_BOX(table->window_vbox), GTK_WIDGET(table->window_label), FALSE, FALSE, 0);	gtk_box_pack_end(GTK_BOX(table->window_vbox), GTK_WIDGET(table->area), TRUE, TRUE, 0);	gtk_widget_show_all(GTK_WIDGET(table->window_vbox));	table->selected_rows = init_rows;	table->selected_cols = init_cols;	table->total_rows = my_max(init_rows + 1, 5);	table->total_cols = my_max(init_cols + 1, 6);	abi_table_resize(table);	table->icon = NULL;	if (gtk_stock_lookup ("abi-table-widget", &table->stock_item))	{		table->label = gtk_label_new_with_mnemonic(table->stock_item.label);		table->icon = gtk_image_new_from_stock ("abi-table-widget", GTK_ICON_SIZE_LARGE_TOOLBAR);		gtk_widget_show(table->icon);		gtk_widget_show(table->label);		//		// We actually never want this label in toolbar		//		gtk_box_pack_end(GTK_BOX(table->button_box), table->label, FALSE, FALSE, 0);		gtk_box_pack_end(GTK_BOX(table->button_box), table->icon, FALSE, FALSE, 0);		UT_DEBUGMSG(("abi-table icon loaded %p !/n",table->icon));	}	else	{		/* it should not happen... */		UT_DEBUGMSG(("abi-table icon did not load !/n"));		UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);		table->label = gtk_label_new_with_mnemonic("_Table");		//		gtk_box_pack_end(GTK_BOX(table->button_box), table->label, FALSE, FALSE, 0);	}	gtk_container_add(GTK_CONTAINER(table), GTK_WIDGET(table->button_box));	g_signal_connect(G_OBJECT(table), "pressed",			 G_CALLBACK(on_pressed), static_cast<gpointer>(table));	g_signal_connect(G_OBJECT(table->area), "expose_event",			 G_CALLBACK(on_drawing_area_event), static_cast<gpointer>(table));	g_signal_connect(G_OBJECT(table->area), "motion_notify_event",			 G_CALLBACK(on_motion_notify_event), static_cast<gpointer>(table));	g_signal_connect(G_OBJECT(table->area), "button_release_event",			 G_CALLBACK(on_button_release_event), static_cast<gpointer>(table));	g_signal_connect(G_OBJECT(table->area), "button_press_event",			 G_CALLBACK(on_button_release_event), static_cast<gpointer>(table));	g_signal_connect(G_OBJECT(table->area), "leave_notify_event",			 G_CALLBACK(on_leave_event), static_cast<gpointer>(table));	g_signal_connect(G_OBJECT(table->window), "key_press_event",			 G_CALLBACK(on_key_event), static_cast<gpointer>(table));	gtk_widget_set_events (GTK_WIDGET(table->area), GDK_EXPOSURE_MASK						   | GDK_LEAVE_NOTIFY_MASK						   | GDK_BUTTON_PRESS_MASK						   | GDK_BUTTON_RELEASE_MASK						   | GDK_POINTER_MOTION_MASK						   | GDK_KEY_PRESS_MASK						   | GDK_KEY_RELEASE_MASK);	gtk_button_set_relief (GTK_BUTTON (table), GTK_RELIEF_NORMAL);}

//.........这里部分代码省略.........  ACE_ASSERT (view_);  GtkTextIter iter;  gtk_text_buffer_get_end_iter (gtk_text_view_get_buffer (view_),                                &iter);  gtk_text_buffer_create_mark (gtk_text_view_get_buffer (view_),                               ACE_TEXT_ALWAYS_CHAR ("scroll"),                               &iter,                               TRUE);  // enable multi-selection in treeview  GtkTreeView* tree_view_p =    GTK_TREE_VIEW (gtk_builder_get_object (builder_p,                                           ACE_TEXT_ALWAYS_CHAR ("channel_tab_treeview")));  ACE_ASSERT (tree_view_p);  GtkTreeSelection* tree_selection_p =    gtk_tree_view_get_selection (tree_view_p);  ACE_ASSERT (tree_selection_p);  gtk_tree_selection_set_mode (tree_selection_p,                               GTK_SELECTION_MULTIPLE);  // add the invite_channel_members_menu to the "Invite" menu item  GtkMenu* menu_p =    GTK_MENU (gtk_builder_get_object (builder_p,                                      ACE_TEXT_ALWAYS_CHAR ("invite_channel_members_menu")));  ACE_ASSERT (menu_p);  GtkMenuItem* menu_item_p =    GTK_MENU_ITEM (gtk_builder_get_object (builder_p,                                           ACE_TEXT_ALWAYS_CHAR ("menuitem_invite")));  ACE_ASSERT (menu_item_p);  gtk_menu_item_set_submenu (menu_item_p, GTK_WIDGET (menu_p));  // connect signal(s)  GtkButton* button_p =    GTK_BUTTON (gtk_builder_get_object (builder_p,                                        ACE_TEXT_ALWAYS_CHAR ("channel_tab_label_button")));  ACE_ASSERT (button_p);  g_signal_connect (button_p,                    ACE_TEXT_ALWAYS_CHAR ("clicked"),                    G_CALLBACK (part_clicked_cb),                    &CBData_);  // toggle buttons  GtkToggleButton* toggle_button_p =    GTK_TOGGLE_BUTTON (gtk_builder_get_object (builder_p,                                               ACE_TEXT_ALWAYS_CHAR ("mode_key_toggle_button_p")));  ACE_ASSERT (toggle_button_p);  g_signal_connect (toggle_button_p,                    ACE_TEXT_ALWAYS_CHAR ("toggled"),                    G_CALLBACK (channel_mode_toggled_cb),                    &CBData_);  toggle_button_p =    GTK_TOGGLE_BUTTON (gtk_builder_get_object (builder_p,                                               ACE_TEXT_ALWAYS_CHAR ("mode_voice_toggle_button_p")));  ACE_ASSERT (toggle_button_p);  g_signal_connect (toggle_button_p,                    ACE_TEXT_ALWAYS_CHAR ("toggled"),                    G_CALLBACK (channel_mode_toggled_cb),                    &CBData_);  toggle_button_p =    GTK_TOGGLE_BUTTON (gtk_builder_get_object (builder_p,                                               ACE_TEXT_ALWAYS_CHAR ("mode_ban_toggle_button_p")));  ACE_ASSERT (toggle_button_p);  g_signal_connect (toggle_button_p,                    ACE_TEXT_ALWAYS_CHAR ("toggled"),                    G_CALLBACK (channel_mode_toggled_cb),                    &CBData_);  toggle_button_p =

static voidbrasero_project_type_chooser_build_recent (BraseroProjectTypeChooser *self,					   GtkRecentManager *recent){	GtkSizeGroup *image_group;	GtkSizeGroup *group;	GList *list = NULL;	gchar *filename;	GList *recents;	GList *iter;	recents = gtk_recent_manager_get_items (recent);	for (iter = recents; iter; iter = iter->next) {		GtkRecentInfo *info;		const gchar *mime;		info = iter->data;		mime = gtk_recent_info_get_mime_type (info);		if (!mime)			continue;		/* filter those we want */		if (strcmp (mime, "application/x-brasero")		&&  strcmp (mime, "application/x-cd-image")		&&  strcmp (mime, "application/x-cdrdao-toc")		&&  strcmp (mime, "application/x-toc")		&&  strcmp (mime, "application/x-cue")		&&  strcmp (mime, "audio/x-scpls")		&&  strcmp (mime, "audio/x-ms-asx")		&&  strcmp (mime, "audio/x-mp3-playlist")		&&  strcmp (mime, "audio/x-mpegurl"))			continue;		/* sort */		list = g_list_insert_sorted (list,					     info,					     brasero_project_type_chooser_sort_recent);		if (g_list_length (list) > 5)			list = g_list_delete_link (list, g_list_last (list));	}	group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);	image_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);	/* If a project was left unfinished last time then add another entry */	filename = g_build_filename (g_get_user_config_dir (),				     "brasero",				     BRASERO_SESSION_TMP_PROJECT_PATH,				     NULL);	if (g_file_test (filename, G_FILE_TEST_EXISTS)) {		gchar *uri;		GtkWidget *link;		GtkWidget *image;		uri = g_filename_to_uri (filename, NULL, NULL);		image = gtk_image_new_from_icon_name ("brasero", GTK_ICON_SIZE_BUTTON);		gtk_size_group_add_widget (image_group, image);		link = gtk_button_new_with_label (_("Last _Unsaved Project"));		g_object_set_data_full (G_OBJECT (link),					"BraseroButtonURI", uri,					g_free);		gtk_button_set_relief (GTK_BUTTON (link), GTK_RELIEF_NONE);		gtk_button_set_alignment (GTK_BUTTON (link), 0.0, 0.5);		gtk_button_set_focus_on_click (GTK_BUTTON (link), FALSE);		gtk_button_set_image (GTK_BUTTON (link), image);		gtk_button_set_use_underline (GTK_BUTTON (link), TRUE);		g_signal_connect (link,				  "clicked",				  G_CALLBACK (brasero_project_type_chooser_last_unsaved_clicked_cb),				  self);		gtk_widget_show (link);		gtk_widget_set_tooltip_text (link, _("Load the last project that was not burned and not saved"));		gtk_box_pack_start (GTK_BOX (self->priv->recent_box), link, FALSE, TRUE, 0);		gtk_size_group_add_widget (group, link);	}	g_free (filename);	for (iter = list; iter; iter = iter->next) {		GtkRecentInfo *info;		GList *child_iter;		const gchar *name;		GIcon *icon;		GtkWidget *image;		const gchar *uri;		GtkWidget *child;		GtkWidget *link;		GList *children;		gchar *tooltip;		info = iter->data;		tooltip = gtk_recent_info_get_uri_display (info);		icon = gtk_recent_info_get_gicon (info);		image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_BUTTON);//.........这里部分代码省略.........

void program_init(void){	GtkWidget *widget;	StashGroup *group = stash_group_new("program");	extern gboolean thread_select_on_running;	extern gboolean thread_select_on_stopped;	extern gboolean thread_select_on_exited;	extern gboolean thread_select_follow;	program_dialog = dialog_connect("program_dialog");	program_page_vbox = get_widget("program_page_vbox");	program_exec_entry = GTK_ENTRY(get_widget("program_executable_entry"));	gtk_entry_set_max_length(program_exec_entry, PATH_MAX);	stash_group_add_entry(group, &program_executable, "executable", "", program_exec_entry);	ui_setup_open_button_callback(get_widget("program_executable_button"), NULL,		GTK_FILE_CHOOSER_ACTION_OPEN, program_exec_entry);	stash_group_add_entry(group, &program_arguments, "arguments", "",		get_widget("program_arguments_entry"));	widget = get_widget("program_environment");	environment = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));	stash_group_add_string(group, &program_environment, "environment", "");	working_dir_entry = GTK_ENTRY(get_widget("program_working_dir_entry"));	gtk_entry_set_max_length(working_dir_entry, PATH_MAX);	stash_group_add_entry(group, &program_working_dir, "working_dir", "", working_dir_entry);	ui_setup_open_button_callback(get_widget("program_working_dir_button"), NULL,		GTK_FILE_CHOOSER_ACTION_OPEN, working_dir_entry);	load_script_entry = GTK_ENTRY(get_widget("program_load_script_entry"));	gtk_entry_set_max_length(load_script_entry, PATH_MAX);	stash_group_add_entry(group, &program_load_script, "load_script", "", load_script_entry);	ui_setup_open_button_callback(get_widget("program_load_script_button"), NULL,		GTK_FILE_CHOOSER_ACTION_OPEN, load_script_entry);	auto_run_exit = get_widget("program_auto_run_exit");	stash_group_add_toggle_button(group, &program_auto_run_exit, "auto_run_exit", TRUE,		auto_run_exit);	stash_group_add_toggle_button(group, &program_non_stop_mode, "non_stop_mode", FALSE,		get_widget("program_non_stop_mode"));	temp_breakpoint = get_widget("program_temp_breakpoint");	stash_group_add_toggle_button(group, &program_temp_breakpoint, "temp_breakpoint", FALSE,		temp_breakpoint);	widget = get_widget("program_temp_break_location");	gtk_entry_set_max_length(GTK_ENTRY(widget), PATH_MAX + 0xFF);	stash_group_add_entry(group, &program_temp_break_location, "temp_break_location", "",		widget);	program_group = group;	delete_all_items = GTK_TOGGLE_BUTTON(get_widget("program_delete_all_items"));	g_signal_connect(program_exec_entry, "changed",		G_CALLBACK(on_program_name_entry_changed), NULL);	g_signal_connect(load_script_entry, "changed",		G_CALLBACK(on_program_name_entry_changed), NULL);	g_signal_connect(temp_breakpoint, "toggled", G_CALLBACK(on_temp_breakpoint_toggled),		widget);	import_button = get_widget("program_import");	g_signal_connect(import_button, "clicked", G_CALLBACK(on_program_import_button_clicked),		NULL);	widget = get_widget("program_ok");	g_signal_connect(widget, "clicked", G_CALLBACK(on_program_ok_button_clicked), NULL);	gtk_widget_grab_default(widget);	group = stash_group_new("options");	stash_group_add_toggle_button(group, &option_open_panel_on_load, "open_panel_on_load",		TRUE, get_widget("option_open_panel_on_load"));	stash_group_add_toggle_button(group, &option_open_panel_on_start, "open_panel_on_start",		TRUE, get_widget("option_open_panel_on_start"));	stash_group_add_toggle_button(group, &option_update_all_views, "update_all_views", FALSE,		get_widget("option_update_all_views"));	stash_group_add_radio_buttons(group, &option_high_bit_mode, "high_bit_mode", HB_7BIT,		get_widget("option_high_bit_mode_7bit"), HB_7BIT,		get_widget("option_high_bit_mode_locale"), HB_LOCALE,		get_widget("option_high_bit_mode_utf8"), HB_UTF8, NULL);	stash_group_add_toggle_button(group, &option_member_names, "member_names", TRUE,		get_widget("option_member_names"));	stash_group_add_toggle_button(group, &option_argument_names, "argument_names", TRUE,		get_widget("option_argument_names"));	long_mr_format = GTK_BUTTON(get_widget("option_mr_long_mr_format"));	stash_group_add_boolean(group, &option_long_mr_format, "long_mr_format", TRUE);	LONG_MR_FORMAT[FALSE] = _("as _Name=value");	LONG_MR_FORMAT[TRUE] = _("as _Name = value");	g_signal_connect(long_mr_format, "clicked", G_CALLBACK(on_long_mr_format_clicked), NULL);	stash_group_add_toggle_button(group, &option_inspect_expand, "inspect_expand", TRUE,		get_widget("option_inspect_expand"));	stash_group_add_spin_button_integer(group, &option_inspect_count, "inspect_count", 100,		get_widget("option_inspect_count"));	stash_group_add_toggle_button(group, &option_library_messages, "library_messages", FALSE,		get_widget("option_library_messages"));	stash_group_add_toggle_button(group, &option_editor_tooltips, "editor_tooltips", TRUE,		get_widget("option_editor_tooltips"));//.........这里部分代码省略.........

static voidmcharmap_mini_font_selection_init (McharmapMiniFontSelection *fontsel){  GtkCellRenderer *renderer;  GtkStyle *style;  AtkObject *accessib;  gtk_widget_ensure_style (GTK_WIDGET (fontsel));  style = gtk_widget_get_style (GTK_WIDGET (fontsel));  fontsel->font_desc = pango_font_description_copy (style->font_desc);  fontsel->default_size = -1;  fontsel->size_adj = gtk_adjustment_new (MIN_FONT_SIZE,                                           MIN_FONT_SIZE, MAX_FONT_SIZE, 1, 8, 0);  accessib = gtk_widget_get_accessible (GTK_WIDGET (fontsel));  atk_object_set_name (accessib, _("Font"));  gtk_box_set_spacing (GTK_BOX (fontsel), 6);  fontsel->family = gtk_combo_box_new ();  renderer = gtk_cell_renderer_text_new ();  gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (fontsel->family), renderer, TRUE);  gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (fontsel->family), renderer,                                  "text", COL_FAMILIY,                                  NULL);  gtk_widget_show (fontsel->family);  accessib = gtk_widget_get_accessible (fontsel->family);  atk_object_set_name (accessib, _("Font Family"));  fontsel->bold = gtk_toggle_button_new_with_mnemonic (GTK_STOCK_BOLD);  gtk_button_set_use_stock (GTK_BUTTON (fontsel->bold), TRUE);  gtk_widget_show (fontsel->bold);  g_signal_connect (fontsel->bold, "toggled",                    G_CALLBACK (bold_toggled), fontsel);  fontsel->italic = gtk_toggle_button_new_with_mnemonic (GTK_STOCK_ITALIC);  gtk_button_set_use_stock (GTK_BUTTON (fontsel->italic), TRUE);  gtk_widget_show (fontsel->italic);  g_signal_connect (fontsel->italic, "toggled",                    G_CALLBACK (italic_toggled), fontsel);  fontsel->size = gtk_spin_button_new (GTK_ADJUSTMENT (fontsel->size_adj),                                       0, 0);  gtk_widget_show (fontsel->size);  accessib = gtk_widget_get_accessible (fontsel->size);  atk_object_set_name (accessib, _("Font Size"));  g_signal_connect (fontsel->size_adj, "value-changed",                    G_CALLBACK (font_size_changed), fontsel);  fill_font_families_combo (fontsel);  gtk_combo_box_set_active (GTK_COMBO_BOX (fontsel->family), -1);  g_signal_connect (fontsel->family, "changed",                    G_CALLBACK (family_combo_changed), fontsel);  gtk_box_pack_start (GTK_BOX (fontsel), fontsel->family, FALSE, FALSE, 0);  gtk_box_pack_start (GTK_BOX (fontsel), fontsel->bold, FALSE, FALSE, 0);  gtk_box_pack_start (GTK_BOX (fontsel), fontsel->italic, FALSE, FALSE, 0);  gtk_box_pack_start (GTK_BOX (fontsel), fontsel->size, FALSE, FALSE, 0);  gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (fontsel->family), FALSE);  gtk_button_set_focus_on_click (GTK_BUTTON (fontsel->bold), FALSE);  gtk_button_set_focus_on_click (GTK_BUTTON (fontsel->italic), FALSE);  gtk_container_set_border_width (GTK_CONTAINER (fontsel), 6);  gtk_widget_show_all (GTK_WIDGET (fontsel));}

static voidnautilus_zoom_control_init (NautilusZoomControl *zoom_control){	GtkWidget *image;	int i;		zoom_control->details = G_TYPE_INSTANCE_GET_PRIVATE (zoom_control, NAUTILUS_TYPE_ZOOM_CONTROL, NautilusZoomControlDetails);	zoom_control->details->zoom_level = NAUTILUS_ZOOM_LEVEL_STANDARD;	zoom_control->details->min_zoom_level = NAUTILUS_ZOOM_LEVEL_SMALLEST;	zoom_control->details->max_zoom_level = NAUTILUS_ZOOM_LEVEL_LARGEST;	zoom_control->details->has_min_zoom_level = TRUE;	zoom_control->details->has_max_zoom_level = TRUE;	for (i = NAUTILUS_ZOOM_LEVEL_LARGEST; i >= NAUTILUS_ZOOM_LEVEL_SMALLEST; i--) {		zoom_control->details->preferred_zoom_levels = g_list_prepend (		          zoom_control->details->preferred_zoom_levels,			  GINT_TO_POINTER (i));	}	image = gtk_image_new_from_stock (GTK_STOCK_ZOOM_OUT, GTK_ICON_SIZE_MENU);	zoom_control->details->zoom_out = gtk_button_new ();	gtk_button_set_focus_on_click (GTK_BUTTON (zoom_control->details->zoom_out), FALSE);	gtk_button_set_relief (GTK_BUTTON (zoom_control->details->zoom_out),			       GTK_RELIEF_NONE);	gtk_widget_set_tooltip_text (zoom_control->details->zoom_out,				     _("Decrease the view size"));	g_signal_connect (G_OBJECT (zoom_control->details->zoom_out),			  "clicked", G_CALLBACK (zoom_out_clicked),			  zoom_control);	gtk_container_add (GTK_CONTAINER (zoom_control->details->zoom_out), image);	gtk_box_pack_start (GTK_BOX (zoom_control),			    zoom_control->details->zoom_out, FALSE, FALSE, 0);	zoom_control->details->zoom_button = gtk_button_new ();	gtk_button_set_focus_on_click (GTK_BUTTON (zoom_control->details->zoom_button), FALSE);	gtk_button_set_relief (GTK_BUTTON (zoom_control->details->zoom_button),			       GTK_RELIEF_NONE);	gtk_widget_set_tooltip_text (zoom_control->details->zoom_button,				     _("Use the normal view size"));			       	gtk_widget_add_events (GTK_WIDGET (zoom_control->details->zoom_button),			       GDK_BUTTON_PRESS_MASK			       | GDK_BUTTON_RELEASE_MASK			       | GDK_POINTER_MOTION_MASK);		       			       	g_signal_connect (G_OBJECT (zoom_control->details->zoom_button),			  "button-press-event",			  G_CALLBACK (nautilus_zoom_control_button_press_event),			  zoom_control);			  		  		  	g_signal_connect (G_OBJECT (zoom_control->details->zoom_button),			  "clicked", G_CALLBACK (zoom_button_clicked),			  zoom_control);		g_signal_connect (G_OBJECT (zoom_control->details->zoom_button),			  "popup-menu", G_CALLBACK (zoom_popup_menu),			  zoom_control);	zoom_control->details->zoom_label = gtk_label_new ("100%");	g_signal_connect (zoom_control->details->zoom_label,			  "style_set",			  G_CALLBACK (label_style_set_callback),			  zoom_control);	set_label_size (zoom_control);		gtk_container_add (GTK_CONTAINER (zoom_control->details->zoom_button), zoom_control->details->zoom_label);	gtk_box_pack_start (GTK_BOX (zoom_control),			    zoom_control->details->zoom_button, TRUE, TRUE, 0);	image = gtk_image_new_from_stock (GTK_STOCK_ZOOM_IN, GTK_ICON_SIZE_MENU);	zoom_control->details->zoom_in = gtk_button_new ();	gtk_button_set_focus_on_click (GTK_BUTTON (zoom_control->details->zoom_in), FALSE);	gtk_button_set_relief (GTK_BUTTON (zoom_control->details->zoom_in),			       GTK_RELIEF_NONE);	gtk_widget_set_tooltip_text (zoom_control->details->zoom_in,				     _("Increase the view size"));	g_signal_connect (G_OBJECT (zoom_control->details->zoom_in),			  "clicked", G_CALLBACK (zoom_in_clicked),			  zoom_control);	gtk_container_add (GTK_CONTAINER (zoom_control->details->zoom_in), image);	gtk_box_pack_start (GTK_BOX (zoom_control),			    zoom_control->details->zoom_in, FALSE, FALSE, 0);	gtk_widget_show_all (zoom_control->details->zoom_out);	gtk_widget_show_all (zoom_control->details->zoom_button);	gtk_widget_show_all (zoom_control->details->zoom_in);}

static gboolean _togglebutton_draw(GtkWidget *widget, cairo_t *cr){  g_return_val_if_fail(widget != NULL, FALSE);  g_return_val_if_fail(DTGTK_IS_TOGGLEBUTTON(widget), FALSE);  GtkDarktableToggleButton *button = DTGTK_TOGGLEBUTTON(widget);  GtkStateFlags state = gtk_widget_get_state_flags(widget);  GdkRGBA bg_color, fg_color;  GtkStyleContext *context = gtk_widget_get_style_context(widget);  if(button->icon_flags & CPF_CUSTOM_BG)    bg_color = button->bg;  else    gtk_style_context_get_background_color(context, state, &bg_color);  if(button->icon_flags & CPF_CUSTOM_FG)    fg_color = button->fg;  else    gtk_style_context_get_color(context, state, &fg_color);  /* fetch flags */  int flags = DTGTK_TOGGLEBUTTON(widget)->icon_flags;  /* set inner border */  int border = DT_PIXEL_APPLY_DPI((flags & CPF_DO_NOT_USE_BORDER) ? 2 : 6);  /* update active state paint flag */  gboolean active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));  if(active)    flags |= CPF_ACTIVE;  else    flags &= ~(CPF_ACTIVE);  /* prelight */  if(state & GTK_STATE_FLAG_PRELIGHT)    flags |= CPF_PRELIGHT;  else    flags &= ~CPF_PRELIGHT;  /* begin cairo drawing */  GtkAllocation allocation;  gtk_widget_get_allocation(widget, &allocation);  int width = allocation.width;  int height = allocation.height;  /* draw standard button background if not transparent nor flat styled */  if((flags & CPF_STYLE_FLAT))  {    if(flags & CPF_PRELIGHT || flags & CPF_ACTIVE)    {      cairo_rectangle(cr, 0, 0, width, height);      gdk_cairo_set_source_rgba(cr, &bg_color);      cairo_fill(cr);    }  }  else if(!(flags & CPF_BG_TRANSPARENT))  {    /* draw default boxed button */    gtk_render_background(context, cr, 0, 0, width, height);    if(!(flags & CPF_DO_NOT_USE_BORDER))      gtk_render_frame(context, cr, 0, 0, width, height);  }  /* create pango text settings if label exists */  PangoLayout *layout = NULL;  int pw = 0, ph = 0;  const gchar *text = gtk_button_get_label(GTK_BUTTON(widget));  if(text)  {    layout = pango_cairo_create_layout(cr);    pango_layout_set_font_description(layout, darktable.bauhaus->pango_font_desc);    pango_cairo_context_set_resolution(pango_layout_get_context(layout), darktable.gui->dpi);    pango_layout_set_text(layout, text, -1);    pango_layout_get_pixel_size(layout, &pw, &ph);  }  gdk_cairo_set_source_rgba(cr, &fg_color);  /* draw icon */  if(DTGTK_TOGGLEBUTTON(widget)->icon)  {    //     if (flags & CPF_IGNORE_FG_STATE)    //       state = GTK_STATE_NORMAL;    int icon_width = text ? height - (border * 2) : width - (border * 2);    int icon_height = height - (border * 2);    if(icon_width > 0 && icon_height > 0)    {      if(text)        DTGTK_TOGGLEBUTTON(widget)            ->icon(cr, border, border, height - (border * 2), height - (border * 2), flags);      else        DTGTK_TOGGLEBUTTON(widget)            ->icon(cr, border, border, width - (border * 2), height - (border * 2), flags);    }  }//.........这里部分代码省略.........

static voidcaja_file_conflict_dialog_init (CajaFileConflictDialog *fcd){    GtkWidget *hbox, *vbox, *vbox2;    GtkWidget *widget, *dialog_area;    CajaFileConflictDialogPrivate *details;    GtkDialog *dialog;    details = fcd->details = caja_file_conflict_dialog_get_instance_private (fcd);    dialog = GTK_DIALOG (fcd);    /* Setup the main hbox */    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);    dialog_area = gtk_dialog_get_content_area (dialog);    gtk_box_pack_start (GTK_BOX (dialog_area), hbox, FALSE, FALSE, 0);    gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);    /* Setup the dialog image */    widget = gtk_image_new_from_icon_name ("dialog-warning",                                       GTK_ICON_SIZE_DIALOG);    gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);    gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);    gtk_widget_set_valign (widget, GTK_ALIGN_START);    /* Setup the vbox containing the dialog body */    vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);    gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);    /* Setup the vbox for the dialog labels */    widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);    gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);    details->titles_vbox = widget;    /* Setup the hboxes to pack file infos into */    vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);    gtk_widget_set_halign (vbox2, GTK_ALIGN_START);    gtk_widget_set_valign (vbox2, GTK_ALIGN_START);    gtk_widget_set_margin_start (vbox2, 12);    gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0);    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);    gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);    details->first_hbox = hbox;    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);    gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);    details->second_hbox = hbox;    /* Setup the expander for the rename action */    details->expander = gtk_expander_new_with_mnemonic (_("Select a new name for the _destination"));    gtk_box_pack_start (GTK_BOX (vbox2), details->expander, FALSE, FALSE, 0);    g_signal_connect (details->expander, "activate",                      G_CALLBACK (expander_activated_cb), dialog);    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);    gtk_container_add (GTK_CONTAINER (details->expander), hbox);    widget = gtk_entry_new ();    gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 6);    details->entry = widget;    g_signal_connect (widget, "changed",                      G_CALLBACK (entry_text_changed_cb), dialog);    widget = gtk_button_new_with_label (_("Reset"));    gtk_button_set_image (GTK_BUTTON (widget),                          gtk_image_new_from_icon_name ("edit-undo",                                  GTK_ICON_SIZE_MENU));    gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6);    g_signal_connect (widget, "clicked",                      G_CALLBACK (reset_button_clicked_cb), dialog);    gtk_widget_show_all (vbox2);    /* Setup the diff button for text files */    details->diff_button = gtk_button_new_with_label (_("Differences..."));    gtk_button_set_image (GTK_BUTTON (details->diff_button),                          gtk_image_new_from_icon_name ("edit-find",                                  GTK_ICON_SIZE_MENU));    gtk_box_pack_start (GTK_BOX (vbox), details->diff_button, FALSE, FALSE, 6);    g_signal_connect (details->diff_button, "clicked",                      G_CALLBACK (diff_button_clicked_cb), dialog);    gtk_widget_hide (details->diff_button);    /* Setup the checkbox to apply the action to all files */    widget = gtk_check_button_new_with_mnemonic (_("Apply this action to all files and folders"));    gtk_box_pack_start (GTK_BOX (vbox),                        widget, FALSE, FALSE, 0);    details->checkbox = widget;    g_signal_connect (widget, "toggled",                      G_CALLBACK (checkbox_toggled_cb), dialog);    /* Add buttons */    eel_dialog_add_button (dialog,                           _("_Cancel"),                           "process-stop",                           GTK_RESPONSE_CANCEL);    gtk_dialog_add_button (dialog,                           _("_Skip"),//.........这里部分代码省略.........

//.........这里部分代码省略.........	  		    GTK_EXPAND|GTK_FILL, GTK_EXPAND|GTK_FILL, 0, 0);	}#ifdef ENABLE_ENHANCED      if (pinentry->enhanced)	{	  GtkWidget *sbox = gtk_hbox_new (FALSE, HIG_SMALL);	  gtk_box_pack_start (GTK_BOX (box), sbox, FALSE, FALSE, 0);	  w = gtk_label_new ("Forget secret after");	  gtk_box_pack_start (GTK_BOX (sbox), w, FALSE, FALSE, 0);	  gtk_widget_show (w);	  time_out = gtk_spin_button_new	    (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, HUGE_VAL, 1, 60, 60)),	     2, 0);	  gtk_box_pack_start (GTK_BOX (sbox), time_out, FALSE, FALSE, 0);	  gtk_widget_show (time_out);	  w = gtk_label_new ("seconds");	  gtk_box_pack_start (GTK_BOX (sbox), w, FALSE, FALSE, 0);	  gtk_widget_show (w);	  gtk_widget_show (sbox);	  insure = gtk_check_button_new_with_label ("ask before giving out "						    "secret");	  gtk_box_pack_start (GTK_BOX (box), insure, FALSE, FALSE, 0);	  gtk_widget_show (insure);	}#endif    }  bbox = gtk_hbutton_box_new ();  gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);  gtk_box_set_spacing (GTK_BOX (bbox), 6);  gtk_box_pack_start (GTK_BOX (wvbox), bbox, TRUE, FALSE, 0);  if (!pinentry->one_button)    {      if (pinentry->cancel)        {          msg = pinentry_utf8_validate (pinentry->cancel);          w = gtk_button_new_with_mnemonic (msg);          g_free (msg);        }      else if (pinentry->default_cancel)        {          GtkWidget *image;          msg = pinentry_utf8_validate (pinentry->default_cancel);          w = gtk_button_new_with_mnemonic (msg);          g_free (msg);          image = gtk_image_new_from_stock (GTK_STOCK_CANCEL,                                            GTK_ICON_SIZE_BUTTON);          if (image)            gtk_button_set_image (GTK_BUTTON (w), image);        }      else          w = gtk_button_new_from_stock (GTK_STOCK_CANCEL);      gtk_container_add (GTK_CONTAINER (bbox), w);      g_signal_connect (G_OBJECT (w), "clicked",                        G_CALLBACK (confirm_mode ? confirm_button_clicked                                    : button_clicked),			(gpointer) CONFIRM_CANCEL);      GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);    }