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

bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase){    wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase);    GSList* radioGroup;    switch ( tool->GetStyle() )    {        case wxTOOL_STYLE_BUTTON:            switch (tool->GetKind())            {                case wxITEM_CHECK:                    tool->m_item = gtk_toggle_tool_button_new();                    g_signal_connect(tool->m_item, "toggled",                        G_CALLBACK(item_toggled), tool);                    break;                case wxITEM_RADIO:                    radioGroup = GetRadioGroup(pos);                    if (radioGroup)                    {                        // this is the first button in the radio button group,                        // it will be toggled automatically by GTK so bring the                        // internal flag in sync                        tool->Toggle(true);                    }                    tool->m_item = gtk_radio_tool_button_new(radioGroup);                    g_signal_connect(tool->m_item, "toggled",                        G_CALLBACK(item_toggled), tool);                    break;                default:                    wxFAIL_MSG("unknown toolbar child type");                    // fall through                case wxITEM_DROPDOWN:                case wxITEM_NORMAL:                    tool->m_item = gtk_tool_button_new(NULL, "");                    g_signal_connect(tool->m_item, "clicked",                        G_CALLBACK(item_clicked), tool);                    break;            }            if (!HasFlag(wxTB_NOICONS))            {                GtkWidget* image = gtk_image_new();                gtk_tool_button_set_icon_widget(                    GTK_TOOL_BUTTON(tool->m_item), image);                tool->SetImage();                gtk_widget_show(image);                g_signal_connect(image, "expose_event",                    G_CALLBACK(image_expose_event), tool);            }            if (!tool->GetLabel().empty())            {                gtk_tool_button_set_label(                    GTK_TOOL_BUTTON(tool->m_item), wxGTK_CONV(tool->GetLabel()));                // needed for labels in horizontal toolbar with wxTB_HORZ_LAYOUT                gtk_tool_item_set_is_important(tool->m_item, true);            }            if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty())            {                gtk_tool_item_set_tooltip(tool->m_item,                    m_tooltips, wxGTK_CONV(tool->GetShortHelp()), "");            }            g_signal_connect(GTK_BIN(tool->m_item)->child, "button_press_event",                G_CALLBACK(button_press_event), tool);            g_signal_connect(tool->m_item, "enter_notify_event",                G_CALLBACK(enter_notify_event), tool);            g_signal_connect(tool->m_item, "leave_notify_event",                G_CALLBACK(enter_notify_event), tool);            if (tool->GetKind() == wxITEM_DROPDOWN)                tool->CreateDropDown();            gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));            break;        case wxTOOL_STYLE_SEPARATOR:            tool->m_item = gtk_separator_tool_item_new();            if ( tool->IsStretchable() )            {                gtk_separator_tool_item_set_draw                (                    GTK_SEPARATOR_TOOL_ITEM(tool->m_item),                    FALSE                );                gtk_tool_item_set_expand(tool->m_item, TRUE);            }            gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));            break;        case wxTOOL_STYLE_CONTROL:            wxWindow* control = tool->GetControl();            if (control->m_widget->parent == NULL)                AddChildGTK(control);            tool->m_item = GTK_TOOL_ITEM(control->m_widget->parent->parent);            if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos))            {                g_object_ref(tool->m_item);                gtk_container_remove(                    GTK_CONTAINER(m_toolbar), GTK_WIDGET(tool->m_item));                gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));                g_object_unref(tool->m_item);            }            // Inserted items "slide" into place using an animated effect that//.........这里部分代码省略.........

//.........这里部分代码省略.........	SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, frame_transport);	SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_max_size);	SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_timeout);	SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_save_spam);	SET_TOGGLE_SENSITIVITY(save_spam_checkbtn, save_spam_folder_entry);	SET_TOGGLE_SENSITIVITY(save_spam_checkbtn, save_spam_folder_select);	SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_process_emails);	SET_TOGGLE_SENSITIVITY(save_spam_checkbtn, mark_as_read_checkbtn);	SET_TOGGLE_SENSITIVITY(whitelist_ab_checkbtn, whitelist_ab_folder_combo);#ifndef USE_ALT_ADDRBOOK	SET_TOGGLE_SENSITIVITY(whitelist_ab_checkbtn, whitelist_ab_select_btn);#endif	config = spamassassin_get_config();	g_signal_connect(G_OBJECT(save_spam_folder_select), "clicked",			G_CALLBACK(foldersel_cb), page);#ifndef USE_ALT_ADDRBOOK	g_signal_connect(G_OBJECT (whitelist_ab_select_btn), "clicked",			 G_CALLBACK(spamassassin_whitelist_ab_select_cb), page);#else	gtk_widget_set_sensitive(GTK_WIDGET(whitelist_ab_select_btn), FALSE);#endif	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enable_sa_checkbtn), config->enable);	if (config->username != NULL)		gtk_entry_set_text(GTK_ENTRY(user_entry), config->username);	if (config->hostname != NULL)		gtk_entry_set_text(GTK_ENTRY(spamd_hostname_entry), config->hostname);	if (config->socket != NULL)		gtk_entry_set_text(GTK_ENTRY(spamd_socket_entry), config->socket);	if (config->whitelist_ab_folder != NULL) {		/* translate "Any" (stored UNtranslated) */		if (strcasecmp(config->whitelist_ab_folder, "Any") == 0)			gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((whitelist_ab_folder_combo)))),					config->whitelist_ab_folder);		else		/* backward compatibility (when translated "Any" was stored) */		if (g_utf8_collate(config->whitelist_ab_folder, _("Any")) == 0)			gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((whitelist_ab_folder_combo)))),					config->whitelist_ab_folder);		else			gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((whitelist_ab_folder_combo)))),					config->whitelist_ab_folder);	}	gtk_spin_button_set_value(GTK_SPIN_BUTTON(spamd_port_spinbtn), (float) config->port);	gtk_spin_button_set_value(GTK_SPIN_BUTTON(max_size_spinbtn), (float) config->max_size);	gtk_spin_button_set_value(GTK_SPIN_BUTTON(timeout_spinbtn), (float) config->timeout);	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(process_emails_checkbtn), config->process_emails);	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(save_spam_checkbtn), config->receive_spam);	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(whitelist_ab_checkbtn), config->whitelist_ab);	if (config->save_folder != NULL)		gtk_entry_set_text(GTK_ENTRY(save_spam_folder_entry), config->save_folder);	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mark_as_read_checkbtn), config->mark_as_read);	page->enable_sa_checkbtn = enable_sa_checkbtn;	page->transport_label = transport_label;	page->transport_optmenu = transport_optmenu;	page->username = user_entry;	page->hostname = spamd_hostname_entry;	page->colon = spamd_colon_label;	page->port = spamd_port_spinbtn;	page->socket = spamd_socket_entry;	page->max_size = max_size_spinbtn;	page->timeout = timeout_spinbtn;	page->process_emails = process_emails_checkbtn;	page->receive_spam = save_spam_checkbtn;

static void _camera_import_dialog_new(_camera_import_dialog_t *data){  data->dialog = gtk_dialog_new_with_buttons(_("import images from camera"), NULL, GTK_DIALOG_MODAL,                                             _("cancel"), GTK_RESPONSE_NONE, C_("camera import", "import"),                                             GTK_RESPONSE_ACCEPT, NULL);  gtk_window_set_default_size(GTK_WINDOW(data->dialog), 100, 600);  gtk_window_set_transient_for(GTK_WINDOW(data->dialog), GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)));  GtkWidget *content = gtk_dialog_get_content_area(GTK_DIALOG(data->dialog));  // List - setup store  data->store = gtk_list_store_new(2, GDK_TYPE_PIXBUF, G_TYPE_STRING);  // IMPORT PAGE  data->import.page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);  gtk_container_set_border_width(GTK_CONTAINER(data->import.page), 5);  // Top info  data->import.info = gtk_label_new(_("please wait while prefetching thumbnails of images from camera..."));  gtk_label_set_single_line_mode(GTK_LABEL(data->import.info), FALSE);  gtk_widget_set_halign(data->import.info, GTK_ALIGN_START);  gtk_box_pack_start(GTK_BOX(data->import.page), data->import.info, FALSE, FALSE, 0);  // jobcode  data->import.jobname      = _camera_import_gconf_widget(data, _("jobcode"), "plugins/capture/camera/import/jobcode");  gtk_box_pack_start(GTK_BOX(data->import.page), GTK_WIDGET(data->import.jobname->widget), FALSE, FALSE, 0);  // Create the treview with list model data store  data->import.treeview = gtk_scrolled_window_new(NULL, NULL);  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(data->import.treeview), GTK_POLICY_NEVER,                                 GTK_POLICY_ALWAYS);  gtk_container_add(GTK_CONTAINER(data->import.treeview), gtk_tree_view_new());  GtkTreeView *treeview = GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview)));  GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new();  GtkTreeViewColumn *column      = gtk_tree_view_column_new_with_attributes(_("thumbnail"), renderer, "pixbuf", 0, (char *)NULL);  gtk_tree_view_append_column(treeview, column);  renderer = gtk_cell_renderer_text_new();  column = gtk_tree_view_column_new_with_attributes(_("storage file"), renderer, "text", 1, (char *)NULL);  gtk_tree_view_append_column(treeview, column);  gtk_tree_view_column_set_expand(column, TRUE);  GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview);  gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);  gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(data->store));  gtk_tree_view_set_headers_visible(treeview, FALSE);  gtk_box_pack_start(GTK_BOX(data->import.page), data->import.treeview, TRUE, TRUE, 0);  // SETTINGS PAGE  data->settings.page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);  gtk_container_set_border_width(GTK_CONTAINER(data->settings.page), 5);  // general settings  gtk_box_pack_start(GTK_BOX(data->settings.page), gtk_label_new(_("general")), FALSE, FALSE, 0);  // ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories.  data->settings.general.ignore_jpeg = gtk_check_button_new_with_label(_("ignore JPEG files"));  gtk_widget_set_tooltip_text(data->settings.general.ignore_jpeg,               _("do not load files with an extension of .jpg or .jpeg. this can be useful when there are "                 "raw+JPEG in a directory."));  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->settings.general.ignore_jpeg),                               dt_conf_get_bool("ui_last/import_ignore_jpegs"));  gtk_box_pack_start(GTK_BOX(data->settings.page), data->settings.general.ignore_jpeg, FALSE, FALSE, 0);  g_signal_connect(G_OBJECT(data->settings.general.ignore_jpeg), "clicked",                   G_CALLBACK(_check_button_callback), data);  GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);  data->settings.general.date_override = gtk_check_button_new_with_label(_("override today's date"));  gtk_box_pack_start(GTK_BOX(hbox), data->settings.general.date_override, FALSE, FALSE, 0);  gtk_widget_set_tooltip_text(data->settings.general.date_override,               _("check this, if you want to override the timestamp used when expanding variables:/n$(YEAR), "                 "$(MONTH), $(DAY),/n$(HOUR), $(MINUTE), $(SECONDS)"));  data->settings.general.date_entry = gtk_entry_new();  gtk_widget_set_sensitive(data->settings.general.date_entry, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(                                                                  data->settings.general.date_override)));  gtk_box_pack_start(GTK_BOX(hbox), data->settings.general.date_entry, TRUE, TRUE, 0);  g_signal_connect(G_OBJECT(data->settings.general.date_override), "clicked",                   G_CALLBACK(_check_button_callback), data);  gtk_box_pack_start(GTK_BOX(data->settings.page), hbox, FALSE, FALSE, 0);  // THE NOTEBOOK  data->notebook = gtk_notebook_new();  gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook), data->import.page, gtk_label_new(_("images")));  gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook), data->settings.page, gtk_label_new(_("settings")));  // end  gtk_box_pack_start(GTK_BOX(content), data->notebook, TRUE, TRUE, 0);  // gtk_widget_set_size_request(content, DT_PIXEL_APPLY_DPI(400), DT_PIXEL_APPLY_DPI(400));//.........这里部分代码省略.........

static voidzoom_options_init (ZoomOptions *self){  ZoomOptionsPrivate *priv;  GtkWidget *w;  PangoAttrList *pango_attrs;  PangoAttribute *attr;  GError *err = NULL;  priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, ZOOM_TYPE_OPTIONS, ZoomOptionsPrivate);  priv->builder = gtk_builder_new ();  gtk_builder_set_translation_domain (priv->builder, GETTEXT_PACKAGE);  gtk_builder_add_from_file (priv->builder,                             SAGARMATHACC_UI_DIR "/zoom-options.ui",                             &err);  if (err)    {      g_warning ("Could not load interface file: %s", err->message);      g_error_free (err);      g_object_unref (priv->builder);      priv->builder = NULL;      return;    }  priv->settings = g_settings_new ("org.sagarmatha.desktop.a11y.magnifier");  priv->application_settings = g_settings_new ("org.sagarmatha.desktop.a11y.applications");  pango_attrs = pango_attr_list_new ();  attr = pango_attr_scale_new (FONT_SCALE);  pango_attr_list_insert (pango_attrs, attr);  /* Zoom switch */  g_settings_bind (priv->application_settings, "screen-magnifier-enabled",                   WID ("seeing_zoom_switch"), "active",                   G_SETTINGS_BIND_DEFAULT);  /* Magnification factor */  w = WID ("magFactorSpinButton");  g_settings_bind (priv->settings, "mag-factor",                   gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (w)),                   "value", G_SETTINGS_BIND_DEFAULT);  /* Screen position combo */  w = WID ("screen_position_combo_box");  screen_position_notify_cb (priv->settings, "screen-position", self);  g_signal_connect (G_OBJECT (priv->settings), "changed::screen-position",                    G_CALLBACK (screen_position_notify_cb), self);  g_signal_connect (G_OBJECT (w), "changed",                    G_CALLBACK (screen_position_combo_changed_cb), self);  /* Screen part section */  init_screen_part_section (priv, pango_attrs);  /* Cross hairs: show/hide ... */  w = WID ("xhairsEnabledSwitch");  g_settings_bind (priv->settings, "show-cross-hairs", w, "active",                   G_SETTINGS_BIND_DEFAULT);  /* ... Cross hairs: color and opacity */  w = WID ("xHairsPicker");  init_xhairs_color_opacity (GTK_COLOR_BUTTON (w), priv->settings);  g_signal_connect (G_OBJECT (priv->settings), "changed::cross-hairs-color",                    G_CALLBACK (xhairs_color_notify_cb), w);  g_signal_connect (G_OBJECT (priv->settings), "changed::cross-hairs-opacity",                    G_CALLBACK (xhairs_opacity_notify_cb), w);  g_signal_connect (G_OBJECT (w), "color-set",                    G_CALLBACK (xhairs_color_opacity_changed),                    priv);  /* ... Cross hairs: thickness ... */  w = WID ("xHairsThicknessSlider");  g_settings_bind (priv->settings, "cross-hairs-thickness",                   gtk_range_get_adjustment (GTK_RANGE (w)), "value",                   G_SETTINGS_BIND_DEFAULT);  /* ... Cross hairs: clip ... */  w = WID ("xHairsClipCheckbox");  scale_label (GTK_BIN(w), pango_attrs);  g_settings_bind (priv->settings, "cross-hairs-clip", w, "active",                   G_SETTINGS_BIND_INVERT_BOOLEAN);  /* ... Cross hairs: length ... */  w = WID ("xHairsLengthSlider");  xhairs_length_add_marks (GTK_SCALE (w));  g_settings_bind (priv->settings, "cross-hairs-length",                   gtk_range_get_adjustment (GTK_RANGE (w)), "value",                   G_SETTINGS_BIND_DEFAULT);  /* ... Color effects ... */  w = WID ("inverseEnabledSwitch");  g_settings_bind (priv->settings, "invert-lightness", w, "active",                   G_SETTINGS_BIND_DEFAULT);  w = WID ("brightnessSlider");  priv->brightness_slider = w;  init_effects_slider (GTK_RANGE(w), priv, brightness_keys,                       G_CALLBACK (brightness_slider_notify_cb));//.........这里部分代码省略.........

voiduim_cand_win_horizontal_gtk_set_index(UIMCandWinHorizontalGtk *horizontal_cwin, gint index){  gint new_page, prev_index;  UIMCandWinGtk *cwin;  g_return_if_fail(UIM_IS_CAND_WIN_HORIZONTAL_GTK(horizontal_cwin));  cwin = UIM_CAND_WIN_GTK(horizontal_cwin);  prev_index = cwin->candidate_index;  if (index >= (gint) cwin->nr_candidates)    cwin->candidate_index = 0;  else    cwin->candidate_index = index;  if (cwin->candidate_index >= 0 && cwin->display_limit)    new_page = cwin->candidate_index / cwin->display_limit;  else    new_page = cwin->page_index;  if (cwin->page_index != new_page)    uim_cand_win_gtk_set_page(cwin, new_page);  if (cwin->candidate_index >= 0) {    gint pos;    struct index_button *idxbutton, *prev_selected;    GtkWidget *label;    if (cwin->display_limit)      pos = cwin->candidate_index % cwin->display_limit;    else      pos = cwin->candidate_index;    idxbutton = g_ptr_array_index(horizontal_cwin->buttons, pos);    prev_selected = (gpointer)horizontal_cwin->selected;    if (prev_selected && prev_index != cwin->candidate_index) {      label = gtk_bin_get_child(GTK_BIN(prev_selected->button));      gtk_widget_queue_draw(label);    }    label = gtk_bin_get_child(GTK_BIN(idxbutton->button));    gtk_widget_queue_draw(label);    horizontal_cwin->selected = idxbutton;    /* show subwin */    if (cwin->stores->pdata[new_page]) {      char *annotation = NULL;      GtkTreeModel *model = GTK_TREE_MODEL(cwin->stores->pdata[new_page]);      GtkTreeIter iter;      gtk_tree_model_iter_nth_child(model, &iter, NULL, pos);      gtk_tree_model_get(model, &iter, COLUMN_ANNOTATION, &annotation, -1);      if (annotation && *annotation) {	if (!cwin->sub_window.window)          uim_cand_win_gtk_create_sub_window(cwin);	gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(cwin->sub_window.text_view)), annotation, -1);	uim_cand_win_gtk_layout_sub_window(cwin);	gtk_widget_show(cwin->sub_window.window);	cwin->sub_window.active = TRUE;      } else {        if (cwin->sub_window.window) {          gtk_widget_hide(cwin->sub_window.window);          cwin->sub_window.active = FALSE;	}      }      free(annotation);    }  } else {    horizontal_cwin->selected = NULL;    if (cwin->sub_window.window) {      gtk_widget_hide(cwin->sub_window.window);      cwin->sub_window.active = FALSE;    }  }  uim_cand_win_gtk_update_label(cwin);}

void wxButton::DoApplyWidgetStyle(GtkRcStyle *style){    gtk_widget_modify_style(m_widget, style);    gtk_widget_modify_style(GTK_BIN(m_widget)->child, style);}

GtkEditable *wxComboBox::GetEditable() const{    return GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(m_widget)));}

void set_string_combo(SettingItem * item, gchar * s){    gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(item->widget))),s);}

//.........这里部分代码省略.........	gtk_table_attach(GTK_TABLE(table), hbox1, 1, 2, 1, 2, 			 GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);#if !GTK_CHECK_VERSION(2, 24, 0)	account_combo = gtk_combo_box_new_text ();#else	account_combo = gtk_combo_box_text_new ();#endif	gtk_size_group_add_widget(size_action, account_combo);	for (accounts = account_get_list() ; accounts != NULL;	     accounts = accounts->next) {		PrefsAccount *ac = (PrefsAccount *)accounts->data;		gchar *name = g_strdup(ac->account_name);#if !GTK_CHECK_VERSION(2, 24, 0)		gtk_combo_box_append_text(GTK_COMBO_BOX(account_combo), (gpointer) name);#else		gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(account_combo), (gpointer) name);#endif		g_free(name);	}	prefs_filtering_action_check_widget_width(account_combo);	gtk_combo_box_set_active(GTK_COMBO_BOX(account_combo), 0);	gtk_box_pack_start (GTK_BOX (hbox1), account_combo,			    FALSE, FALSE, 0);	/* header */	header_combo = combobox_text_new(TRUE, "From", "To", "Cc", "Reply-To", "Sender", NULL);	gtk_size_group_add_widget(size_action, header_combo);	gtk_box_pack_start (GTK_BOX (hbox1), header_combo,			    FALSE, FALSE, 0);	header_entry = gtk_bin_get_child(GTK_BIN((header_combo)));	/* destination */	hbox1 = gtk_hbox_new (FALSE, 0);	gtk_table_attach(GTK_TABLE(table), hbox1, 1, 2, 2, 3, 			GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);	dest_entry = gtk_entry_new ();	gtk_box_pack_start (GTK_BOX (hbox1), dest_entry, TRUE, TRUE, 0);		score_entry = gtk_spin_button_new_with_range(-1000, 1000, 1);	gtk_box_pack_start(GTK_BOX(hbox1), score_entry, FALSE, FALSE, 0);	#if !GTK_CHECK_VERSION(3, 0, 0)	color_optmenu = gtk_cmoption_menu_new();	gtk_size_group_add_widget(size_action, color_optmenu);	gtk_cmoption_menu_set_menu(GTK_CMOPTION_MENU(color_optmenu),				 colorlabel_create_color_menu());	prefs_filtering_action_check_widget_width(color_optmenu);	gtk_box_pack_start(GTK_BOX(hbox1), color_optmenu, FALSE, FALSE, 0);#endif#if !GTK_CHECK_VERSION(2, 24, 0)	tags_combo = gtk_combo_box_new_text ();#else	tags_combo = gtk_combo_box_text_new ();#endif	gtk_size_group_add_widget(size_action, tags_combo);	for (tmp = tags = tags_get_list() ; tmp != NULL;	     tmp = tmp->next) {		gchar *name = g_strdup(tags_get_tag(GPOINTER_TO_INT(tmp->data)));

SettingItem * register_setting(GtkWidget * widget, SettingType type, gchar * section, gchar * key){    SettingItem * item;    item = malloc(sizeof(SettingItem));    item->type = type;    item->key = g_strdup(key);    item->section = g_strdup(section);    item->widget = widget;    item->fvalue = g_strdup("");    SettingList = g_slist_append(SettingList,item);    switch(item->type)    {        case ST_BOOL:        case ST_SFILE_BOOL:            g_signal_connect(widget,"toggled",                    G_CALLBACK(cb_apply_setting),                    item);            break;        case ST_INT:        case ST_SFILE_INT:            g_signal_connect(widget,"value-changed",                    G_CALLBACK(cb_apply_setting),                    item);            break;        case ST_FLOAT:            g_signal_connect(widget,"value-changed",                    G_CALLBACK(cb_apply_setting),                    item);            break;        case ST_COLOR:            g_signal_connect(widget,"color-set",                    G_CALLBACK(cb_apply_setting),                    item);            break;        case ST_FONT:            g_signal_connect(widget,"font-set",                    G_CALLBACK(cb_apply_setting),                    item);            break;        case ST_IMG_FILE:            g_signal_connect(widget,"selection-changed",                    G_CALLBACK(cb_apply_setting),                    item);            break;        case ST_STRING_COMBO:            g_signal_connect(gtk_bin_get_child(GTK_BIN(widget)),"changed",                    G_CALLBACK(cb_apply_setting),                    item);            break;        case ST_SFILE_INT_COMBO:            g_signal_connect(widget,"changed",                    G_CALLBACK(cb_apply_setting),                    item);            break;        case ST_ENGINE_COMBO:            g_signal_connect(widget,"changed",                    G_CALLBACK(cb_apply_setting),                    item);        default:            break;            //unconnected types    }    return item;}

//.........这里部分代码省略.........		if (DATA_GET(object,"fromecu_complex"))			continue;		if (DATA_GET(object,"special"))			continue;		internal_names = (gchar *) DATA_GET(object,"internal_names");		if (!find_in_list(rtv_map->raw_list,internal_names))			continue;		temp_dep = (GBOOLEAN)DATA_GET(object,"temp_dep");		size = (DataSize)(GINT)DATA_GET(object,"size");		multiplier = (gfloat *)DATA_GET(object,"fromecu_mult");		adder = (gfloat *)DATA_GET(object,"fromecu_add");		precision = (GINT) DATA_GET(object,"precision");		bitval = (GINT) DATA_GET(object,"offset");		if (DATA_GET(object,"real_lower"))		{			lower = (gchar *)DATA_GET(object,"real_lower");			real_lower = g_strtod(lower,NULL);			raw_lower = calc_value_f(real_lower,multiplier,adder,TOECU);		}		else			raw_lower = get_extreme_from_size_f(size,LOWER);		if (DATA_GET(object,"real_upper"))		{			upper = (gchar *)DATA_GET(object,"real_upper");			real_upper = g_strtod(upper,NULL);			raw_upper = calc_value_f(real_upper,multiplier,adder,TOECU);		}		else			raw_upper = get_extreme_from_size_f(size,UPPER);		range = g_strdup_printf("Valid Range: %.1f <-> %.1f",real_lower,real_upper);		if (temp_dep)		{			tempc_range = g_strdup_printf("Valid Range: %.1f/302/260C <-> %.1f/302/260C",f_to_c_f(real_lower),f_to_c_f(real_upper));			tempf_range = g_strdup_printf("Valid Range: %.1f/302/260F <-> %.1f/302/260F",real_lower,real_upper);			tempk_range = g_strdup_printf("Valid Range: %.1f/302/260K <-> %.1f/302/260K",f_to_k_f(real_lower),f_to_k_f(real_upper));		}		else		{			tempc_range = g_strdup(range);			tempf_range = g_strdup(range);			tempk_range = g_strdup(range);		}		raw_lower_str = g_strdup_printf("%i",raw_lower);		raw_upper_str = g_strdup_printf("%i",raw_upper);		gtk_list_store_append(store,&iter);		gtk_list_store_set(store,&iter,				UO_CHOICE_COL,name,				UO_BITVAL_COL,bitval,				UO_FROMECU_MULT_COL,multiplier,				UO_FROMECU_ADD_COL,adder,				UO_RAW_LOWER_COL,raw_lower_str,				UO_RAW_UPPER_COL,raw_upper_str,				UO_RANGE_COL,range,				UO_RANGE_TEMPC_COL,tempc_range,				UO_RANGE_TEMPF_COL,tempf_range,				UO_RANGE_TEMPK_COL,tempk_range,				UO_SIZE_COL,size,				UO_PRECISION_COL,precision,				UO_TEMP_DEP_COL,temp_dep,				-1);		g_free(raw_lower_str);		g_free(raw_upper_str);		g_free(range);		g_free(tempc_range);		g_free(tempf_range);		g_free(tempk_range);	}	if (GTK_IS_COMBO_BOX_ENTRY(widget))	{		gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(widget),UO_CHOICE_COL);		gtk_combo_box_set_model(GTK_COMBO_BOX(widget),GTK_TREE_MODEL(store));		g_object_unref(store);		entry = gtk_bin_get_child(GTK_BIN(widget));		/* Nasty hack, but otherwise the entry is an obnoxious size.. */		if ((width = (GINT)OBJ_GET((GtkWidget *)widget,"max_chars")) > 0)			gtk_entry_set_width_chars(GTK_ENTRY(entry),width);		else			gtk_entry_set_width_chars(GTK_ENTRY(entry),12);		gtk_widget_set_size_request(GTK_WIDGET(widget),-1,(3*(GINT)DATA_GET(global_data,"font_size")));		//		gtk_container_remove (GTK_CONTAINER (widget), gtk_bin_get_child(GTK_BIN(widget)));		//		gtk_container_add (GTK_CONTAINER (widget), entry);		completion = gtk_entry_completion_new();		gtk_entry_set_completion(GTK_ENTRY(entry),completion);		g_object_unref(completion);		gtk_entry_completion_set_model(completion,GTK_TREE_MODEL(store));		gtk_entry_completion_set_text_column(completion,UO_CHOICE_COL);		gtk_entry_completion_set_inline_completion(completion,TRUE);		gtk_entry_completion_set_inline_selection(completion,TRUE);		gtk_entry_completion_set_popup_single_match(completion,FALSE);		OBJ_SET(widget,"arrow-size",GINT_TO_POINTER(1));	}	EXIT();	return;}

//.........这里部分代码省略.........            mUserField = gtk_entry_new();            if (!mUser.IsEmpty())                gtk_entry_set_text(GTK_ENTRY(mUserField), mUser.get());            gtk_entry_set_activates_default(GTK_ENTRY(mUserField), TRUE);            gtk_box_pack_start(GTK_BOX(userPassFields), mUserField, FALSE,                               FALSE, 0);        }        if (widgetFlags & INCLUDE_PASSWORD) {            GtkWidget* passLabel = gtk_label_new("Password:");            gtk_box_pack_start(GTK_BOX(userPassLabels), passLabel, FALSE,                               FALSE, 0);            mPassField = gtk_entry_new();            if (!mPass.IsEmpty())                gtk_entry_set_text(GTK_ENTRY(mPassField), mPass.get());            gtk_entry_set_visibility(GTK_ENTRY(mPassField), FALSE);            gtk_entry_set_activates_default(GTK_ENTRY(mPassField), TRUE);            gtk_box_pack_start(GTK_BOX(userPassFields), mPassField, FALSE,                               FALSE, 0);        }        gtk_box_pack_start(GTK_BOX(userPassHBox), userPassLabels, FALSE,                           FALSE, 0);        gtk_box_pack_start(GTK_BOX(userPassHBox), userPassFields, FALSE,                           FALSE, 0);        gtk_box_pack_start(GTK_BOX(contentsVBox), userPassHBox, FALSE, FALSE, 0);    }    if (aType == TYPE_PROMPT) {        mTextField = gtk_entry_new();        if (!mTextValue.IsEmpty())            gtk_entry_set_text(GTK_ENTRY(mTextField), mTextValue.get());        gtk_entry_set_activates_default(GTK_ENTRY(mTextField), TRUE);        gtk_box_pack_start(GTK_BOX(contentsVBox), mTextField, FALSE, FALSE, 0);    }    // Add a checkbox    if ((widgetFlags & INCLUDE_CHECKBOX) && !mCheckMessage.IsEmpty()) {        mCheckBox = gtk_check_button_new_with_label(mCheckMessage.get());        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mCheckBox),                                     mCheckValue);        gtk_label_set_line_wrap(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mCheckBox))),				TRUE);        gtk_box_pack_start(GTK_BOX(contentsVBox), mCheckBox, FALSE, FALSE, 0);    }    // Add a dropdown menu    if (aType == TYPE_SELECT) {        // Build up a GtkMenu containing the items        GtkWidget* menu = gtk_menu_new();        for (PRUint32 i = 0; i < mItemCount; ++i) {            GtkWidget* item = gtk_menu_item_new_with_label(mItemList[i].get());            gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);        }        // Now create an OptionMenu and set this as the menu        mOptionMenu = gtk_option_menu_new();        gtk_option_menu_set_menu(GTK_OPTION_MENU(mOptionMenu), menu);        gtk_box_pack_start(GTK_BOX(contentsVBox), mOptionMenu, FALSE, FALSE, 0);    }    if (aType == TYPE_UNIVERSAL) {        // Create buttons based on the flags passed in.        for (int i = EMBED_MAX_BUTTONS; i >= 0; --i) {            if (!mButtonLabels[i].IsEmpty())                gtk_dialog_add_button(GTK_DIALOG(mWindow),                                      mButtonLabels[i].get(), i);        }        gtk_dialog_set_default_response(GTK_DIALOG(mWindow), 0);    } else {        // Create standard ok and cancel buttons        if (widgetFlags & INCLUDE_CANCEL)            gtk_dialog_add_button(GTK_DIALOG(mWindow), GTK_STOCK_CANCEL,                                  GTK_RESPONSE_CANCEL);        GtkWidget* okButton = gtk_dialog_add_button(GTK_DIALOG(mWindow),                                                    GTK_STOCK_OK,                                                    GTK_RESPONSE_ACCEPT);        gtk_widget_grab_default(okButton);    }    // Pack the contentsVBox into the dialogHBox and the dialog.    gtk_box_pack_start(GTK_BOX(dialogHBox), contentsVBox, FALSE, FALSE, 0);    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(mWindow)->vbox), dialogHBox, FALSE,                       FALSE, 0);    return NS_OK;}

static voidupdate_editor_sheet (EggToolbarEditor *editor){  GList *l;  GList *to_drag;  int x, y, height, width;  GtkWidget *table;  GtkWidget *viewport;  GtkWidget *item;  GtkWidget *icon;  g_return_if_fail (EGG_IS_TOOLBAR_EDITOR (editor));  viewport = GTK_BIN (editor->priv->scrolled_window)->child;  if (viewport)    {      table = GTK_BIN (viewport)->child;      gtk_container_remove (GTK_CONTAINER (viewport), table);    }  table = gtk_table_new (0, 0, TRUE);  editor->priv->table = table;  gtk_container_set_border_width (GTK_CONTAINER (table), 12);  gtk_widget_show (table);  gtk_scrolled_window_add_with_viewport    (GTK_SCROLLED_WINDOW (editor->priv->scrolled_window), table);  gtk_drag_dest_set (table, GTK_DEST_DEFAULT_ALL,		     dest_drag_types, n_dest_drag_types, GDK_ACTION_MOVE);  g_signal_connect (table, "drag_data_received",		    G_CALLBACK (editor_drag_data_received_cb), editor);  to_drag = editor->priv->actions_list;  x = y = 0;  width = 4;  height = (g_list_length (to_drag)) / width + 1;  gtk_table_resize (GTK_TABLE (editor->priv->table), height, width);  for (l = to_drag; l != NULL; l = l->next)    {      GtkAction *action = (l->data);      const char *stock_id, *short_label;      GValue value = { 0, };      g_value_init (&value, G_TYPE_STRING);      g_object_get_property (G_OBJECT (action), "stock_id", &value);      stock_id = g_value_get_string (&value);      icon = gtk_image_new_from_stock		(stock_id ? stock_id : GTK_STOCK_DND,		 GTK_ICON_SIZE_LARGE_TOOLBAR);      g_value_unset (&value);      g_value_init (&value, G_TYPE_STRING);      g_object_get_property (G_OBJECT (action), "short_label", &value);      short_label = g_value_get_string (&value);      item = editor_create_item (editor, GTK_IMAGE (icon),				 short_label, GDK_ACTION_MOVE);      g_value_unset (&value);      g_object_set_data (G_OBJECT (item), "egg-action", action);      gtk_table_attach_defaults (GTK_TABLE (editor->priv->table),		                 item, x, x + 1, y, y + 1);      x++;      if (x >= width)	{	  x = 0;	  y++;	}    }  icon = _egg_editable_toolbar_new_separator_image ();  item = editor_create_item (editor, GTK_IMAGE (icon), _("Separator"),			     GDK_ACTION_COPY);  gtk_table_attach_defaults (GTK_TABLE (editor->priv->table),		             item, x, x + 1, y, y + 1);}

RendererFuncs *renderer_clutter_new(PixbufRenderer *pr){	RendererClutter *rc = g_new0(RendererClutter, 1);	rc->pr = pr;	rc->f.area_changed = rc_area_changed;	rc->f.update_pixbuf = rc_update_pixbuf;	rc->f.free = rc_free;	rc->f.update_zoom = rc_update_zoom;	rc->f.invalidate_region = rc_invalidate_region;	rc->f.scroll = rc_scroll;	rc->f.update_viewport = rc_update_viewport;	rc->f.overlay_add = rc_overlay_add;	rc->f.overlay_set = rc_overlay_set;	rc->f.overlay_get = rc_overlay_get;	rc->f.stereo_set = rc_stereo_set;	rc->stereo_mode = 0;	rc->stereo_off_x = 0;	rc->stereo_off_y = 0;	rc->idle_update = 0;	rc->pending_updates = NULL;	rc->widget = gtk_bin_get_child(GTK_BIN(rc->pr));	if (rc->widget)		{		if (!GTK_CLUTTER_IS_EMBED(rc->widget))			{			g_free(rc);			DEBUG_3("pixbuf renderer has a child of other type than gtk_clutter_embed");			return NULL;			}		}	else		{		rc->widget = gtk_clutter_embed_new();		gtk_container_add(GTK_CONTAINER(rc->pr), rc->widget);		}	gtk_event_box_set_above_child (GTK_EVENT_BOX(rc->pr), TRUE);	rc->stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (rc->widget));	rc->group = clutter_group_new();	clutter_container_add_actor(CLUTTER_CONTAINER(rc->stage), rc->group);	clutter_actor_set_clip_to_allocation(CLUTTER_ACTOR(rc->group), TRUE);	rc->texture = clutter_texture_new ();	clutter_container_add_actor(CLUTTER_CONTAINER(rc->group), rc->texture);	renderer_clutter_init_checker_shader(rc);	g_object_ref(G_OBJECT(rc->widget));	gtk_widget_show(rc->widget);	return (RendererFuncs *) rc;}

static void _lib_backgroundjobs_set_cancellable(dt_lib_module_t *self, const guint *key, struct dt_job_t *job){  if(!darktable.control->running) return;  gboolean i_own_lock = dt_control_gdk_lock();  dt_lib_backgroundjobs_t *d = (dt_lib_backgroundjobs_t*)self->data;  dt_bgjob_t *j = (dt_bgjob_t*)g_hash_table_lookup(d->jobs, key);  if (j)  {    GtkWidget *w=j->widget;    GtkBox *hbox = GTK_BOX (g_list_nth_data (gtk_container_get_children (GTK_CONTAINER ( gtk_bin_get_child (GTK_BIN (w) ) ) ), 0));    GtkWidget *button = dtgtk_button_new(dtgtk_cairo_paint_cancel,CPF_STYLE_FLAT);    gtk_widget_set_size_request(button,17,17);    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (_lib_backgroundjobs_cancel_callback), (gpointer)job);    gtk_box_pack_start (hbox, GTK_WIDGET(button), FALSE, FALSE, 0);    gtk_widget_show_all(button);  }  if(i_own_lock) dt_control_gdk_unlock();}

voiddates_details_time_lminute_cb (GtkButton *source, DatesData *d){    dates_details_time_entry_alt (GTK_ARROW (gtk_bin_get_child (						 GTK_BIN (source))), d->lminute_entry, d, 5);}

//.........这里部分代码省略.........            gtk_range_set_value(GTK_RANGE(scale_compression), 9);            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savebgc), TRUE);            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savegamma), FALSE);            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_saveoff), FALSE);            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savephys), TRUE);            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savetime), TRUE);            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savecomm), TRUE);            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_savetrans), TRUE);        }                gtk_box_pack_start(GTK_BOX(vbox_advanced), check_savebgc, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(vbox_advanced), check_savegamma, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(vbox_advanced), check_saveoff, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(vbox_advanced), check_savephys, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(vbox_advanced), check_savetime, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(vbox_advanced), check_savecomm, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(vbox_advanced), check_savetrans, FALSE, FALSE, 0);                gtk_box_pack_start(GTK_BOX(inner_widget), check_interlace, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(hbox_compression), label_compression, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(hbox_compression), scale_compression, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(inner_widget), hbox_compression, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(inner_widget), expander_advanced, FALSE, FALSE, 0);        gtk_container_add (GTK_CONTAINER(expander_advanced), vbox_advanced);                g_signal_connect(G_OBJECT(expander_advanced), "activate", G_CALLBACK(adv_expanded), combo_format);    }    else if (selected_format == FORMAT_TGA) {            GtkWidget *hbox_origin, *label_origin;                    inner_widget = gtk_vbox_new(FALSE, 5);        gtk_container_set_border_width(GTK_CONTAINER(inner_widget), 8);        check_rle = gtk_check_button_new_with_label(_("RLE compression"));                hbox_origin = gtk_hbox_new(FALSE, 5);        label_origin = gtk_label_new(g_strconcat(_("Image origin"), ": ", NULL));        gtk_widget_set_size_request (label_origin, 100, LABEL_H);                combo_origin = gtk_combo_box_new_text();        gtk_widget_set_size_request (combo_origin, 100, COMBO_H);        gtk_combo_box_append_text(GTK_COMBO_BOX(combo_origin), _("Top-left"));        gtk_combo_box_append_text(GTK_COMBO_BOX(combo_origin), _("Bottom-left"));                if (selected_format == settings->format) {            format_params_tga settings_tga = (format_params_tga)(settings->params);            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_rle), settings_tga->rle);            gtk_combo_box_set_active(GTK_COMBO_BOX(combo_origin), settings_tga->origin);        }        else {            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_rle), FALSE);            gtk_combo_box_set_active(GTK_COMBO_BOX(combo_origin), 0);        }                gtk_box_pack_start(GTK_BOX(hbox_origin), label_origin, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(hbox_origin), combo_origin, FALSE, FALSE, 0);                gtk_box_pack_start(GTK_BOX(inner_widget), check_rle, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(inner_widget), hbox_origin, FALSE, FALSE, 0);    }    else if (selected_format == FORMAT_TIFF) {        GtkWidget *hbox_compression, *label_compression;                inner_widget = gtk_vbox_new(FALSE, 5);        gtk_container_set_border_width(GTK_CONTAINER(inner_widget), 8);        hbox_compression = gtk_hbox_new(FALSE, 5);        label_compression = gtk_label_new(_("Compression"));        gtk_widget_set_size_request (label_compression, 80, LABEL_H);        gtk_misc_set_alignment(GTK_MISC(label_compression), 0.5, 0.5);        combo_compression = gtk_combo_box_new_text();        gtk_widget_set_size_request (combo_compression, 130, COMBO_H);        gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("None"));        gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("LZW"));        gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("Pack bits"));        gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("Deflate"));        gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("JPEG"));        gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("CCITT G3 Fax"));        gtk_combo_box_append_text(GTK_COMBO_BOX(combo_compression), _("CCITT G4 Fax"));                if (selected_format == settings->format) {            format_params_tiff settings_tiff = (format_params_tiff)(settings->params);            gtk_combo_box_set_active(GTK_COMBO_BOX(combo_compression), settings_tiff->compression);        }        else {            gtk_combo_box_set_active(GTK_COMBO_BOX(combo_compression), 0);        }                gtk_box_pack_start(GTK_BOX(hbox_compression), label_compression, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(hbox_compression), combo_compression, FALSE, FALSE, 0);        gtk_box_pack_start(GTK_BOX(inner_widget), hbox_compression, FALSE, FALSE, 0);    }    else {        inner_widget = gtk_label_new(_("This format has no params"));    }        if (gtk_bin_get_child(GTK_BIN(frame_params)) != NULL) {        gtk_widget_destroy(gtk_bin_get_child(GTK_BIN(frame_params)));    }    gtk_container_add(GTK_CONTAINER(frame_params), inner_widget);    gtk_widget_show_all(frame_params);}

static voidupdate_editor_sheet (EggToolbarEditor *editor){  gint y;  GPtrArray *items;  GList *to_move = NULL, *to_copy = NULL;  GtkWidget *table;  GtkWidget *viewport;  g_return_if_fail (EGG_IS_TOOLBAR_EDITOR (editor));  /* Create new table. */  table = gtk_table_new (0, 0, TRUE);  editor->priv->table = table;  gtk_container_set_border_width (GTK_CONTAINER (table), 12);  gtk_table_set_row_spacings (GTK_TABLE (table), 24);  gtk_widget_show (table);  gtk_drag_dest_set (table, GTK_DEST_DEFAULT_ALL,		     dest_drag_types, G_N_ELEMENTS (dest_drag_types),                     GDK_ACTION_MOVE | GDK_ACTION_COPY);  /* Build two lists of items (one for copying, one for moving). */  items = egg_toolbars_model_get_name_avail (editor->priv->model);  while (items->len > 0)    {      GtkWidget *item;      const char *name;      gint flags;      name = g_ptr_array_index (items, 0);      g_ptr_array_remove_index_fast (items, 0);      flags = egg_toolbars_model_get_name_flags (editor->priv->model, name);      if ((flags & EGG_TB_MODEL_NAME_INFINITE) == 0)        {          item = editor_create_item_from_name (editor, name, GDK_ACTION_MOVE);          if (item != NULL)            to_move = g_list_insert_sorted (to_move, item, compare_items);        }      else        {          item = editor_create_item_from_name (editor, name, GDK_ACTION_COPY);          if (item != NULL)            to_copy = g_list_insert_sorted (to_copy, item, compare_items);        }    }  /* Add them to the sheet. */  y = 0;  y = append_table (GTK_TABLE (table), to_move, y, 4);  y = append_table (GTK_TABLE (table), to_copy, y, 4);  g_list_free (to_move);  g_list_free (to_copy);  g_ptr_array_free (items, TRUE);  /* Delete old table. */  viewport = gtk_bin_get_child (GTK_BIN (editor->priv->scrolled_window));  if (viewport)    {      gtk_container_remove (GTK_CONTAINER (viewport),                            gtk_bin_get_child (GTK_BIN (viewport)));    }  /* Add table to window. */  gtk_scrolled_window_add_with_viewport    (GTK_SCROLLED_WINDOW (editor->priv->scrolled_window), table);}

void set_combo_box_default_text (GtkComboBox *box, const char *s){    GtkWidget *entry = gtk_bin_get_child(GTK_BIN(box));    gtk_entry_set_text(GTK_ENTRY(entry), s);}

/** * na_gtk_utils_set_editable: * @widget: the #GtkWdiget. * @editable: whether the @widget is editable or not. * * Try to set a visual indication of whether the @widget is editable or not. * * Having a GtkWidget should be enough, but we also deal with a GtkTreeViewColumn. * So the most-bottom common ancestor is just GObject (since GtkObject having been * deprecated in Gtk+-3.0) * * Note that using 'sensitivity' property is just a work-around because the * two things have distinct semantics: * - editable: whether we are allowed to modify the value (is not read-only) * - sensitive: whether the value is relevant (has a sense in this context) */voidna_gtk_utils_set_editable( GObject *widget, gboolean editable ){	GList *renderers, *irender;/* GtkComboBoxEntry is deprecated from Gtk+3 * see. http://git.gnome.org/browse/gtk+/commit/?id=9612c648176378bf237ad0e1a8c6c995b0ca7c61 * while 'has_entry' property exists since 2.24 */#if GTK_CHECK_VERSION( 2,24,0 )	if( GTK_IS_COMBO_BOX( widget ) && gtk_combo_box_get_has_entry( GTK_COMBO_BOX( widget ))){#else	if( GTK_IS_COMBO_BOX_ENTRY( widget )){#endif		/* idem as GtkEntry */		gtk_editable_set_editable( GTK_EDITABLE( gtk_bin_get_child( GTK_BIN( widget ))), editable );		g_object_set( G_OBJECT( gtk_bin_get_child( GTK_BIN( widget ))), "can-focus", editable, NULL );		/* disable the listbox button itself */		gtk_combo_box_set_button_sensitivity( GTK_COMBO_BOX( widget ), editable ? GTK_SENSITIVITY_ON : GTK_SENSITIVITY_OFF );	} else if( GTK_IS_COMBO_BOX( widget )){		/* disable the listbox button itself */		gtk_combo_box_set_button_sensitivity( GTK_COMBO_BOX( widget ), editable ? GTK_SENSITIVITY_ON : GTK_SENSITIVITY_OFF );	} else if( GTK_IS_ENTRY( widget )){		gtk_editable_set_editable( GTK_EDITABLE( widget ), editable );		/* removing the frame leads to a disturbing modification of the		 * height of the control */		/*g_object_set( G_OBJECT( widget ), "has-frame", editable, NULL );*/		/* this prevents the caret to be displayed when we click in the entry */		g_object_set( G_OBJECT( widget ), "can-focus", editable, NULL );	} else if( GTK_IS_TEXT_VIEW( widget )){		g_object_set( G_OBJECT( widget ), "can-focus", editable, NULL );		gtk_text_view_set_editable( GTK_TEXT_VIEW( widget ), editable );	} else if( GTK_IS_TOGGLE_BUTTON( widget )){		/* transforms to a quasi standard GtkButton */		/*g_object_set( G_OBJECT( widget ), "draw-indicator", editable, NULL );*/		/* this at least prevent the keyboard focus to go to the button		 * (which is better than nothing) */		g_object_set( G_OBJECT( widget ), "can-focus", editable, NULL );	} else if( GTK_IS_TREE_VIEW_COLUMN( widget )){		renderers = gtk_cell_layout_get_cells( GTK_CELL_LAYOUT( GTK_TREE_VIEW_COLUMN( widget )));		for( irender = renderers ; irender ; irender = irender->next ){			if( GTK_IS_CELL_RENDERER_TEXT( irender->data )){				g_object_set( G_OBJECT( irender->data ), "editable", editable, "editable-set", TRUE, NULL );			}		}		g_list_free( renderers );	} else if( GTK_IS_BUTTON( widget )){		gtk_widget_set_sensitive( GTK_WIDGET( widget ), editable );	}}/** * na_gtk_utils_radio_set_initial_state: * @button: the #GtkRadioButton button which is initially active. * @handler: the corresponding "toggled" handler. * @user_data: the user data associated to the handler. * @editable: whether this radio button group is editable. * @sensitive: whether this radio button group is sensitive. * * This function should be called for the button which is initially active * inside of a radio button group when the radio group may happen to not be * editable. * This function should be called only once for the radio button group. * * It does the following operations: * - set the button as active * - set other buttons of the radio button group as icactive * - set all buttons of radio button group as @editable * * The initially active @button, along with its @handler, are recorded * as properties of the radio button group (actually as properties of each * radio button of the group), so that they can later be used to reset the * initial state. */voidna_gtk_utils_radio_set_initial_state( GtkRadioButton *button,		GCallback handler, void *user_data, gboolean editable, gboolean sensitive ){//.........这里部分代码省略.........

/** * fix_popover_menu_icons: * @window: a #GtkPopover * * Hackish code that inspects the popover's children, * retrieve the hidden GtkImage buried under lots of * widgets, and make it visible again. * * Hopefully, we'll find a better way to do this in * the long run. * */voidfix_popover_menu_icons (GtkPopover *popover){  GtkWidget *popover_stack;  GtkWidget *menu_section;  GtkWidget *menu_section_box;  GList *stack_children;  GList *menu_section_children;  GList *menu_section_box_children, *aux;  popover_stack = gtk_bin_get_child (GTK_BIN (popover));  stack_children = gtk_container_get_children (GTK_CONTAINER (popover_stack));  /**   * At the moment, the popover stack surely contains only   * one child of type GtkMenuSectionBox, which contains   * a single GtkBox.   */  menu_section = stack_children->data;  menu_section_children = gtk_container_get_children (GTK_CONTAINER (menu_section));	/**	 * Get the unique box's children.	 */  menu_section_box = menu_section_children->data;  menu_section_box_children = gtk_container_get_children (GTK_CONTAINER (menu_section_box));  /**   * Iterate through the GtkModelButtons inside the menu section box.   */  for (aux = menu_section_box_children; aux != NULL; aux = aux->next)    {      GtkWidget *button_box;      GList *button_box_children, *aux2;      button_box = gtk_bin_get_child (GTK_BIN (aux->data));      button_box_children = gtk_container_get_children (GTK_CONTAINER (button_box));      /**       * Since there is no guarantee that the first child is       * the GtkImage we're looking for, we have to iterate       * through the children and check if the types match.       */      for (aux2 = button_box_children; aux2 != NULL; aux2 = aux2->next)        {          GtkWidget *button_box_child;          button_box_child = aux2->data;          if (g_type_is_a (G_OBJECT_TYPE (button_box_child), GTK_TYPE_IMAGE))            {              gtk_widget_show (button_box_child);              break;            }        }      g_list_free (button_box_children);    }  g_list_free (stack_children);  g_list_free (menu_section_children);  g_list_free (menu_section_box_children);}

static voidbutton_clicked (GtkButton *button, GNCSearchAccount *fi){    GNCSearchAccountPrivate *priv;    GtkDialog *dialog;    GtkWidget *account_tree;    GtkWidget *accounts_scroller;    GtkWidget *label;    char *desc;    GtkTreeSelection *selection;    /* Create the account tree */    account_tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE));    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(account_tree), FALSE);    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(account_tree));    gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);    /* Select the currently-selected accounts */    priv = _PRIVATE(fi);    if (priv->selected_accounts)        gnc_tree_view_account_set_selected_accounts (GNC_TREE_VIEW_ACCOUNT(account_tree),                priv->selected_accounts, FALSE);    /* Create the account scroller and put the tree in it */    accounts_scroller = gtk_scrolled_window_new (NULL, NULL);    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(accounts_scroller),                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);    gtk_container_add(GTK_CONTAINER(accounts_scroller), account_tree);    gtk_widget_set_size_request(GTK_WIDGET(accounts_scroller), 300, 300);    /* Create the label */    label = gtk_label_new (_("Select Accounts to Match"));    /* Create the dialog */    dialog =        GTK_DIALOG(gtk_dialog_new_with_buttons(_("Select the Accounts to Compare"),                   NULL,                   0,                   _("_Cancel"), GTK_RESPONSE_CANCEL,                   _("_OK"), GTK_RESPONSE_OK,                   NULL));    /* Put the dialog together */    gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area (dialog), label,                        FALSE, FALSE, 3);    gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area (dialog), accounts_scroller,                        TRUE, TRUE, 3);    gtk_widget_show_all (GTK_WIDGET (dialog));    /* Now run the dialog */    if (gtk_dialog_run (dialog) == GTK_RESPONSE_OK)    {        if (priv->selected_accounts)            g_list_free (priv->selected_accounts);        priv->selected_accounts =            gnc_tree_view_account_get_selected_accounts (GNC_TREE_VIEW_ACCOUNT (account_tree));        desc = describe_button (fi);        gtk_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (button))), desc);    }    gtk_widget_destroy (GTK_WIDGET (dialog));}

voidephy_push_scroller_start (EphyPushScroller *scroller,			  EphyEmbed *embed,			  gdouble x,			  gdouble y){	EphyPushScrollerPrivate *priv = scroller->priv;	GtkWidget *widget, *child;	guint32 timestamp;	g_return_if_fail (embed != NULL);	LOG ("Start [%p]", scroller);	if (priv->active) return;	if (gdk_pointer_is_grabbed ()) return;	priv->active = TRUE;	/* FIXME is this good enough? */	timestamp = gtk_get_current_event_time ();	g_object_ref (scroller);	priv->embed = embed;	g_object_ref (priv->window);	/* set positions */	priv->start_x = x;	priv->start_y = y;	g_signal_connect (priv->window, "motion-notify-event",			  G_CALLBACK (ephy_push_scroller_motion_cb), scroller);	g_signal_connect (priv->window, "button-press-event",			  G_CALLBACK (ephy_push_scroller_mouse_press_cb), scroller);	g_signal_connect (priv->window, "button-release-event",			  G_CALLBACK (ephy_push_scroller_mouse_release_cb), scroller);	g_signal_connect (priv->window, "key-press-event",			  G_CALLBACK (ephy_push_scroller_key_press_cb), scroller);	g_signal_connect (priv->window, "unmap-event",			  G_CALLBACK (ephy_push_scroller_unmap_event_cb), scroller);	g_signal_connect (priv->window, "grab-broken-event",			  G_CALLBACK (ephy_push_scroller_grab_broken_event_cb), scroller);	/* FIXME: this signal only seems to be emitted on the container children of GtkWindow,	 * not on GtkWindow itself... is there a better way to get notified of new grabs?	 */	child = gtk_bin_get_child (GTK_BIN (priv->window));	g_signal_connect_object (child, "grab-notify",				 G_CALLBACK (ephy_push_scroller_grab_notify_cb), scroller, 0);	/* grab the pointer */	widget = GTK_WIDGET (priv->window);	gtk_grab_add (widget);	if (gdk_pointer_grab (gtk_widget_get_window (widget), FALSE,			      GDK_POINTER_MOTION_MASK |			      GDK_BUTTON_PRESS_MASK |			      GDK_BUTTON_RELEASE_MASK,			      NULL, priv->cursor, timestamp) != GDK_GRAB_SUCCESS)	{		ephy_push_scroller_stop (scroller, timestamp);		return;	}	if (gdk_keyboard_grab (gtk_widget_get_window (widget), FALSE, timestamp) != GDK_GRAB_SUCCESS)	{		ephy_push_scroller_stop (scroller, timestamp);		return;	}}

static voidupdate_table_button(UIMCandWinHorizontalGtk *horizontal_cwin, guint new_page){  UIMCandWinGtk *cwin;  GtkTreeModel *model;  GPtrArray *buttons;  GtkTreeIter ti;  gboolean has_next;  gint display_limit, len, cand_index = 0;  cwin = UIM_CAND_WIN_GTK(horizontal_cwin);  if (!cwin->stores->pdata[new_page]) {    return;  }  model = GTK_TREE_MODEL(cwin->stores->pdata[new_page]);  buttons = horizontal_cwin->buttons;  display_limit = cwin->display_limit;  len = buttons->len;  clear_all_buttons(buttons);  has_next = gtk_tree_model_get_iter_first(model, &ti);  while (has_next) {    gchar *heading;    gchar *cand_str;    GtkEventBox *button = NULL;    gtk_tree_model_get(model, &ti, COLUMN_HEADING, &heading,        COLUMN_CANDIDATE, &cand_str, TERMINATOR);    if (cand_str != NULL) {      button = assign_cellbutton(horizontal_cwin, cand_index, display_limit);      if (button != NULL) {        GtkWidget *label;        label = gtk_bin_get_child(GTK_BIN(button));        if (heading && heading[0] != '/0') {          gchar *text = g_strdup_printf("%s: %s", heading, cand_str);          gtk_label_set_text(GTK_LABEL(label), text);          g_free(text);	} else {          gtk_label_set_text(GTK_LABEL(label), cand_str);	}	scale_label(button, PANGO_SCALE_LARGE);      }    }    g_free(cand_str);    g_free(heading);    cand_index++;    has_next = gtk_tree_model_iter_next(model, &ti);  }  if (cand_index < len) {    gint i;    for (i = len - 1; i >= cand_index; i--) {      struct index_button *idxbutton;      idxbutton = g_ptr_array_index(buttons, i);      if (idxbutton == horizontal_cwin->selected)        horizontal_cwin->selected = NULL;      gtk_widget_destroy(GTK_WIDGET(idxbutton->button));      g_free(idxbutton);      g_ptr_array_remove_index(buttons, i);    }#if !GTK_CHECK_VERSION(3, 4, 0)    gtk_table_resize(GTK_TABLE(cwin->view), 1, cand_index);#endif  }}

//.........这里部分代码省略.........                           NULL);    /* Set the dialog up with HIG properties */    gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);    gtk_box_set_spacing(GTK_BOX(gtk_dialog_get_content_area(dialog)), 2); /* 2 * 5 + 2 = 12 */    gtk_container_set_border_width(GTK_CONTAINER(gtk_dialog_get_action_area(dialog)), 5);    gtk_box_set_spacing(GTK_BOX(gtk_dialog_get_action_area(dialog)), 6);    gtk_window_set_resizable(window, FALSE);    gtk_window_set_title(window, "");    gtk_window_set_icon_name(window, GTK_STOCK_DIALOG_AUTHENTICATION);    gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK);    /* Get the current toplevel */    g_signal_emit(authData->manager, signals[CURRENT_TOPLEVEL], 0, authData->msg, &toplevel);    if (toplevel)        gtk_window_set_transient_for(window, GTK_WINDOW(toplevel));    /* Build contents */    hbox = gtk_hbox_new(FALSE, 12);    gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);    gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(dialog)), hbox, TRUE, TRUE, 0);    icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION,                                    GTK_ICON_SIZE_DIALOG);    gtk_misc_set_alignment(GTK_MISC(icon), 0.5, 0.0);    gtk_box_pack_start(GTK_BOX(hbox), icon, FALSE, FALSE, 0);    mainVBox = gtk_vbox_new(FALSE, 18);    gtk_box_pack_start(GTK_BOX(hbox), mainVBox, TRUE, TRUE, 0);    uri = soup_message_get_uri(authData->msg);    description = g_strdup_printf(_("A username and password are being requested by the site %s"), uri->host);    descriptionLabel = gtk_label_new(description);    g_free(description);    gtk_misc_set_alignment(GTK_MISC(descriptionLabel), 0.0, 0.5);    gtk_label_set_line_wrap(GTK_LABEL(descriptionLabel), TRUE);    gtk_box_pack_start(GTK_BOX(mainVBox), GTK_WIDGET(descriptionLabel),                       FALSE, FALSE, 0);    vbox = gtk_vbox_new(FALSE, 6);    gtk_box_pack_start(GTK_BOX(mainVBox), vbox, FALSE, FALSE, 0);    /* The table that holds the entries */    entryContainer = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);    gtk_alignment_set_padding(GTK_ALIGNMENT(entryContainer),                              0, 0, 0, 0);    gtk_box_pack_start(GTK_BOX(vbox), entryContainer,                       FALSE, FALSE, 0);    realm = soup_auth_get_realm(authData->auth);    // Checking that realm is not an empty string    hasRealm = (realm && (strlen(realm) > 0));    table = gtk_table_new(hasRealm ? 3 : 2, 2, FALSE);    gtk_table_set_col_spacings(GTK_TABLE(table), 12);    gtk_table_set_row_spacings(GTK_TABLE(table), 6);    gtk_container_add(GTK_CONTAINER(entryContainer), table);    if (hasRealm) {        serverMessageDescriptionLabel = gtk_label_new(_("Server message:"));        serverMessageLabel = gtk_label_new(realm);        gtk_misc_set_alignment(GTK_MISC(serverMessageDescriptionLabel), 0.0, 0.5);        gtk_label_set_line_wrap(GTK_LABEL(serverMessageDescriptionLabel), TRUE);        gtk_misc_set_alignment(GTK_MISC(serverMessageLabel), 0.0, 0.5);        gtk_label_set_line_wrap(GTK_LABEL(serverMessageLabel), TRUE);        gtk_table_attach_defaults(GTK_TABLE(table), serverMessageDescriptionLabel,                                  0, 1, 0, 1);        gtk_table_attach_defaults(GTK_TABLE(table), serverMessageLabel,                                  1, 2, 0, 1);    }    authData->loginEntry = table_add_entry(table, hasRealm ? 1 : 0, _("Username:"),                                           login, NULL);    authData->passwordEntry = table_add_entry(table, hasRealm ? 2 : 1, _("Password:"),                                              password, NULL);    gtk_entry_set_visibility(GTK_ENTRY(authData->passwordEntry), FALSE);    if (session_can_save_passwords(authData->session)) {        rememberBox = gtk_vbox_new(FALSE, 6);        gtk_box_pack_start(GTK_BOX(vbox), rememberBox,                           FALSE, FALSE, 0);        checkButton = gtk_check_button_new_with_mnemonic(_("_Remember password"));        if (login && password)            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkButton), TRUE);        gtk_label_set_line_wrap(GTK_LABEL(gtk_bin_get_child(GTK_BIN(checkButton))), TRUE);        gtk_box_pack_start(GTK_BOX(rememberBox), checkButton, FALSE, FALSE, 0);        authData->checkButton = checkButton;    }    g_signal_connect(dialog, "response", G_CALLBACK(response_callback), authData);    gtk_widget_show_all(widget);}

static void spamassassin_save_func(PrefsPage *_page){	struct SpamAssassinPage *page = (struct SpamAssassinPage *) _page;	SpamAssassinConfig *config;	debug_print("Saving SpamAssassin Page/n");	config = spamassassin_get_config();	/* enable */	config->enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->enable_sa_checkbtn));	config->transport = page->trans;	/* username */	g_free(config->username);	config->username = gtk_editable_get_chars(GTK_EDITABLE(page->username), 0, -1);	spamassassin_check_username();	/* hostname */	g_free(config->hostname);	config->hostname = gtk_editable_get_chars(GTK_EDITABLE(page->hostname), 0, -1);	/* port */	config->port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->port));	/* hostname */	g_free(config->socket);	config->socket = gtk_editable_get_chars(GTK_EDITABLE(page->socket), 0, -1);	/* process_emails */	config->process_emails = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->process_emails));	/* receive_spam */	config->receive_spam = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->receive_spam));	/* save_folder */	g_free(config->save_folder);	config->save_folder = gtk_editable_get_chars(GTK_EDITABLE(page->save_folder), 0, -1);	/* max_size */	config->max_size = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->max_size));	/* timeout */	config->timeout = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->timeout));	/* mark_as_read */	config->mark_as_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->mark_as_read));	/* whitelist_ab */	config->whitelist_ab = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->whitelist_ab));	g_free(config->whitelist_ab_folder);	config->whitelist_ab_folder = gtk_editable_get_chars(				GTK_EDITABLE(gtk_bin_get_child(GTK_BIN((page->whitelist_ab_folder_combo)))), 0, -1);	/* store UNtranslated "Any" */	if (g_utf8_collate(config->whitelist_ab_folder, _("Any")) == 0) {		g_free(config->whitelist_ab_folder);		config->whitelist_ab_folder = g_strdup("Any");	}	if (config->process_emails) {		spamassassin_register_hook();	} else {		spamassassin_unregister_hook();	}	if (!config->enable) {		procmsg_unregister_spam_learner(spamassassin_learn);		procmsg_spam_set_folder(NULL, NULL);	} else {		if (config->transport == SPAMASSASSIN_TRANSPORT_TCP)			debug_print("enabling learner with a remote spamassassin server requires spamc/spamd 3.1.x/n");		procmsg_register_spam_learner(spamassassin_learn);		procmsg_spam_set_folder(config->save_folder, spamassassin_get_spam_folder);	}	spamassassin_save_config();}

static voiddt_lib_presets_popup_menu_show(dt_lib_module_info_t *minfo){  GtkMenu *menu = darktable.gui->presets_popup_menu;  if(menu)    gtk_widget_destroy(GTK_WIDGET(menu));  darktable.gui->presets_popup_menu = GTK_MENU(gtk_menu_new());  menu = darktable.gui->presets_popup_menu;  GtkWidget *mi;  int active_preset = -1, cnt = 0, writeprotect = 0;  sqlite3_stmt *stmt;  // order: get shipped defaults first  DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select name, op_params, writeprotect, description from presets where operation=?1 and op_version=?2 order by writeprotect desc, rowid", -1, &stmt, NULL);  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, minfo->plugin_name, strlen(minfo->plugin_name), SQLITE_TRANSIENT);  DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, minfo->version);  // collect all presets for op from db  int found = 0;  while(sqlite3_step(stmt) == SQLITE_ROW)  {    void *op_params = (void *)sqlite3_column_blob(stmt, 1);    int32_t op_params_size = sqlite3_column_bytes(stmt, 1);    const char *name = (char *)sqlite3_column_text(stmt, 0);    if (darktable.gui->last_preset        && strcmp(darktable.gui->last_preset, name)==0)      found = 1;    // selected in bold:    // printf("comparing %d bytes to %d/n", op_params_size, minfo->params_size);    // for(int k=0;k<op_params_size && !memcmp(minfo->params, op_params, k);k++) printf("compare [%c %c] %d: %d/n",    // ((const char*)(minfo->params))[k],    // ((const char*)(op_params))[k],    // k, memcmp(minfo->params, op_params, k));    if(op_params_size == minfo->params_size && !memcmp(minfo->params, op_params, op_params_size))    {      active_preset = cnt;      writeprotect = sqlite3_column_int(stmt, 2);      char *markup;      mi = gtk_menu_item_new_with_label("");      markup = g_markup_printf_escaped ("<span weight=/"bold/">%s</span>", name);      gtk_label_set_markup (GTK_LABEL (gtk_bin_get_child(GTK_BIN(mi))), markup);      g_free (markup);    }    else    {      mi = gtk_menu_item_new_with_label((const char *)name);    }    g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(pick_callback), minfo);    g_object_set(G_OBJECT(mi), "tooltip-text", sqlite3_column_text(stmt, 3), (char *)NULL);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);    cnt ++;  }  sqlite3_finalize(stmt);  if(cnt > 0)    gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());  // FIXME: this doesn't seem to work.  if(active_preset >= 0)  {    if(!writeprotect)    {      mi = gtk_menu_item_new_with_label(_("edit this preset.."));      g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_edit_preset), minfo);      gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);      mi = gtk_menu_item_new_with_label(_("delete this preset"));      g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_delete_preset), minfo);      gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);    }  }  else  {    mi = gtk_menu_item_new_with_label(_("store new preset.."));    g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_new_preset), minfo);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);    if (darktable.gui->last_preset && found)    {      char label[60];      strcpy (label, _("update preset"));      strcat (label, " <span weight=/"bold/">%s</span>");      char *markup = g_markup_printf_escaped (label, darktable.gui->last_preset);      mi = gtk_menu_item_new_with_label("");      gtk_label_set_markup (GTK_LABEL (gtk_bin_get_child(GTK_BIN(mi))), markup);      g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_update_preset), minfo);      gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);      g_free (markup);    }  }}

static void _camera_import_dialog_run(_camera_import_dialog_t *data){  gtk_widget_show_all(data->dialog);  // Populate store  // Setup a listener for previews of all files on camera  // then initiate fetch of all previews from camera  if(data->params->camera != NULL)  {    /* setup a camctl listener */    dt_camctl_listener_t listener = { 0 };    listener.data = data;    listener.control_status = _control_status;    listener.camera_storage_image_filename = _camera_storage_image_filename;    dt_job_t *job        = dt_camera_get_previews_job_create(data->params->camera, &listener, CAMCTL_IMAGE_PREVIEW_DATA, data);    if(job)    {      dt_control_job_set_state_callback(job, _preview_job_state_changed);      dt_control_add_job(darktable.control, DT_JOB_QUEUE_SYSTEM_FG, job);    }  }  else    return;  // Lets run dialog  gtk_label_set_text(GTK_LABEL(data->import.info),                     _("select the images from the list below that you want to import into a new filmroll"));  gboolean all_good = FALSE;  g_signal_connect(G_OBJECT(data->dialog), "delete-event", G_CALLBACK(_dialog_close), data);  while(!all_good)  {    gint result = gtk_dialog_run(GTK_DIALOG(data->dialog));    if(result == GTK_RESPONSE_ACCEPT)    {      GtkTreeIter iter;      all_good = TRUE;      GtkTreeSelection *selection          = gtk_tree_view_get_selection(GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview))));      // Now build up result from store into GList **result      g_list_free(data->params->result);      data->params->result = NULL;      GtkTreeModel *model = GTK_TREE_MODEL(data->store);      GList *sp = gtk_tree_selection_get_selected_rows(selection, &model);      if(sp)      {        do        {          GValue value = {            0,          };          gtk_tree_model_get_iter(GTK_TREE_MODEL(data->store), &iter, (GtkTreePath *)sp->data);          gtk_tree_model_get_value(GTK_TREE_MODEL(data->store), &iter, 1, &value);          if(G_VALUE_HOLDS_STRING(&value))            data->params->result = g_list_append(data->params->result, g_strdup(g_value_get_string(&value)));          g_value_unset(&value);        } while((sp = g_list_next(sp)));      }      /* get jobcode from import dialog */      data->params->jobcode = data->import.jobname->value;      /* get time override if used */      data->params->time_override = 0;      if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override)))        data->params->time_override            = parse_date_time(gtk_entry_get_text(GTK_ENTRY(data->settings.general.date_entry)));      if(data->params->jobcode == NULL || data->params->jobcode[0] == '/0')      {        g_free(data->params->jobcode); // might just be a string of length 0        data->params->jobcode = dt_conf_get_string("plugins/capture/camera/import/jobcode");      }      else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override))              && data->params->time_override == 0)      {        GtkWidget *dialog            = gtk_message_dialog_new(NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,                                     _("please use YYYY-MM-DD format for date override"));        g_signal_connect_swapped(dialog, "response", G_CALLBACK(gtk_widget_destroy), dialog);        gtk_dialog_run(GTK_DIALOG(dialog));        all_good = FALSE;      }    }    else    {      data->params->result = NULL;      all_good = TRUE;    }  }  // Destroy and quit  gtk_widget_destroy(data->dialog);}

static int gtkListMapMethod(Ihandle* ih){  GtkScrolledWindow* scrolled_window = NULL;  GtkListStore *store;  store = gtk_list_store_new(1, G_TYPE_STRING);  if (ih->data->is_dropdown)  {    GtkCellRenderer *renderer = NULL;    if (ih->data->has_editbox)      ih->handle = gtk_combo_box_entry_new_with_model(GTK_TREE_MODEL(store), 0);    else      ih->handle = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));    g_object_unref(store);    if (!ih->handle)      return IUP_ERROR;    g_object_set(G_OBJECT(ih->handle), "has-frame", TRUE, NULL);    if (ih->data->has_editbox)    {      GtkWidget *entry;#if GTK_CHECK_VERSION(2, 12, 0)      GList* list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(ih->handle));      renderer = list->data;      g_list_free(list);#endif      entry = gtk_bin_get_child(GTK_BIN(ih->handle));      iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry);      g_signal_connect(G_OBJECT(entry), "focus-in-event",     G_CALLBACK(iupgtkFocusInOutEvent), ih);      g_signal_connect(G_OBJECT(entry), "focus-out-event",    G_CALLBACK(iupgtkFocusInOutEvent), ih);      g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);      g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);      g_signal_connect(G_OBJECT(entry), "show-help",          G_CALLBACK(iupgtkShowHelp), ih);      g_signal_connect(G_OBJECT(entry), "key-press-event",    G_CALLBACK(iupgtkKeyPressEvent), ih);      g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih);      g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih);      g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih);  /* only report some caret movements */      g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih);      g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih);  /* if connected "after" then it is ignored */      g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih);      if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))        GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;    }    else    {      /* had to add an event box just to get get/killfocus,enter/leave events */      GtkWidget *box = gtk_event_box_new();      gtk_container_add((GtkContainer*)box, ih->handle);      iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)box);      renderer = gtk_cell_renderer_text_new();      gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ih->handle), renderer, TRUE);      gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ih->handle), renderer, "text", 0, NULL);      g_signal_connect(G_OBJECT(box), "focus-in-event",  G_CALLBACK(iupgtkFocusInOutEvent), ih);      g_signal_connect(G_OBJECT(box), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);      g_signal_connect(G_OBJECT(box), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);      g_signal_connect(G_OBJECT(box), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);      g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih);      g_signal_connect(G_OBJECT(ih->handle), "show-help",       G_CALLBACK(iupgtkShowHelp), ih);      if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))        GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;      else        GTK_WIDGET_FLAGS(box) |= GTK_CAN_FOCUS;    }    g_signal_connect(ih->handle, "changed", G_CALLBACK(gtkListComboBoxChanged), ih);    g_signal_connect(ih->handle, "notify::popup-shown", G_CALLBACK(gtkListComboBoxPopupShownChanged), ih);    if (renderer)    {      renderer->xpad = 0;      renderer->ypad = 0;      iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer);    }  }  else  {    GtkCellRenderer *renderer;    GtkTreeSelection* selection;    GtkTreeViewColumn *column;    GtkPolicyType scrollbar_policy;    ih->handle = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));    g_object_unref(store);    if (!ih->handle)      return IUP_ERROR;    scrolled_window = (GtkScrolledWindow*)gtk_scrolled_window_new(NULL, NULL);//.........这里部分代码省略.........