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

static voidchoose_picture(AvatarManipulation *self){    AvatarManipulationPrivate *priv = AVATAR_MANIPULATION_GET_PRIVATE(self);    GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;    GtkFileFilter *filter = gtk_file_filter_new ();    gint res;    auto preview = gtk_image_new();    GtkWidget *ring_main_window = gtk_widget_get_toplevel(GTK_WIDGET(self));    auto dialog = gtk_file_chooser_dialog_new (_("Open Avatar Image"),                                          GTK_WINDOW(ring_main_window),                                          action,                                          _("_Cancel"),                                          GTK_RESPONSE_CANCEL,                                          _("_Open"),                                          GTK_RESPONSE_ACCEPT,                                          NULL);    /* add filters */    gtk_file_filter_add_pattern (filter,"*.png");    gtk_file_filter_add_pattern (filter,"*.jpg");    gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(dialog),filter);    /* add an image preview inside the file choose */    gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER(dialog), preview);    g_signal_connect (GTK_FILE_CHOOSER(dialog), "update-preview", G_CALLBACK (update_preview_cb), preview);    /* start the file chooser */    res = gtk_dialog_run (GTK_DIALOG(dialog)); /* blocks until the dialog is closed */    if (res == GTK_RESPONSE_ACCEPT) {        if(auto filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (dialog))) {            GError* error =  nullptr; /* initialising to null avoid trouble... */            auto picture = gdk_pixbuf_new_from_file_at_size (filename, VIDEO_WIDTH, VIDEO_HEIGHT, &error);            if (!error) {                /* reset crop area */                if (priv->crop_area)                    gtk_container_remove(GTK_CONTAINER(priv->vbox_crop_area), priv->crop_area);                priv->crop_area = cc_crop_area_new();                gtk_widget_show(priv->crop_area);                gtk_box_pack_start(GTK_BOX(priv->vbox_crop_area), priv->crop_area, TRUE, TRUE, 0);                cc_crop_area_set_picture(CC_CROP_AREA(priv->crop_area), picture);                g_object_unref(picture);                set_state(self, AVATAR_MANIPULATION_STATE_EDIT);            } else {                g_warning("(choose_picture) failed to load pixbuf from file: %s", error->message);                g_error_free(error);            }            g_free(filename);        } else {            g_warning("(choose_picture) filename empty");        }    }    gtk_widget_destroy(dialog);}

/** * A button hit in the Export Dialog */static voidfile_export_response_callback(GtkWidget *fs,                               gint       response,                               gpointer   user_data){  char *filename;  Diagram *dia;  DiaExportFilter *ef;  struct stat statbuf;  dia = g_object_get_data (G_OBJECT (fs), "user_data");  g_assert (dia);  if (response == GTK_RESPONSE_ACCEPT) {    gint index;    diagram_update_extents(dia);    filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fs));    if (g_stat(filename, &statbuf) == 0) {      GtkWidget *dialog = NULL;      dialog = gtk_message_dialog_new (GTK_WINDOW(fs),				       GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, 				       GTK_MESSAGE_QUESTION,				       GTK_BUTTONS_YES_NO,				       _("File already exists"));      gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),        _("The file '%s' already exists./n"        "Do you want to overwrite it?"), dia_message_filename(filename));      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);      if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_YES) {	/* if not overwrite allow to select another filename */	gtk_widget_destroy(dialog);	g_free (filename);	return;      }      gtk_widget_destroy(dialog);    }    index = gtk_combo_box_get_active (GTK_COMBO_BOX(user_data));    if (index >= 0)      persistence_set_integer ("export-filter", index);    ef = efilter_by_index (index - 1, NULL);    if (!ef)      ef = filter_guess_export_filter(filename);    if (ef) {      DiaContext *ctx = dia_context_new (_("Export"));      g_object_ref(dia->data);      dia_context_set_filename (ctx, filename);      ef->export_func(dia->data, ctx,		      filename, dia->filename, ef->user_data);      g_object_unref(dia->data);      dia_context_release (ctx);    } else      message_error(_("Could not determine which export filter/n"		      "to use to save '%s'"), dia_message_filename(filename));    g_free (filename);  }  g_object_unref (dia); /* drop our diagram reference */  gtk_widget_destroy(exportdlg);}

//.........这里部分代码省略.........	// Create the threading spin box and label, and stash them in a box. (Yes, we do a lot of that.)	threads_label = gtk_label_new("Extra rendering threads:");	threads_spin = gtk_spin_button_new_with_range(0,100,1);	gtk_spin_button_set_value(GTK_SPIN_BUTTON(threads_spin), theApp.GetConfig("extrathreads", 0));	threads_box = gtk_hbox_new(false, 0);	gtk_box_pack_start(GTK_BOX(threads_box), threads_label, false, false, 5);	gtk_box_pack_start(GTK_BOX(threads_box), threads_spin, false, false, 5);	// A bit of funkiness for the resolution box.	native_label = gtk_label_new("Original PS2 Resolution: ");	native_res_check = gtk_check_button_new_with_label("Native");	native_box = gtk_hbox_new(false, 5);	gtk_box_pack_start(GTK_BOX(native_box), native_label, false, false, 5);	gtk_box_pack_start(GTK_BOX(native_box), native_res_check, false, false, 5);	fsaa_label = gtk_label_new("Or Use Scaling:");	fsaa_combo_box = CreateMsaaComboBox();	fsaa_box = gtk_hbox_new(false, 5);	gtk_box_pack_start(GTK_BOX(fsaa_box), fsaa_label, false, false, 5);	gtk_box_pack_start(GTK_BOX(fsaa_box), fsaa_combo_box, false, false, 5);	rexy_label = gtk_label_new("Custom Resolution:");	resx_spin = gtk_spin_button_new_with_range(256,8192,1);	gtk_spin_button_set_value(GTK_SPIN_BUTTON(resx_spin), theApp.GetConfig("resx", 1024));	resy_spin = gtk_spin_button_new_with_range(256,8192,1);	gtk_spin_button_set_value(GTK_SPIN_BUTTON(resy_spin), theApp.GetConfig("resy", 1024));	resxy_box = gtk_hbox_new(false, 5);	gtk_box_pack_start(GTK_BOX(resxy_box), rexy_label, false, false, 5);	gtk_box_pack_start(GTK_BOX(resxy_box), resx_spin, false, false, 5);	gtk_box_pack_start(GTK_BOX(resxy_box), resy_spin, false, false, 5);	// shader fx entry	shader            = gtk_file_chooser_button_new("Select an external shader", GTK_FILE_CHOOSER_ACTION_OPEN);	shader_conf       = gtk_file_chooser_button_new("Then select a config", GTK_FILE_CHOOSER_ACTION_OPEN);	shader_label      = gtk_label_new("External shader glsl");	shader_conf_label = gtk_label_new("External shader conf");	// Create our hack settings.	hack_alpha_check    = gtk_check_button_new_with_label("Alpha Hack");	hack_date_check     = gtk_check_button_new_with_label("Date Hack");	hack_offset_check   = gtk_check_button_new_with_label("Offset Hack");	hack_skipdraw_label = gtk_label_new("Skipdraw:");	hack_skipdraw_spin  = gtk_spin_button_new_with_range(0,1000,1);	hack_enble_check    = gtk_check_button_new_with_label("Enable User Hacks");	hack_wild_check     = gtk_check_button_new_with_label("Wild arm Hack");	hack_sprite_check   = gtk_check_button_new_with_label("Sprite Hack");	hack_msaa_check     = gtk_check_button_new_with_label("Msaa Hack");	hack_tco_label      = gtk_label_new("Texture Offset: 0x");	hack_tco_entry      = gtk_entry_new();	hack_logz_check     = gtk_check_button_new_with_label("Log Depth Hack");	gtk_spin_button_set_value(GTK_SPIN_BUTTON(hack_skipdraw_spin), theApp.GetConfig("UserHacks_SkipDraw", 0));	set_hex_entry(hack_tco_entry, theApp.GetConfig("UserHacks_TCOffset", 0));	// Tables are strange. The numbers are for their position: left, right, top, bottom.	gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_alpha_check, 0, 1, 0, 1);	gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_offset_check, 1, 2, 0, 1);	gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_sprite_check, 0, 1, 1, 2);	gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_wild_check, 1, 2, 1, 2);	gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_logz_check, 0, 1, 2, 3);	gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_date_check, 1, 2, 2, 3);	// Note: MSAA is not implemented yet. I disable it to make the table square	//gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_msaa_check, 2, 3, 1, 2);	gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_skipdraw_label, 0, 1, 3, 4);	gtk_table_attach_defaults(GTK_TABLE(hack_table), hack_skipdraw_spin, 1, 2, 3, 4);

void GtkToolkitFileChooser::OpenDialog(X11Types::Window parent, ToolkitFileChooserListener* result_listener){	gtk_widget_show(m_dialog);	XSetTransientForHint(GDK_WINDOW_XDISPLAY(gtk_widget_get_window(m_dialog)),						 GDK_WINDOW_XID(gtk_widget_get_window(m_dialog)), parent);	if (m_action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)		GtkUtils::SetResourceName(m_dialog, "directorychooserdialog");	else		GtkUtils::SetResourceName(m_dialog, "filechooserdialog");	int response_id;	while(1)	{		m_open_dialog = true;		response_id = gtk_dialog_run(GTK_DIALOG(m_dialog));		m_open_dialog = false;		if (response_id == GTK_RESPONSE_ACCEPT)		{			m_selected_filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(m_dialog));			m_active_directory = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(m_dialog));			if (m_action == GTK_FILE_CHOOSER_ACTION_SAVE)			{				// BIG FAT TEST for saving. The file selector (or at least some versions of it)				// allows users entering an existing directory and accepts this as a valid filename				// Do not allow that as we have code that can call OpFile::Delete(TRUE) before saving				// the file. See DSK-318398				if (!VerifySaveFiles())				{					GtkWidget* dialog = m_dialog;					m_dialog = 0;					ResetData();					m_dialog = dialog;					continue;				}			}		}		break;	}	/* Note that gtk sends GTK_RESPONSE_DELETE_EVENT if the dialog is	 * closed, including if the user presses the Escape button.	 */	if (response_id == GTK_RESPONSE_ACCEPT || response_id == GTK_RESPONSE_CANCEL || response_id == GTK_RESPONSE_DELETE_EVENT)	{		m_can_destroy = false;		result_listener->OnChoosingDone(this);		m_can_destroy = true;		if (m_request_destroy)		{			delete this; // Calls ResetData() in destructor			return;		}	}	ResetData();	GtkUtils::ProcessEvents();	if (response_id == RESPONSE_KILL_DIALOG)		delete this;}

/** * Respond to a button press (also destroy) in the save as dialog. */static voidfile_save_as_response_callback(GtkWidget *fs,                                gint       response,                                gpointer   user_data){  char *filename;  Diagram *dia;  struct stat stat_struct;  if (response == GTK_RESPONSE_ACCEPT) {    dia = g_object_get_data (G_OBJECT(fs), "user_data");    filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fs));    if (!filename) {      /* Not getting a filename looks like a contract violation in Gtk+ to me.       * Still Dia would be crashing (bug #651949) - instead simply go back to the dialog. */      gtk_window_present (GTK_WINDOW (fs));      return;    }    if (g_stat(filename, &stat_struct) == 0) {      GtkWidget *dialog = NULL;      char *utf8filename = NULL;      if (!g_utf8_validate(filename, -1, NULL)) {	utf8filename = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);	if (utf8filename == NULL) {	  message_warning(_("Some characters in the filename are neither UTF-8/n" 			    "nor your local encoding./nSome things will break."));	}      }      if (utf8filename == NULL) utf8filename = g_strdup(filename);      dialog = gtk_message_dialog_new (GTK_WINDOW(fs),				       GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,				       GTK_BUTTONS_YES_NO,				       _("File already exists"));      gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),        _("The file '%s' already exists./n"          "Do you want to overwrite it?"), utf8filename);      g_free(utf8filename);      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);      if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_YES) {	/* don't hide/destroy the dialog, but simply go back to it */	gtk_window_present (GTK_WINDOW (fs));	gtk_widget_destroy(dialog);        g_free (filename);	return;      }      gtk_widget_destroy(dialog);    }    dia->data->is_compressed = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(user_data));    diagram_update_extents(dia);    {      DiaContext *ctx = dia_context_new (_("Save as"));      diagram_set_filename(dia, filename);      dia_context_set_filename (ctx, filename);      if (diagram_save(dia, filename, ctx))	recent_file_history_add(filename);      dia_context_release (ctx);    }    g_free (filename);  }  /* if we have our own reference, drop it before destroy */  if ((dia = g_object_get_data (G_OBJECT(fs), "user_data")) != NULL) {    g_object_set_data (G_OBJECT(fs), "user_data", NULL);    g_object_unref (dia);  }  /* if we destroy it gtk_dialog_run wont give the response */  if (!g_object_get_data (G_OBJECT(fs), "dont-destroy"))    gtk_widget_destroy(GTK_WIDGET(fs));}

//.........这里部分代码省略.........	GdkGeometry geo = { 		-1, -1, 1024, 768, -1, -1, 10, 10, 0, 0, GDK_GRAVITY_NORTH_WEST	};	GdkWindowHints geo_mask;	geo_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE;	gtk_window_set_geometry_hints( GTK_WINDOW(widget), widget, &geo, geo_mask);	width = ghb_settings_get_int(ud->settings, "window_width");	height = ghb_settings_get_int(ud->settings, "window_height");	gtk_window_resize(GTK_WINDOW(widget), width, height);	gtk_widget_show(widget);	/* 	 * Filter objects in GtkBuilder xml 	 * Unfortunately, GtkFilter is poorly supported by GtkBuilder, 	 * so a lot of the setup must happen in code.		SourceFilterAll		SourceFilterVideo		SourceFilterTS		SourceFilterMPG		SourceFilterEVO		SourceFilterVOB		SourceFilterMKV		SourceFilterMP4		SourceFilterAVI		SourceFilterMOV		SourceFilterOGG		SourceFilterFLV		SourceFilterWMV	*/	// Add filters to source chooser	GtkFileFilter *filter;	GtkFileChooser *chooser;	chooser = GTK_FILE_CHOOSER(GHB_WIDGET(ud->builder, "source_dialog"));	filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll"));	gtk_file_filter_set_name(filter, "All");	gtk_file_filter_add_pattern(filter, "*");	gtk_file_chooser_add_filter(chooser, filter);	filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVideo"));	gtk_file_filter_set_name(filter, "Video");	gtk_file_filter_add_mime_type(filter, "video/*");	gtk_file_chooser_add_filter(chooser, filter);	filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterTS"));	gtk_file_filter_set_name(filter, "TS");	gtk_file_filter_add_pattern(filter, "*.ts");	gtk_file_filter_add_pattern(filter, "*.TS");	gtk_file_filter_add_pattern(filter, "*.m2ts");	gtk_file_filter_add_pattern(filter, "*.M2TS");	gtk_file_chooser_add_filter(chooser, filter);	filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMPG"));	gtk_file_filter_set_name(filter, "MPG");	gtk_file_filter_add_pattern(filter, "*.mpg");	gtk_file_filter_add_pattern(filter, "*.MPG");	gtk_file_filter_add_pattern(filter, "*.mepg");	gtk_file_filter_add_pattern(filter, "*.MEPG");	gtk_file_chooser_add_filter(chooser, filter);	filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterEVO"));	gtk_file_filter_set_name(filter, "EVO");	gtk_file_filter_add_pattern(filter, "*.evo");	gtk_file_filter_add_pattern(filter, "*.EVO");	gtk_file_chooser_add_filter(chooser, filter);	filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVOB"));	gtk_file_filter_set_name(filter, "VOB");	gtk_file_filter_add_pattern(filter, "*.vob");	gtk_file_filter_add_pattern(filter, "*.VOB");	gtk_file_chooser_add_filter(chooser, filter);

void sendMail(GtkWidget* widget,struct GUI *gui){		char addr[16];	int sockfd;	int n,i;		/* Reset Statu Label */	for(i=0;i<8;i++){		gtk_label_set_text(GTK_LABEL(gui->statu[i]),"-");	}		/* Get host and port */	gui->host = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptHost));	gui->port = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptPort));		/* Get From */	gui->from = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptFrom));		/* Get To */	for(i=0;i<gui->c_to;i++){		gui->to[i] = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptTo[i]));	}		/* Get Cc */	for(i=0;i<gui->c_cc;i++){		gui->cc[i] = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptCc[i]));	}		/* Get Bcc */	for(i=0;i<gui->c_bcc;i++){		gui->bcc[i] = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptBcc[i]));	}		/* Get Subject */	gui->subject = (char *)gtk_entry_get_text(GTK_ENTRY(gui->iptSubject));		/* Get Mailbody file */	gui->mailbody = (char *)gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(gui->btnOpenmail));		/* Get Attachment files */	for(i=0;i<gui->c_file;i++){		gui->file[i] = (char *)gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(gui->btnOpenfile[i]));	}		if(strcmp(gui->host,"")==0||strcmp(gui->port,"")==0){		gtk_label_set_text(GTK_LABEL(gui->statu[0]),"X");		gtk_widget_show_all(gui->window);		printf("host or port is (are) null string/n");		return;	}		/* Connect to mail server */	sockfd = connectToHost(gui->host,gui->port,addr);	if(sockfd==-1){		/* Connect Fail */		printf("Connect to host %s:%s fail/n",gui->host,gui->port);		gtk_label_set_text(GTK_LABEL(gui->statu[0]),"X");		gtk_widget_show_all(gui->window);		return;	}else{		printf("Connect to host %s(%s):%s/n",gui->host,addr,gui->port);				n = HELO(sockfd);		if(n==-1){			close(sockfd);			printf("Close SimpleMail./n");			gtk_label_set_text(GTK_LABEL(gui->statu[0]),"X");			gtk_widget_show_all(gui->window);			return;		}		gtk_label_set_text(GTK_LABEL(gui->statu[0]),"O");		gtk_widget_show_all(gui->window);						n = MAIL(sockfd,gui->from);		if(n==-1){			close(sockfd);			printf("Close SimpleMail./n");			gtk_label_set_text(GTK_LABEL(gui->statu[1]),"X");			gtk_widget_show_all(gui->window);			return;		}		gtk_label_set_text(GTK_LABEL(gui->statu[1]),"O");		gtk_widget_show_all(gui->window);						n = RCPT(sockfd,gui->to,gui->c_to,gui->cc,gui->c_cc,gui->bcc,gui->c_bcc);		switch(n){			case -1:				close(sockfd);				printf("Close SimpleMail./n");				gtk_label_set_text(GTK_LABEL(gui->statu[2]),"X");				gtk_widget_show_all(gui->window);				return;			case -2:				close(sockfd);				printf("Close SimpleMail./n");				gtk_label_set_text(GTK_LABEL(gui->statu[2]),"O");				gtk_label_set_text(GTK_LABEL(gui->statu[3]),"X");				gtk_widget_show_all(gui->window);//.........这里部分代码省略.........

static size_t write_fru(char *eeprom){	gint result;	const char *serial, *file;	char *ser_num, *filename;	time_t frutime;	FILE *fp = NULL;	size_t i;	time_t tmp;	struct tm *tmp2;	char buf[256];	int j, n;	struct dirent **namelist;	GtkListStore *store;	n = scandir(FRU_FILES, &namelist, 0, alphasort);	/* No fru files, don't bother */	if (n < 0) {		printf("didn't find FRU_Files in %s at %s(%s)/n", FRU_FILES, __FILE__, __func__);		return 0;	}	g_object_set(dialogs.serial_num, "secondary_text", eeprom, NULL);	filename = g_malloc(PATH_MAX);	ser_num = malloc(128);	memset(ser_num, 0, 128);	fp = fopen(".serialnum", "r");	if (fp) {		i = fread(ser_num, 1, 128, fp);		if (!ferror(fp) && (i == 128 || feof(fp)))			gtk_entry_set_text(GTK_ENTRY(serial_num), (const gchar*)&ser_num[1]);		fclose(fp);	}	store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(fru_file_list)));	gtk_list_store_clear(store);	for (j = 0; j < n; j++) {		if (namelist[j]->d_type == DT_REG && str_endswith(namelist[j]->d_name, ".bin"))			gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(fru_file_list), namelist[j]->d_name);		free(namelist[j]);	}	free(namelist);	gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(fru_file_list), "Other...");	gtk_combo_box_set_active(GTK_COMBO_BOX(fru_file_list), ser_num[0]);	free(ser_num);	frutime = mins_since_jan_1_1996();	tmp = min2date(frutime);	tmp2 = gmtime(&tmp);	strftime(buf, sizeof(buf), "%a %b %d %H:%M %Y", tmp2);	gtk_entry_set_text(GTK_ENTRY(fru_date), buf);get_serial_and_file:	result = gtk_dialog_run(GTK_DIALOG(dialogs.serial_num));	i = 0;	switch (result) {		case GTK_RESPONSE_OK:			serial = gtk_entry_get_text(GTK_ENTRY(serial_num));			if (strlen(serial) == 0) {				create_blocking_popup(GTK_MESSAGE_INFO, GTK_BUTTONS_OK,					"", "Serial number required");				goto get_serial_and_file;			}			file = gtk_combo_box_get_active_text(GTK_COMBO_BOX(fru_file_list));			if (strncmp(file, "Other...", 8) != 0) {				snprintf(filename, PATH_MAX, FRU_FILES "%s", file);			} else {				/* manually choose fru file */				GtkWidget *dialog;				dialog = gtk_file_chooser_dialog_new("Select FRU file",							GTK_WINDOW(dialogs.serial_num),							GTK_FILE_CHOOSER_ACTION_OPEN,							GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,							GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,							NULL);				if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {					filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));				}				gtk_widget_destroy(dialog);			}			if (filename) {				fflush(NULL);				sprintf(buf, "fru-dump -i %s -o %s -s %s -d %d 2>&1",						filename, eeprom, serial, (unsigned int)frutime);#if DEBUG				printf("%s/n", buf);#else//.........这里部分代码省略.........

/*! /brief Creates the add image dialog *  /par Function Description *  This function creates the add image dialog and loads the selected picture. */void picture_selection_dialog (GschemToplevel *w_current){  TOPLEVEL *toplevel = gschem_toplevel_get_toplevel (w_current);  gchar *filename;  GdkPixbuf *pixbuf;  GError *error = NULL;    w_current->pfswindow = gtk_file_chooser_dialog_new (_("Select a picture file..."),						      GTK_WINDOW(w_current->main_window),						      GTK_FILE_CHOOSER_ACTION_OPEN,						      GTK_STOCK_CANCEL, 						      GTK_RESPONSE_CANCEL,						      GTK_STOCK_OPEN, 						      GTK_RESPONSE_ACCEPT,						      NULL);  /* Set the alternative button order (ok, cancel, help) for other systems */  gtk_dialog_set_alternative_button_order(GTK_DIALOG(w_current->pfswindow),					  GTK_RESPONSE_ACCEPT,					  GTK_RESPONSE_CANCEL,					  -1);  if (w_current->pixbuf_filename)    gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(w_current->pfswindow), 				  w_current->pixbuf_filename);      if (gtk_dialog_run (GTK_DIALOG (w_current->pfswindow)) == GTK_RESPONSE_ACCEPT) {    filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w_current->pfswindow));    gtk_widget_destroy(w_current->pfswindow);    w_current->pfswindow=NULL;    pixbuf = gdk_pixbuf_new_from_file (filename, &error);        if (!pixbuf) {      GtkWidget *dialog;            dialog = gtk_message_dialog_new (GTK_WINDOW (w_current->main_window),				       GTK_DIALOG_DESTROY_WITH_PARENT,				       GTK_MESSAGE_ERROR,				       GTK_BUTTONS_CLOSE,				       _("Failed to load picture: %s"),				       error->message);      /* Wait for any user response */      gtk_dialog_run (GTK_DIALOG (dialog));            g_error_free (error);      gtk_widget_destroy(dialog);    }    else {#if DEBUG      printf("Picture loaded succesfully./n");#endif            o_invalidate_rubber(w_current);      i_update_middle_button(w_current, i_callback_add_picture, _("Picture"));      w_current->inside_action = 0;            o_picture_set_pixbuf(w_current, pixbuf, filename);          gschem_toplevel_page_content_changed (w_current, toplevel->page_current);      i_set_state(w_current, DRAWPICTURE);    }    g_free (filename);  }  i_update_toolbar(w_current);  if (w_current->pfswindow) {    gtk_widget_destroy(w_current->pfswindow);    w_current->pfswindow=NULL;  }}

static void _lib_import_single_image_callback(GtkWidget *widget,gpointer user_data){  GtkWidget *win = dt_ui_main_window(darktable.gui->ui);  GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("import image"),                           GTK_WINDOW (win),                           GTK_FILE_CHOOSER_ACTION_OPEN,                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,                           GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,                           (char *)NULL);  gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE);  char *last_directory = dt_conf_get_string("ui_last/import_last_directory");  if(last_directory != NULL)    gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (filechooser), last_directory);  char *cp, **extensions, ext[1024];  GtkFileFilter *filter;  filter = GTK_FILE_FILTER(gtk_file_filter_new());  extensions = g_strsplit(dt_supported_extensions, ",", 100);  for(char **i=extensions; *i!=NULL; i++)  {    snprintf(ext, 1024, "*.%s", *i);    gtk_file_filter_add_pattern(filter, ext);    gtk_file_filter_add_pattern(filter, cp=g_ascii_strup(ext, -1));    g_free(cp);  }  g_strfreev(extensions);  gtk_file_filter_set_name(filter, _("supported images"));  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);  filter = GTK_FILE_FILTER(gtk_file_filter_new());  gtk_file_filter_add_pattern(filter, "*");  gtk_file_filter_set_name(filter, _("all files"));  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);  GtkWidget *preview = gtk_image_new();  gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(filechooser), preview);  g_signal_connect(filechooser, "update-preview", G_CALLBACK (_lib_import_update_preview), preview);  dt_lib_import_metadata_t metadata;  gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filechooser), _lib_import_get_extra_widget(&metadata, FALSE));  if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT)  {    dt_conf_set_string("ui_last/import_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser)));    _lib_import_evaluate_extra_widget(&metadata, FALSE);    char *filename = NULL;    dt_film_t film;    GSList *list = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (filechooser));    GSList *it = list;    int id = 0;    int filmid = 0;    /* reset filter to display all images, otherwise view may remain empty */    dt_view_filter_reset_to_show_all(darktable.view_manager);    while(it)    {      filename = (char *)it->data;      gchar *directory = g_path_get_dirname((const gchar *)filename);      filmid = dt_film_new(&film, directory);      id = dt_image_import(filmid, filename, TRUE);      if(!id) dt_control_log(_("error loading file `%s'"), filename);      g_free (filename);      g_free (directory);      it = g_slist_next(it);    }    if(id)    {      dt_film_open(filmid);      // make sure buffers are loaded (load full for testing)      dt_mipmap_buffer_t buf;      dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);      if(!buf.buf)      {        dt_control_log(_("file has unknown format!"));      }      else      {        dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);        DT_CTL_SET_GLOBAL(lib_image_mouse_over_id, id);        dt_ctl_switch_mode_to(DT_DEVELOP);      }    }  }  gtk_widget_destroy(metadata.frame);  gtk_widget_destroy (filechooser);  gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));}

static void _lib_import_folder_callback(GtkWidget *widget,gpointer user_data){  GtkWidget *win = dt_ui_main_window(darktable.gui->ui);  GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("import film"),                           GTK_WINDOW (win),                           GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,                           GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,                           (char *)NULL);  gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE);  char *last_directory = dt_conf_get_string("ui_last/import_last_directory");  if(last_directory != NULL)    gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (filechooser), last_directory);  dt_lib_import_metadata_t metadata;  gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filechooser), _lib_import_get_extra_widget(&metadata, TRUE));  // run the dialog  if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT)  {    dt_conf_set_string("ui_last/import_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser)));    _lib_import_evaluate_extra_widget(&metadata, TRUE);    char *filename = NULL, *first_filename = NULL;    GSList *list = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (filechooser));    GSList *it = list;    /* reset filter to display all images, otherwise view may remain empty */    dt_view_filter_reset_to_show_all(darktable.view_manager);    /* for each selected folder add import job */    while(it)    {      filename = (char *)it->data;      dt_film_import(filename);      if (!first_filename)      {        first_filename = g_strdup(filename);        if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (metadata.recursive)))          first_filename = dt_util_dstrcat(first_filename, "%%");      }      g_free (filename);      it = g_slist_next(it);    }    /* update collection to view import */    if (first_filename)    {      dt_conf_set_int("plugins/lighttable/collect/num_rules", 1);      dt_conf_set_int("plugins/lighttable/collect/item0", 0);      dt_conf_set_string("plugins/lighttable/collect/string0",first_filename);      dt_collection_update_query(darktable.collection);      g_free(first_filename);    }    g_slist_free (list);  }  gtk_widget_destroy(metadata.frame);  gtk_widget_destroy (filechooser);  gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));}

  bool show(Display* parent) override {    static std::string s_lastUsedDir;    if (s_lastUsedDir.empty())      s_lastUsedDir = g_get_user_special_dir(G_USER_DIRECTORY_DESKTOP);    const char* okLabel;    GtkFileChooserAction action;    switch (m_type) {      case Type::OpenFile:      case Type::OpenFiles:        action = GTK_FILE_CHOOSER_ACTION_OPEN;        okLabel = "_Open";        break;      case Type::OpenFolder:        action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;        okLabel = "_Open Folder";        break;      case Type::SaveFile:        action = GTK_FILE_CHOOSER_ACTION_SAVE;        okLabel = "_Save";        break;    }    // GtkWindow* gtkParent = nullptr;    GtkWidget* dialog = gtk_file_chooser_dialog_new(      m_title.c_str(),      nullptr,      action,      "_Cancel", GTK_RESPONSE_CANCEL,      okLabel, GTK_RESPONSE_ACCEPT,      nullptr);    gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);    GtkFileChooser* chooser = GTK_FILE_CHOOSER(dialog);    m_chooser = chooser;    if (m_type == Type::SaveFile)      gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE);    else if (m_type == Type::OpenFiles)      gtk_file_chooser_set_select_multiple(chooser, true);    if (m_type != Type::OpenFolder) {      setupFilters(base::get_file_extension(m_filename));      setupPreview();    }    if (m_initialDir.empty())      gtk_file_chooser_set_current_folder(chooser, s_lastUsedDir.c_str());    else      gtk_file_chooser_set_current_folder(chooser, m_initialDir.c_str());    if (!m_filename.empty()) {      std::string fn = m_filename;      // Add default extension      if (m_type == Type::SaveFile && base::get_file_extension(fn).empty()) {        fn.push_back('.');        fn += m_defExtension;      }      gtk_file_chooser_set_current_name(chooser, fn.c_str());    }    // Setup the "parent" display as the parent of the dialog (we've    // to convert a X11 Window into a GdkWindow to do this).    GdkWindow* gdkParentWindow = nullptr;    if (parent) {      GdkWindow* gdkWindow = gtk_widget_get_root_window(dialog);      gdkParentWindow =        gdk_x11_window_foreign_new_for_display(          gdk_window_get_display(gdkWindow),          (::Window)parent->nativeHandle());      gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);      gdk_window_set_transient_for(gdkWindow, gdkParentWindow);    }    else {      gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);    }    // Show the dialog    gint res = gtk_dialog_run(GTK_DIALOG(dialog));    if (res == GTK_RESPONSE_ACCEPT) {      s_lastUsedDir = gtk_file_chooser_get_current_folder(chooser);      m_filename = gtk_file_chooser_get_filename(chooser);      if (m_type == Type::OpenFiles) {        GSList* list = gtk_file_chooser_get_filenames(chooser);        g_slist_foreach(          list,          [](void* fn, void* userdata){            auto self = (FileDialogGTK*)userdata;            self->m_filenames.push_back((char*)fn);            g_free(fn);          }, this);        g_slist_free(list);      }    }//.........这里部分代码省略.........

voidags_machine_open_extended_response_callback(GtkWidget *widget, gint response, AgsMachine *machine){  GtkFileChooserDialog *file_chooser;  AgsFileSelection *file_selection;  GtkCheckButton *overwrite;  GtkCheckButton *create;  GSList *filenames;  gchar *current_folder;  GError *error;  file_chooser = (GtkFileChooserDialog *) gtk_widget_get_toplevel(widget);  if(response == GTK_RESPONSE_ACCEPT){    filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser));    overwrite = g_object_get_data((GObject *) widget, "overwrite/0");    create = g_object_get_data((GObject *) widget, "create/0");    current_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(file_chooser));    //TODO:JK: you need to check against recently used    //TODO:JK: add more file types to AgsFileSelection    /* check for supported packed audio files */    file_selection = (AgsFileSelection *) gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(file_chooser));    if(file_selection != NULL && g_strcmp0(file_selection->directory, current_folder)){      gtk_widget_destroy(GTK_WIDGET(file_selection));      file_selection = NULL;    }    if(file_selection == NULL ||       (AGS_FILE_SELECTION_COMPLETED & (file_selection->flags)) == 0){      if((AGS_MACHINE_ACCEPT_SOUNDFONT2 & (machine->file_input_flags)) != 0){	GDir *current_directory;	GList *new_entry, *old_entry;	  	GSList *slist;	gchar *current_filename;		slist = filenames;	new_entry = NULL;		while(slist != NULL){	  if(g_str_has_suffix(slist->data,			      ".sf2/0")){	    AgsFileSelectionEntry *entry;	    	    	    entry = ags_file_selection_entry_alloc();	    entry->filename = slist->data;	  	    new_entry = g_list_prepend(new_entry,				       entry);	  }	  	  slist = slist->next;	}		old_entry = NULL;		if(file_selection == NULL){	  if(new_entry != NULL){	    file_selection = ags_file_selection_new();	    gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(file_chooser),					      GTK_WIDGET(file_selection));	    ags_file_selection_set_entry(file_selection,					 new_entry);	    ags_connectable_connect(AGS_CONNECTABLE(file_selection));	    gtk_widget_show_all(GTK_WIDGET(file_selection));	    return;	  }	}else if(AGS_IS_FILE_SELECTION(file_selection)){	  GList *really_new_entry;	  GList *list;	  	  old_entry = file_selection->entry;	  list = new_entry;	  really_new_entry = NULL;	  	  /* check against existing entries */	  if(new_entry != NULL){	    while(list != NULL){	      if(g_list_find(old_entry, list->data) == NULL){		really_new_entry = g_list_prepend(really_new_entry,						  list->data);	      }else{		free(list->data);	      }	      	      list = list->next;	    }	    	    g_list_free(new_entry);	  }	  	  ags_file_selection_set_entry(file_selection,//.........这里部分代码省略.........

static voidsave_dialog_response_cb (GtkDialog * dialog,                         gint response_id, GtrWindow * window){  GError *error = NULL;  GtrPo *po;  GtrTab *tab;  gchar *filename;  GFile *location;  GtrStatusbar *status;  tab = GTR_TAB (g_object_get_data (G_OBJECT (dialog), GTR_TAB_SAVE_AS));  g_return_if_fail (GTK_IS_FILE_CHOOSER (dialog));  po = gtr_tab_get_po (tab);  if (response_id != GTK_RESPONSE_ACCEPT)    {      gtk_widget_destroy (GTK_WIDGET (dialog));      return;    }  filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));  g_return_if_fail (filename != NULL);  location = g_file_new_for_path (filename);  g_free (filename);  gtk_widget_destroy (GTK_WIDGET (dialog));  if (po != NULL)    {      gtr_po_set_location (po, location);      g_object_unref (location);      gtr_po_save_file (po, &error);      if (error)        {          GtkWidget *dialog;          dialog = gtk_message_dialog_new (GTK_WINDOW (window),                                           GTK_DIALOG_DESTROY_WITH_PARENT,                                           GTK_MESSAGE_WARNING,                                           GTK_BUTTONS_OK,                                           "%s", error->message);          gtk_dialog_run (GTK_DIALOG (dialog));          gtk_widget_destroy (dialog);          g_clear_error (&error);          return;        }      /* We have to change the state of the tab */      gtr_po_set_state (po, GTR_PO_STATE_SAVED);      /* Flash a message */      status = GTR_STATUSBAR (gtr_window_get_statusbar (window));      gtr_statusbar_flash_message (status, 0, _("File saved."));    }  g_object_unref (location);}

static voidimpl_constructed (GObject *object){	RBImportDialog *dialog;	RhythmDBQuery *query;	GtkBuilder *builder;	GSettings *settings;	char **locations;	RB_CHAIN_GOBJECT_METHOD (rb_import_dialog_parent_class, constructed, object);	dialog = RB_IMPORT_DIALOG (object);	g_object_get (dialog->priv->shell,		      "db", &dialog->priv->db,		      "shell-player", &dialog->priv->shell_player,		      NULL);	/* create entry types */	dialog->priv->entry_type = g_object_new (rb_import_dialog_entry_type_get_type (),						 "db", dialog->priv->db,						 "name", "import-dialog",						 NULL);	dialog->priv->ignore_type = g_object_new (rb_import_dialog_ignore_type_get_type (),						  "db", dialog->priv->db,						  "name", "import-dialog-ignore",						  NULL);	rhythmdb_register_entry_type (dialog->priv->db, dialog->priv->entry_type);	rhythmdb_register_entry_type (dialog->priv->db, dialog->priv->ignore_type);	builder = rb_builder_load ("import-dialog.ui", NULL);	dialog->priv->import_button = GTK_WIDGET (gtk_builder_get_object (builder, "import-button"));	g_signal_connect_object (dialog->priv->import_button, "clicked", G_CALLBACK (import_clicked_cb), dialog, 0);	gtk_widget_set_sensitive (dialog->priv->import_button, FALSE);	dialog->priv->copy_check = GTK_WIDGET (gtk_builder_get_object (builder, "copy-check"));	g_signal_connect (gtk_builder_get_object (builder, "close-button"),			  "clicked",			  G_CALLBACK (close_clicked_cb),			  dialog);	dialog->priv->file_chooser = GTK_WIDGET (gtk_builder_get_object (builder, "file-chooser-button"));		/* select the first library location, since the default may be	 * the user's home dir or / or something that will take forever to scan.	 */	settings = g_settings_new ("org.gnome.rhythmbox.rhythmdb");	locations = g_settings_get_strv (settings, "locations");	if (locations[0] != NULL) {		dialog->priv->current_uri = g_strdup (locations[0]);	} else {		dialog->priv->current_uri = g_filename_to_uri (rb_music_dir (), NULL, NULL);	}	gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (dialog->priv->file_chooser),						 dialog->priv->current_uri);	g_strfreev (locations);	g_object_unref (settings);	g_signal_connect_object (dialog->priv->file_chooser, "selection-changed", G_CALLBACK (current_folder_changed_cb), dialog, 0);	/* not sure why we have to set this, it should be the default */	gtk_widget_set_vexpand (gtk_widget_get_parent (dialog->priv->file_chooser), FALSE);	dialog->priv->info_bar_container = GTK_WIDGET (gtk_builder_get_object (builder, "info-bar-container"));	/* set up entry view */	dialog->priv->entry_view = rb_entry_view_new (dialog->priv->db, G_OBJECT (dialog->priv->shell_player), TRUE, FALSE);	g_signal_connect (dialog->priv->entry_view, "entry-activated", G_CALLBACK (entry_activated_cb), dialog);	g_signal_connect (dialog->priv->entry_view, "selection-changed", G_CALLBACK (selection_changed_cb), dialog);	rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE);	rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_TITLE, TRUE);	rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_GENRE, FALSE);	rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_ARTIST, FALSE);	rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_ALBUM, FALSE);	rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_YEAR, FALSE);	rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_DURATION, FALSE); 	rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_QUALITY, FALSE);	rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_PLAY_COUNT, FALSE);	rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_BPM, FALSE);	rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_COMMENT, FALSE);	rb_entry_view_append_column (dialog->priv->entry_view, RB_ENTRY_VIEW_COL_LOCATION, FALSE);	settings = g_settings_new ("org.gnome.rhythmbox.sources");	g_settings_bind (settings, "visible-columns", dialog->priv->entry_view, "visible-columns", G_SETTINGS_BIND_DEFAULT);	g_object_unref (settings);	g_signal_connect (dialog->priv->entry_view,			  "notify::sort-order",			  G_CALLBACK (sort_changed_cb),			  dialog);	rb_entry_view_set_sorting_order (dialog->priv->entry_view, "Album", GTK_SORT_ASCENDING);	gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (builder, "entry-view-container")),			   GTK_WIDGET (dialog->priv->entry_view));	dialog->priv->query_model = rhythmdb_query_model_new_empty (dialog->priv->db);//.........这里部分代码省略.........

/*! /brief Create dialog to exchange picture objects *  /par Function Description *  This function opens a file chooser and replaces all pictures of the selections *  with the new picture. * *  /todo Maybe merge this dialog function with picture_selection_dialog() */void picture_change_filename_dialog (GschemToplevel *w_current){  TOPLEVEL *toplevel = gschem_toplevel_get_toplevel (w_current);  gchar *filename;  gboolean result;  GError *error = NULL;    w_current->pfswindow = gtk_file_chooser_dialog_new (_("Select a picture file..."),						      GTK_WINDOW(w_current->main_window),						      GTK_FILE_CHOOSER_ACTION_OPEN,						      GTK_STOCK_CANCEL, 						      GTK_RESPONSE_CANCEL,						      GTK_STOCK_OPEN, 						      GTK_RESPONSE_ACCEPT,						      NULL);  /* Set the alternative button order (ok, cancel, help) for other systems */  gtk_dialog_set_alternative_button_order(GTK_DIALOG(w_current->pfswindow),					  GTK_RESPONSE_ACCEPT,					  GTK_RESPONSE_CANCEL,					  -1);  if (w_current->pixbuf_filename)    gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(w_current->pfswindow), 				  w_current->pixbuf_filename);      if (gtk_dialog_run (GTK_DIALOG (w_current->pfswindow)) == GTK_RESPONSE_ACCEPT) {    filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w_current->pfswindow));    gtk_widget_destroy(w_current->pfswindow);    w_current->pfswindow=NULL;    /* Actually update the pictures */    result = o_picture_exchange (w_current, filename, &error);    if (!result) {      GtkWidget *dialog;      dialog = gtk_message_dialog_new (GTK_WINDOW (w_current->main_window),				       GTK_DIALOG_DESTROY_WITH_PARENT,				       GTK_MESSAGE_ERROR,				       GTK_BUTTONS_CLOSE,				       _("Failed to replace pictures: %s"),				       error->message);      /* Wait for any user response */      gtk_dialog_run (GTK_DIALOG (dialog));      g_error_free (error);      gtk_widget_destroy(dialog);    } else {      gschem_toplevel_page_content_changed (w_current, toplevel->page_current);    }    g_free (filename);  }  i_update_toolbar(w_current);  if (w_current->pfswindow) {    gtk_widget_destroy(w_current->pfswindow);    w_current->pfswindow=NULL;  }}

voidgtkutil_file_req (const char *title, void *callback, void *userdata, char *filter, char *extensions,						int flags){	struct file_req *freq;	GtkWidget *dialog;	GtkFileFilter *filefilter;	extern char *get_xdir_fs (void);	char *token;	char *tokenbuffer;#ifdef WIN32	if (!(flags & FRF_WRITE))	{		freq = malloc (sizeof (struct file_req));		freq->th = thread_new ();		freq->flags = 0;		freq->multiple = (flags & FRF_MULTIPLE);		freq->callback = callback;		freq->userdata = userdata;		freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0);		if (!filter)		{			freq->filter =	"All files/0*.*/0"							"Executables/0*.exe/0"							"ZIP files/0*.zip/0/0";		}		else		{			freq->filter = filter;		}		thread_start (freq->th, win32_thread, freq);		fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq);		return;	}		else {		freq = malloc (sizeof (struct file_req));		freq->th = thread_new ();		freq->flags = 0;		freq->multiple = (flags & FRF_MULTIPLE);		freq->callback = callback;		freq->userdata = userdata;		freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0);		if (!filter)		{			freq->filter = "All files/0*.*/0/0";		}		else		{			freq->filter = filter;		}		thread_start (freq->th, win32_thread2, freq);		fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq);	return;	}#endif	if (flags & FRF_WRITE)	{		dialog = gtk_file_chooser_dialog_new (title, NULL,												GTK_FILE_CHOOSER_ACTION_SAVE,												GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,												GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,												NULL);		if (filter && filter[0])	/* filter becomes initial name when saving */		{			char temp[1024];			path_part (filter, temp, sizeof (temp));			gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), temp);			gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), file_part (filter));		}		if (!(flags & FRF_NOASKOVERWRITE))			gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);	}	else		dialog = gtk_file_chooser_dialog_new (title, NULL,												GTK_FILE_CHOOSER_ACTION_OPEN,												GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,												GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,												NULL);	if (flags & FRF_MULTIPLE)		gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);	if (last_dir[0])		gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), last_dir);	if (flags & FRF_ADDFOLDER)		gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),														  get_xdir_fs (), NULL);	if (flags & FRF_CHOOSEFOLDER)	{		gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);		gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter);	}	else//.........这里部分代码省略.........

GtkWidget*gtr_torrent_options_dialog_new (GtkWindow * parent, TrCore * core, tr_ctor * ctor){  const char *     str;  GtkWidget *      w;  GtkWidget *      d;  GtkGrid        * grid;  int              row;  GtkWidget *      l;  GtkWidget *      source_chooser;  struct OpenData * data;  bool             flag;  GSList *         list;  GSList *         walk;  /* make the dialog */  d = gtk_dialog_new_with_buttons (_("Torrent Options"), parent,                                   GTK_DIALOG_DESTROY_WITH_PARENT,                                   GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,                                   GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,                                   NULL);  gtk_dialog_set_default_response (GTK_DIALOG (d),                                   GTK_RESPONSE_ACCEPT);  gtk_dialog_set_alternative_button_order (GTK_DIALOG (d),                                           GTK_RESPONSE_ACCEPT,                                           GTK_RESPONSE_CANCEL,                                           -1);  if (tr_ctorGetDownloadDir (ctor, TR_FORCE, &str))    g_assert_not_reached ();  g_assert (str);  data = g_new0 (struct OpenData, 1);  data->core = core;  data->ctor = ctor;  data->filename = g_strdup (tr_ctorGetSourceFile (ctor));  data->downloadDir = g_strdup (str);  data->file_list = gtr_file_list_new (core, 0);  str = _("Mo_ve .torrent file to the trash");  data->trash_check = gtk_check_button_new_with_mnemonic (str);  str = _("_Start when added");  data->run_check = gtk_check_button_new_with_mnemonic (str);  w = data->priority_combo = gtr_priority_combo_new ();  gtr_priority_combo_set_value (GTK_COMBO_BOX (w), TR_PRI_NORMAL);  g_signal_connect (G_OBJECT (d), "response",                    G_CALLBACK (addResponseCB), data);  row = 0;  grid = GTK_GRID (gtk_grid_new ());  gtk_container_set_border_width (GTK_CONTAINER (grid), GUI_PAD_BIG);  gtk_grid_set_row_spacing (grid, GUI_PAD);  gtk_grid_set_column_spacing (grid, GUI_PAD_BIG);  /* "torrent file" row */  l = gtk_label_new_with_mnemonic (_("_Torrent file:"));  gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);  gtk_grid_attach (grid, l, 0, row, 1, 1);  w = gtk_file_chooser_button_new (_("Select Source File"),                                   GTK_FILE_CHOOSER_ACTION_OPEN);  source_chooser = w;  gtk_widget_set_hexpand (w, TRUE);  gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);  gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);  addTorrentFilters (GTK_FILE_CHOOSER (w));  g_signal_connect (w, "selection-changed",                    G_CALLBACK (sourceChanged), data);  /* "destination folder" row */  row++;  l = gtk_label_new_with_mnemonic (_("_Destination folder:"));  gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);  gtk_grid_attach (grid, l, 0, row, 1, 1);  w = gtk_file_chooser_button_new (_("Select Destination Folder"),                                   GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);  if (!gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w),                                            data->downloadDir))    g_warning ("couldn't select '%s'", data->downloadDir);  list = get_recent_destinations ();  for (walk = list; walk; walk = walk->next)    gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (w), walk->data, NULL);  g_slist_free (list);  gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);  gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);  g_signal_connect (w, "selection-changed",                    G_CALLBACK (downloadDirChanged), data);  row++;  l = data->freespace_label = gtr_freespace_label_new (core, data->downloadDir);  gtk_widget_set_margin_bottom (l, GUI_PAD_BIG);  gtk_misc_set_alignment (GTK_MISC (l), 1.0f, 0.5f);  gtk_grid_attach (grid, l, 0, row, 2, 1);  /* file list row */  row++;  w = data->file_list;  gtk_widget_set_vexpand (w, TRUE);  gtk_widget_set_size_request (w, 466u, 300u);//.........这里部分代码省略.........

static voidsave_avatar_menu_activate_cb (GtkWidget *widget,                              EmpathyContactWidget *information){  GtkWidget *dialog;  EmpathyAvatar *avatar;  gchar *ext = NULL, *filename;  dialog = gtk_file_chooser_dialog_new (_("Save Avatar"),      NULL,      GTK_FILE_CHOOSER_ACTION_SAVE,      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,      GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,      NULL);  gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),      TRUE);  /* look for the avatar extension */  avatar = empathy_contact_get_avatar (information->contact);  if (avatar->format != NULL)    {      gchar **splitted;      splitted = g_strsplit (avatar->format, "/", 2);      if (splitted[0] != NULL && splitted[1] != NULL)          ext = g_strdup (splitted[1]);      g_strfreev (splitted);    }  else    {      /* Avatar was loaded from the cache so was converted to PNG */      ext = g_strdup ("png");    }  if (ext != NULL)    {      gchar *id;      id = tp_escape_as_identifier (empathy_contact_get_id (            information->contact));      filename = g_strdup_printf ("%s.%s", id, ext);      gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), filename);      g_free (id);      g_free (ext);      g_free (filename);    }  if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)    {      GError *error = NULL;      filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));      if (!empathy_avatar_save_to_file (avatar, filename, &error))        {          /* Save error */          GtkWidget *error_dialog;          error_dialog = gtk_message_dialog_new (NULL, 0,              GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,              _("Unable to save avatar"));          gtk_message_dialog_format_secondary_text (              GTK_MESSAGE_DIALOG (error_dialog), "%s", error->message);          g_signal_connect (error_dialog, "response",              G_CALLBACK (gtk_widget_destroy), NULL);          gtk_window_present (GTK_WINDOW (error_dialog));          g_clear_error (&error);        }      g_free (filename);    }  gtk_widget_destroy (dialog);}

static voidavatar_chooser_clicked_cb (GtkWidget            *button,			   EmpathyAvatarChooser *chooser){	GtkFileChooser *chooser_dialog;	GtkWidget      *image;	gchar          *saved_dir = NULL;	const gchar    *default_dir = DEFAULT_DIR;	const gchar    *pics_dir;	GtkFileFilter  *filter;	EmpathyAvatarChooserPriv *priv = GET_PRIV (chooser);	if (priv->chooser_dialog) {		gtk_window_present (GTK_WINDOW (priv->chooser_dialog));		return;	}	priv->chooser_dialog = GTK_FILE_CHOOSER (		gtk_file_chooser_dialog_new (_("Select Your Avatar Image"),					     empathy_get_toplevel_window (GTK_WIDGET (chooser)),					     GTK_FILE_CHOOSER_ACTION_OPEN,					     _("No Image"),					     GTK_RESPONSE_NO,					     GTK_STOCK_CANCEL,					     GTK_RESPONSE_CANCEL,					     GTK_STOCK_OPEN,					     GTK_RESPONSE_OK,					     NULL));	chooser_dialog = priv->chooser_dialog;	gtk_window_set_destroy_with_parent (GTK_WINDOW (chooser_dialog), TRUE);	/* Get special dirs */	empathy_conf_get_string (empathy_conf_get (),				 EMPATHY_PREFS_UI_AVATAR_DIRECTORY,				 &saved_dir);	if (saved_dir && !g_file_test (saved_dir, G_FILE_TEST_IS_DIR)) {		g_free (saved_dir);		saved_dir = NULL;	}	if (!g_file_test (default_dir, G_FILE_TEST_IS_DIR)) {		default_dir = NULL;	}	pics_dir = g_get_user_special_dir (G_USER_DIRECTORY_PICTURES);	if (pics_dir && !g_file_test (pics_dir, G_FILE_TEST_IS_DIR)) {		pics_dir = NULL;	}	/* Set current dir to the last one or to DEFAULT_DIR or to home */	if (saved_dir) {		gtk_file_chooser_set_current_folder (chooser_dialog, saved_dir);	}	else if (pics_dir) {		gtk_file_chooser_set_current_folder (chooser_dialog, pics_dir);	}	else if (default_dir) {		gtk_file_chooser_set_current_folder (chooser_dialog, default_dir);	} else {		gtk_file_chooser_set_current_folder (chooser_dialog, g_get_home_dir ());	}	/* Add shortcuts to special dirs */	if (saved_dir) {		gtk_file_chooser_add_shortcut_folder (chooser_dialog, saved_dir, NULL);	}	else if (pics_dir) {		gtk_file_chooser_add_shortcut_folder (chooser_dialog, pics_dir, NULL);	}	if (default_dir) {		gtk_file_chooser_add_shortcut_folder (chooser_dialog, default_dir, NULL);	}	/* Setup preview image */	image = gtk_image_new ();	gtk_file_chooser_set_preview_widget (chooser_dialog, image);	gtk_widget_set_size_request (image, AVATAR_SIZE_SAVE, AVATAR_SIZE_SAVE);	gtk_widget_show (image);	gtk_file_chooser_set_use_preview_label (chooser_dialog,	FALSE);	g_signal_connect (chooser_dialog, "update-preview",			  G_CALLBACK (avatar_chooser_update_preview_cb),			  chooser);	/* Setup filers */	filter = gtk_file_filter_new ();	gtk_file_filter_set_name (filter, _("Images"));	gtk_file_filter_add_pixbuf_formats (filter);	gtk_file_chooser_add_filter (chooser_dialog, filter);	filter = gtk_file_filter_new ();	gtk_file_filter_set_name (filter, _("All Files"));	gtk_file_filter_add_pattern (filter, "*");	gtk_file_chooser_add_filter (chooser_dialog, filter);	/* Setup response */	gtk_dialog_set_default_response (GTK_DIALOG (chooser_dialog), GTK_RESPONSE_OK);	g_signal_connect (chooser_dialog, "response",			  G_CALLBACK (avatar_chooser_response_cb),			  chooser);	gtk_widget_show (GTK_WIDGET (chooser_dialog));	g_free (saved_dir);}

void GtkToolkitFileChooser::ShowHiddenFiles(bool show_hidden){	gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(m_dialog), show_hidden);}

int main(int argc, char* argv[]){	regex_t fregex[2];	gtk_init(&argc,&argv);	// check the correct BASS was loaded	if (HIWORD(BASS_GetVersion())!=BASSVERSION) {		Error("An incorrect version of BASS was loaded");		return 0;	}	// Initialize the output device with 3D support	if (!BASS_Init(-1,44100,BASS_DEVICE_3D,NULL,NULL)) {		Error("Can't initialize device");		return 0;	}	{		BASS_INFO i;		BASS_GetInfo(&i);		if (i.speakers>2) {			GtkWidget *dialog=gtk_message_dialog_new(NULL,0,				GTK_MESSAGE_QUESTION,GTK_BUTTONS_YES_NO,"Multiple speakers were detected. Would you like to use them?");			if (gtk_dialog_run(GTK_DIALOG(dialog))==GTK_RESPONSE_NO)				BASS_SetConfig(BASS_CONFIG_3DALGORITHM,BASS_3DALG_OFF);			gtk_widget_destroy(dialog);		}	}	// Use meters as distance unit, real world rolloff, real doppler effect	BASS_Set3DFactors(1,1,1);	// initialize GUI	glade=glade_xml_new(GLADE_PATH"3dtest.glade",NULL,NULL);	if (!glade) return 0;	win=GetWidget("window1");	if (!win) return 0;	glade_xml_signal_autoconnect(glade);	g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(GetWidget("channels"))),"changed",G_CALLBACK(ListSelectionChange),NULL);	{ // setup list		GtkTreeView *list=GTK_TREE_VIEW(GetWidget("channels"));		GtkTreeViewColumn *col=gtk_tree_view_column_new();		gtk_tree_view_append_column(list,col);		GtkCellRenderer *renderer = gtk_cell_renderer_text_new();		gtk_tree_view_column_pack_start(col,renderer,TRUE);		gtk_tree_view_column_add_attribute(col, renderer, "text", 0);		GtkListStore *liststore=gtk_list_store_new(1,G_TYPE_STRING);		gtk_tree_view_set_model(list,GTK_TREE_MODEL(liststore));		g_object_unref(liststore);	}	{ // initialize file selector		GtkFileFilter *filter;		filesel=gtk_file_chooser_dialog_new("Open File",GTK_WINDOW(win),GTK_FILE_CHOOSER_ACTION_OPEN,			GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,GTK_STOCK_OPEN,GTK_RESPONSE_ACCEPT,NULL);		filter=gtk_file_filter_new();		gtk_file_filter_set_name(filter,"Streamable files (wav/aif/mp3/mp2/mp1/ogg)");		regcomp(&fregex[0],"//.(mp[1-3]|ogg|wav|aif)$",REG_ICASE|REG_NOSUB|REG_EXTENDED);		gtk_file_filter_add_custom(filter,GTK_FILE_FILTER_FILENAME,FileExtensionFilter,&fregex[0],NULL);		gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter);		filter=gtk_file_filter_new();		gtk_file_filter_set_name(filter,"MOD music files (mo3/xm/mod/s3m/it/mtm/umx)");		regcomp(&fregex[1],"//.(mo3|xm|mod|s3m|it|umx)$",REG_ICASE|REG_NOSUB|REG_EXTENDED);		gtk_file_filter_add_custom(filter,GTK_FILE_FILTER_FILENAME,FileExtensionFilter,&fregex[1],NULL);		gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter);		filter=gtk_file_filter_new();		gtk_file_filter_set_name(filter,"All files");		gtk_file_filter_add_pattern(filter,"*");		gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter);	}	g_timeout_add(TIMERPERIOD,Update,NULL);	UpdateButtons();	gtk_main();	gtk_widget_destroy(filesel);	regfree(&fregex[0]);	regfree(&fregex[1]);	BASS_Free(); // close output    return 0;}

/** * Handle menu click File/Open * * This is either with or without diagram */voidfile_open_callback(GtkAction *action){  if (!opendlg) {    DDisplay *ddisp;    Diagram *dia = NULL;    GtkWindow *parent_window;    gchar *filename = NULL;        /* FIXME: we should not use ddisp_active but instead get the current diagram     * from caller. Thus we could offer the option to "load into" if invoked by     * <Display/File/Open. It wouldn't make any sense if invoked by      * <Toolbox>/File/Open ...     */    ddisp = ddisplay_active();    if (ddisp) {      dia = ddisp->diagram;      parent_window = GTK_WINDOW(ddisp->shell);    } else {      parent_window = GTK_WINDOW(interface_get_toolbox_shell());    }    persistence_register_integer ("import-filter", 0);    opendlg = gtk_file_chooser_dialog_new(_("Open Diagram"), parent_window,					  GTK_FILE_CHOOSER_ACTION_OPEN,					  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,					  GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,					  NULL);    /* is activating gvfs really that easy - at least it works for samba shares*/    gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(opendlg), FALSE);    gtk_dialog_set_default_response(GTK_DIALOG(opendlg), GTK_RESPONSE_ACCEPT);    gtk_window_set_role(GTK_WINDOW(opendlg), "open_diagram");    if (dia && dia->filename)      filename = g_filename_from_utf8(dia->filename, -1, NULL, NULL, NULL);    if (filename != NULL) {      char* fnabs = dia_get_absolute_filename (filename);      if (fnabs)        gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(opendlg), fnabs);      g_free(fnabs);      g_free(filename);    }    g_signal_connect(G_OBJECT(opendlg), "destroy",		     G_CALLBACK(gtk_widget_destroyed), &opendlg);  } else {    gtk_widget_set_sensitive(opendlg, TRUE);#if GTK_CHECK_VERSION(2,20,0)    if (gtk_widget_get_visible(opendlg))#else    if (GTK_WIDGET_VISIBLE(opendlg))#endif      return;  }  if (!gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(opendlg))) {    GtkWidget *hbox, *label, *omenu, *options;    GtkFileFilter* filter;    options = gtk_frame_new(_("Open Options"));    gtk_frame_set_shadow_type(GTK_FRAME(options), GTK_SHADOW_ETCHED_IN);    hbox = gtk_hbox_new(FALSE, 1);    gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);    gtk_container_add(GTK_CONTAINER(options), hbox);    gtk_widget_show(hbox);    label = gtk_label_new (_("Determine file type:"));    gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);    gtk_widget_show (label);    omenu = create_open_menu();    gtk_box_pack_start(GTK_BOX(hbox), omenu, TRUE, TRUE, 0);    gtk_widget_show(omenu);    gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(opendlg),				      options);    gtk_widget_show(options);    g_signal_connect(G_OBJECT(opendlg), "response",		     G_CALLBACK(file_open_response_callback), omenu);    /* set up the gtk file (name) filters */    /* 0 = by extension */    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (opendlg), 	                         build_gtk_file_filter_from_index (0));    filter = gtk_file_filter_new ();    gtk_file_filter_set_name (filter, _("All Files"));    gtk_file_filter_add_pattern (filter, "*");    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (opendlg), filter);    gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), persistence_get_integer ("import-filter"));  }  gtk_widget_show(opendlg);}

nsresultHeaderSniffer::PerformSave (const GulCString &defaultFileName){	EmbedPersistFlags flags;	PRBool askDownloadDest;	flags = galeon_embed_persist_get_flags (mEmbedPersist);	askDownloadDest = (flags & EMBED_PERSIST_ASK_DESTINATION) ||		              eel_gconf_get_boolean (CONF_DOWNLOADING_ASK_DIR);			/* Validate the file name to ensure legality. */	char *default_name = g_strdup (defaultFileName.get());	default_name = g_strdelimit (default_name, ":/", ' ');        char *filename;        filename = gnome_vfs_unescape_string (default_name, NULL);        if (!g_utf8_validate (filename, -1, NULL))        {                g_free (filename);                filename = g_strdup (default_name);        }	g_free (default_name);	GtkWidget *parent;	parent = galeon_embed_persist_get_fc_parent (mEmbedPersist);	if (!askDownloadDest)	{		nsCOMPtr<nsILocalFile> destFile;		nsresult rv = BuildDownloadPath (filename, parent,						  getter_AddRefs (destFile));		if (NS_SUCCEEDED (rv))		{			g_free (filename);			return InitiateDownload (destFile);		}	}	GulFileChooser *dialog;	const char *title;	title = galeon_embed_persist_get_fc_title (mEmbedPersist);	dialog = gul_file_chooser_new (title ? title: _("Save"),				       GTK_WIDGET (parent),				       GTK_FILE_CHOOSER_ACTION_SAVE,				       CONF_STATE_LAST_DOWNLOAD_DIR);	if (mDocument && (flags & EMBED_PERSIST_SAVE_CONTENT))	{		/* Reset the flags to turn off content, the user toggles		 * if they want to turn it on */		GtkWidget *toggle;                int f = flags & ~EMBED_PERSIST_SAVE_CONTENT;                flags = (EmbedPersistFlags) f;		galeon_embed_persist_set_flags (mEmbedPersist, flags);		toggle = gtk_check_button_new_with_mnemonic (_("Save _with content"));		gtk_widget_show (toggle);		gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), toggle);		g_signal_connect (toggle, "toggled",				  G_CALLBACK (content_toggled_cb), mEmbedPersist);	}	gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog),					   filename);		NS_ADDREF (this); /* add a ref to this object, so it doesn't dissappear */	g_signal_connect (dialog, "response",			  G_CALLBACK (filechooser_response_cb), this);	guint32 user_time;	g_object_get (mEmbedPersist, "user_time", &user_time, NULL);	if (!user_time)	{		g_warning ("No user time specified in embed persist for file save" );	}	gul_x11_window_update_user_time (GTK_WIDGET (dialog), user_time);	gtk_widget_show (GTK_WIDGET (dialog));		g_free (filename);	return NS_OK;}

static GtkWidget *file_save_as_dialog_prepare (Diagram *dia, DDisplay *ddisp){  gchar *filename = NULL;  if (!savedlg) {    GtkWidget *compressbutton;    savedlg = gtk_file_chooser_dialog_new(_("Save Diagram"),					  GTK_WINDOW(ddisp->shell),					  GTK_FILE_CHOOSER_ACTION_SAVE,					  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,					  GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,					  NULL);    /* vfs saving is as easy - if you see 'bad file descriptor' there is     * something wrong with the permissions of the share ;) */    gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(savedlg), FALSE);    gtk_dialog_set_default_response(GTK_DIALOG(savedlg), GTK_RESPONSE_ACCEPT);    gtk_window_set_role(GTK_WINDOW(savedlg), "save_diagram");    /* Need better way to make it a reasonable size.  Isn't there some*/    /* standard look for them (or is that just Gnome?)*/    compressbutton = gtk_check_button_new_with_label(_("Compress diagram files"));    gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(savedlg),				      compressbutton);    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compressbutton),				 dia->data->is_compressed);    g_signal_connect(G_OBJECT(compressbutton), "toggled",		     G_CALLBACK(toggle_compress_callback), NULL);    gtk_widget_show(compressbutton);    gtk_widget_set_tooltip_text (compressbutton,			 _("Compression reduces file size to less than 1/10th "			   "size and speeds up loading and saving.  Some text "			   "programs cannot manipulate compressed files."));    g_signal_connect (GTK_FILE_CHOOSER(savedlg),		      "response", G_CALLBACK(file_save_as_response_callback), compressbutton);    g_signal_connect(G_OBJECT(savedlg), "destroy",		     G_CALLBACK(gtk_widget_destroyed), &savedlg);  } else {    GtkWidget *compressbutton = gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(savedlg));    gtk_widget_set_sensitive(savedlg, TRUE);    g_signal_handlers_block_by_func(G_OBJECT(compressbutton), toggle_compress_callback, NULL);    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compressbutton),				 dia->data->is_compressed);    g_signal_handlers_unblock_by_func(G_OBJECT(compressbutton), toggle_compress_callback, NULL);    if (g_object_get_data (G_OBJECT (savedlg), "user_data") != NULL)      g_object_unref (g_object_get_data (G_OBJECT (savedlg), "user_data"));#if GTK_CHECK_VERSION(2,20,0)    if (gtk_widget_get_visible(savedlg)) {#else    if (GTK_WIDGET_VISIBLE(savedlg)) {#endif      /* keep a refernce to the diagram */      g_object_ref(dia);      g_object_set_data (G_OBJECT (savedlg), "user_data", dia);      gtk_window_present (GTK_WINDOW(savedlg));      return savedlg;    }  }  if (dia && dia->filename)    filename = g_filename_from_utf8(dia->filename, -1, NULL, NULL, NULL);  if (filename != NULL) {    char* fnabs = dia_get_absolute_filename (filename);    if (fnabs) {      gchar *base = g_path_get_basename(dia->filename);      gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(savedlg), fnabs);      /* FileChooser api insist on exiting files for set_filename  */      /* ... and does not use filename encoding on this one. */      gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(savedlg), base);      g_free(base);    }    g_free(fnabs);    g_free(filename);  }  g_object_ref(dia);  g_object_set_data (G_OBJECT (savedlg), "user_data", dia);  return savedlg;}/** * Respond to the File/Save menu entry. * * Delegates to Save As if there is no filename set yet. */voidfile_save_callback(GtkAction *action){  Diagram *diagram;  diagram = ddisplay_active_diagram();  if (!diagram) return;  if (diagram->unsaved) {    file_save_as_callback(action);  } else {    gchar *filename = g_filename_from_utf8(diagram->filename, -1, NULL, NULL, NULL);    DiaContext *ctx = dia_context_new (_("Save"));    diagram_update_extents(diagram);    if (diagram_save(diagram, filename, ctx))//.........这里部分代码省略.........

//.........这里部分代码省略.........		EXIT();		return TRUE;	}	if (!GTK_IS_WIDGET(window))	{		xml = glade_xml_new(main_xml->filename,"table_generator_window",NULL);		window = glade_xml_get_widget(xml,"table_generator_window");		glade_xml_signal_autoconnect(xml);		/* Default to params not a file */		chooser = glade_xml_get_widget(xml,"import_filechooser_button");		register_widget_f("import_filechooser_button",chooser);		item = glade_xml_get_widget(xml,"use_params_rbutton");		register_widget_f("use_params_rbutton",item);		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(item),TRUE);		g_signal_emit_by_name(item,"toggled",NULL);		item = glade_xml_get_widget(xml,"sensor_combo");		gtk_combo_box_set_active(GTK_COMBO_BOX(item),0);		register_widget_f("thermister_sensor_combo",item);		item = glade_xml_get_widget(xml,"temp_label");		register_widget_f("temp_label",item);		if (firmware->capabilities & PIS)			gtk_widget_destroy(glade_xml_get_widget(xml,"bias_resistor_table"));		else		{			item = glade_xml_get_widget(xml,"bias_entry");			register_widget_f("bias_entry",item);			OBJ_SET_FULL(item,"raw_lower",g_strdup("0"),g_free);			OBJ_SET_FULL(item,"raw_upper",g_strdup("100000"),g_free);			OBJ_SET(item,"precision",GINT_TO_POINTER(1));		}		item = glade_xml_get_widget(xml,"temp1_entry");		register_widget_f("temp1_entry",item);		OBJ_SET_FULL(item,"raw_lower",g_strdup("-40"),g_free);		OBJ_SET_FULL(item,"raw_upper",g_strdup("300"),g_free);		OBJ_SET(item,"precision",GINT_TO_POINTER(1));		item = glade_xml_get_widget(xml,"temp2_entry");		register_widget_f("temp2_entry",item);		OBJ_SET_FULL(item,"raw_lower",g_strdup("-40"),g_free);		OBJ_SET_FULL(item,"raw_upper",g_strdup("300"),g_free);		OBJ_SET(item,"precision",GINT_TO_POINTER(1));		item = glade_xml_get_widget(xml,"temp3_entry");		register_widget_f("temp3_entry",item);		OBJ_SET_FULL(item,"raw_lower",g_strdup("-40"),g_free);		OBJ_SET_FULL(item,"raw_upper",g_strdup("300"),g_free);		OBJ_SET(item,"precision",GINT_TO_POINTER(1));		item = glade_xml_get_widget(xml,"resistance1_entry");		register_widget_f("resistance1_entry",item);		OBJ_SET_FULL(item,"raw_lower",g_strdup("0"),g_free);		OBJ_SET_FULL(item,"raw_upper",g_strdup("500000"),g_free);		OBJ_SET(item,"precision",GINT_TO_POINTER(1));		item = glade_xml_get_widget(xml,"resistance2_entry");		register_widget_f("resistance2_entry",item);		OBJ_SET_FULL(item,"raw_lower",g_strdup("0"),g_free);		OBJ_SET_FULL(item,"raw_upper",g_strdup("500000"),g_free);		OBJ_SET(item,"precision",GINT_TO_POINTER(1));		item = glade_xml_get_widget(xml,"resistance3_entry");		register_widget_f("resistance3_entry",item);		OBJ_SET_FULL(item,"raw_lower",g_strdup("0"),g_free);		OBJ_SET_FULL(item,"raw_upper",g_strdup("500000"),g_free);		OBJ_SET(item,"precision",GINT_TO_POINTER(1));		item = glade_xml_get_widget(xml,"celsius_rbutton");		OBJ_SET_FULL(item,"temp_label",g_strdup("Temperature(/302/260 C)"),g_free);		register_widget_f("thermister_celsius_rbutton",item);		item = glade_xml_get_widget(xml,"fahrenheit_rbutton");		OBJ_SET_FULL(item,"temp_label",g_strdup("Temperature(/302/260 F)"),g_free);		register_widget_f("thermister_fahrenheit_rbutton",item);		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(item),TRUE);		g_signal_emit_by_name(item,"toggled",NULL);		item = glade_xml_get_widget(xml,"kelvin_rbutton");		OBJ_SET_FULL(item,"temp_label",g_strdup("Temperature(/302/260 K)"),g_free);		register_widget_f("thermister_kelvin_rbutton",item);		gtk_window_set_transient_for(GTK_WINDOW(window),GTK_WINDOW(lookup_widget_f("main_window")));		gtk_widget_show(GTK_WIDGET(window));		EXIT();		return TRUE;	}#if GTK_MINOR_VERSION >= 18	if (gtk_widget_get_visible(GTK_WIDGET(window)))#else		if (GTK_WIDGET_VISIBLE(GTK_WIDGET(window)))#endif			gtk_widget_hide(GTK_WIDGET(window));		else		{			gtk_file_chooser_unselect_all(GTK_FILE_CHOOSER(chooser));			gtk_widget_show(GTK_WIDGET(window));		}	EXIT();	return TRUE;}

/** * React to <Display>/File/Export */voidfile_export_callback(GtkAction *action){  DDisplay *ddisp;  Diagram *dia;  gchar *filename = NULL;  ddisp = ddisplay_active();  if (!ddisp) return;  dia = ddisp->diagram;  if (!confirm_export_size (dia, GTK_WINDOW(ddisp->shell), CONFIRM_MEMORY|CONFIRM_PAGES))    return;  if (!exportdlg) {    persistence_register_integer ("export-filter", 0);    exportdlg = gtk_file_chooser_dialog_new(_("Export Diagram"),					    GTK_WINDOW(ddisp->shell),					    GTK_FILE_CHOOSER_ACTION_SAVE,					    GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,					    GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,					    NULL);    /* export via vfs gives: Permission denied - but only if you do not     * have write permissions ;) */    gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(exportdlg), FALSE);    gtk_dialog_set_default_response(GTK_DIALOG(exportdlg), GTK_RESPONSE_ACCEPT);    gtk_window_set_role(GTK_WINDOW(exportdlg), "export_diagram");    g_signal_connect(G_OBJECT(exportdlg), "destroy",		     G_CALLBACK(gtk_widget_destroyed), &exportdlg);  }  if (!gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(exportdlg))) {    GtkWidget *hbox, *label, *omenu, *options;    GtkFileFilter* filter;    options = gtk_frame_new(_("Export Options"));    gtk_frame_set_shadow_type(GTK_FRAME(options), GTK_SHADOW_ETCHED_IN);    hbox = gtk_hbox_new(FALSE, 1);    gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);    gtk_container_add(GTK_CONTAINER(options), hbox);    gtk_widget_show(hbox);    label = gtk_label_new (_("Determine file type:"));    gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);    gtk_widget_show (label);    omenu = create_export_menu();    gtk_box_pack_start(GTK_BOX(hbox), omenu, TRUE, TRUE, 0);    gtk_widget_show(omenu);    g_object_set_data(G_OBJECT(exportdlg), "export-menu", omenu);    gtk_widget_show(options);    gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(exportdlg), options);    /* set up file filters */    filter = gtk_file_filter_new ();    gtk_file_filter_set_name (filter, _("All Files"));    gtk_file_filter_add_pattern (filter, "*");    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (exportdlg), filter);    /* match the other selections extension */    filter = gtk_file_filter_new ();    gtk_file_filter_set_name (filter, _("Supported Formats"));    gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_FILENAME,                                matching_extensions_filter, filter_guess_export_filter, NULL);    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (exportdlg), filter);    gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), persistence_get_integer ("export-filter"));    g_signal_connect(GTK_FILE_CHOOSER(exportdlg),		     "response", G_CALLBACK(file_export_response_callback), omenu);  }  if (g_object_get_data (G_OBJECT(exportdlg), "user_data"))    g_object_unref (g_object_get_data (G_OBJECT(exportdlg), "user_data"));  g_object_ref(dia);   g_object_set_data (G_OBJECT (exportdlg), "user_data", dia);  gtk_widget_set_sensitive(exportdlg, TRUE);  if (dia && dia->filename)    filename = g_filename_from_utf8(dia->filename, -1, NULL, NULL, NULL);  if (filename != NULL) {    char* fnabs = dia_get_absolute_filename (filename);    if (fnabs) {      char *folder = g_path_get_dirname (fnabs);      char *basename = g_path_get_basename (fnabs);      /* can't use gtk_file_chooser_set_filename for various reasons, see e.g. bug #305850 */      gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(exportdlg), folder);      export_adapt_extension (basename, persistence_get_integer ("export-filter") - 1);      g_free (folder);      g_free (basename);    }    g_free(fnabs);    g_free(filename);  }  gtk_widget_show(exportdlg);}

FileDialog::FileDialog(wxWindow *parent, const wxString& message,                       const wxString& defaultDir,                       const wxString& defaultFileName,                       const wxString& wildCard,                       long style, const wxPoint& pos): wxGenericFileDialog(parent, message, defaultDir, defaultFileName,                      wildCard, style, pos, #if wxCHECK_VERSION(2,8,0)                      wxDefaultSize,                      wxFileDialogNameStr,#endif                      true ){#if defined(__WXGTK24__) && (!defined(__WXGPE__))   if (!gtk_check_version(2,4,0))   {      wxASSERT_MSG( !( (style & wxFD_SAVE) && (style & wxFD_MULTIPLE) ), wxT("FileDialog - wxFD_MULTIPLE used on a save dialog" ) );      m_needParent = false;      m_destroyed_by_delete = false;            if (!PreCreation(parent, pos, wxDefaultSize) ||          !CreateBase(parent, wxID_ANY, pos, wxDefaultSize, style,                      wxDefaultValidator, wxT("filedialog")))      {         wxFAIL_MSG( wxT("FileDialog creation failed") );         return;      }            GtkFileChooserAction gtk_action;      GtkWindow* gtk_parent = NULL;      if (parent)         gtk_parent = GTK_WINDOW( gtk_widget_get_toplevel(parent->m_widget) );            const gchar* ok_btn_stock;      if ( style & wxFD_SAVE )      {         gtk_action = GTK_FILE_CHOOSER_ACTION_SAVE;         ok_btn_stock = GTK_STOCK_SAVE;      }      else      {         gtk_action = GTK_FILE_CHOOSER_ACTION_OPEN;         ok_btn_stock = GTK_STOCK_OPEN;      }            m_widget = gtk_file_chooser_dialog_new(                                             wxGTK_CONV(m_message),                                             gtk_parent,                                             gtk_action,                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,                                             ok_btn_stock, GTK_RESPONSE_ACCEPT,                                             NULL);            // Allow pressing "Enter" key for default action      gtk_dialog_set_default_response(GTK_DIALOG(m_widget), GTK_RESPONSE_ACCEPT);            if ( style & wxFD_MULTIPLE )         gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(m_widget), true);            // local-only property could be set to false to allow non-local files to be loaded.      // In that case get/set_uri(s) should be used instead of get/set_filename(s) everywhere      // and the GtkFileChooserDialog should probably also be created with a backend,      // e.g "gnome-vfs", "default", ... (gtk_file_chooser_dialog_new_with_backend).      // Currently local-only is kept as the default - true:      // gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(m_widget), true);            g_signal_connect(G_OBJECT(m_widget), "response",                       GTK_SIGNAL_FUNC(gtk_filedialog_response_callback), (gpointer)this);      g_signal_connect(G_OBJECT(m_widget), "show",                       GTK_SIGNAL_FUNC(gtk_filedialog_show_callback), (gpointer)this);            SetWildcard(wildCard);            if ( style & wxFD_SAVE )      {         if ( !defaultDir.empty() )            gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(m_widget),                                                wxConvFileName->cWX2MB(defaultDir));                  gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(m_widget),                                           wxConvFileName->cWX2MB(defaultFileName));         #if GTK_CHECK_VERSION(2,7,3)         if (!gtk_check_version(2,7,3))            gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(m_widget), FALSE);#endif      }      else      {         if ( !defaultFileName.empty() )         {            wxString dir;            if ( defaultDir.empty() )               dir = ::wxGetCwd();            else               dir = defaultDir;                        gtk_file_chooser_set_filename(                                          GTK_FILE_CHOOSER(m_widget),                                          wxConvFileName->cWX2MB( wxFileName(dir, defaultFileName).GetFullPath() ) );//.........这里部分代码省略.........

voidgradients_save_as_pov_ray_cmd_callback (GtkAction *action,                                        gpointer   data){  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);  GimpContext         *context;  GimpGradient        *gradient;  GtkFileChooser      *chooser;  gchar               *title;  context = gimp_container_view_get_context (editor->view);  gradient = gimp_context_get_gradient (context);  if (! gradient)    return;  title = g_strdup_printf (_("Save '%s' as POV-Ray"),                           gimp_object_get_name (gradient));  chooser = GTK_FILE_CHOOSER    (gtk_file_chooser_dialog_new (title, NULL,                                  GTK_FILE_CHOOSER_ACTION_SAVE,                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,                                  GTK_STOCK_SAVE,   GTK_RESPONSE_OK,                                  NULL));  gtk_dialog_set_alternative_button_order (GTK_DIALOG (chooser),                                           GTK_RESPONSE_OK,                                           GTK_RESPONSE_CANCEL,                                           -1);  g_object_set_data (G_OBJECT (chooser), "gimp", context->gimp);  g_free (title);  gtk_window_set_screen (GTK_WINDOW (chooser),                         gtk_widget_get_screen (GTK_WIDGET (editor)));  gtk_window_set_role (GTK_WINDOW (chooser), "gimp-gradient-save-pov");  gtk_window_set_position (GTK_WINDOW (chooser), GTK_WIN_POS_MOUSE);  gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_OK);  gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);  g_signal_connect (chooser, "response",                    G_CALLBACK (gradients_save_as_pov_ray_response),                    gradient);  g_signal_connect (chooser, "delete-event",                    G_CALLBACK (gtk_true),                    NULL);  g_object_ref (gradient);  g_signal_connect_object (chooser, "destroy",                           G_CALLBACK (g_object_unref),                           gradient,                           G_CONNECT_SWAPPED);  gimp_help_connect (GTK_WIDGET (chooser), gimp_standard_help_func,                     GIMP_HELP_GRADIENT_SAVE_AS_POV, NULL);  gtk_widget_show (GTK_WIDGET (chooser));}

/** * Print the file selected by a file chooser dialog. * @param dialog file chooser dialog to print information about */void mk_print_GtkFileChooserDialog_info(GtkFileChooserDialog* dialog){    mk_print_GtkFileChooser_info(GTK_FILE_CHOOSER(dialog));}