void save_file_as_cb( GtkWidget *widget, AnypaperWindow *window )
{
GtkWidget *dialog, *dialog_error;
GtkFileFilter *filterImages, *filterAll;
dialog = gtk_file_chooser_dialog_new ("Save as...",
GTK_WINDOW(window->priv->window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
filterImages = gtk_file_filter_new ();
gtk_file_filter_set_name (GTK_FILE_FILTER(filterImages),"JPEG images");
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filterImages), "image/jpeg/*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filterImages);
filterAll = gtk_file_filter_new ();
gtk_file_filter_set_name (GTK_FILE_FILTER(filterAll),"All files");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(filterAll), "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filterAll);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), FALSE);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), g_path_get_dirname (gtk_entry_get_text (GTK_ENTRY (window->priv->file_entry))));
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), "Untitled image.png");
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
char *filename, *down_filename;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
down_filename = g_ascii_strdown (filename, -1);
if ((g_str_has_suffix (down_filename, ".jpg")) || (g_str_has_suffix (down_filename, ".jpeg"))) gdk_pixbuf_save (window->image->image, filename, "jpeg", NULL, "quality", "100", NULL);
else if(g_str_has_suffix (down_filename, ".png")) gdk_pixbuf_save (window->image->image, filename, "png", NULL, NULL);
else
{
dialog_error = gtk_message_dialog_new (GTK_WINDOW (window->priv->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Invalid format");
gtk_window_set_title (GTK_WINDOW (dialog_error), "Error");
g_signal_connect_swapped (dialog_error, "response", G_CALLBACK (gtk_widget_destroy), dialog_error);
gtk_widget_show(dialog_error);
}
g_free (filename);
g_free (down_filename);
}
gtk_widget_destroy (dialog);
}
void termit_on_save_session()
{
/* // debug
termit_save_session("tmpSess");
return;
*/
gchar* fullPath = termit_get_xdg_data_path();
GtkWidget* dlg = gtk_file_chooser_dialog_new(
_("Save session"),
GTK_WINDOW(termit.main_window),
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(dlg), TRUE);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dlg), fullPath);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dlg), "New session");
if (gtk_dialog_run(GTK_DIALOG(dlg)) != GTK_RESPONSE_ACCEPT) {
gtk_widget_destroy(dlg);
g_free(fullPath);
return;
}
gchar* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dlg));
termit_save_session(filename);
g_free(filename);
gtk_widget_destroy(dlg);
g_free(fullPath);
}
void OnEnregSous(GtkWidget* widget, gpointer data) {
(void) widget;
(void) data;
if (cur_image == NULL) {
fprintf(stderr, "OnEnregSous: Given image is NULL.\n");
return;
}
GtkFileFilter *pgm_filter = gtk_file_filter_new();
gtk_file_filter_set_name(pgm_filter, "*.pgm");
gtk_file_filter_add_pattern(pgm_filter, "*.pgm");
GtkWidget *dialog = gtk_file_chooser_dialog_new("Enregistrer Sous",
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);
//gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), default_folder_for_saving);
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), "SansNom");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), pgm_filter);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
char *nom_fichier = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
sauver_image_pgm(nom_fichier, cur_image);
cur_image->path= my_strdup(nom_fichier);
g_free (nom_fichier);
}
gtk_widget_destroy (dialog);
}
/*
Sauvegarde d'un grille
@params p_widget Elément ayant déclencher la fonction
@params user_data Données transmis au callback
*/
void cb_save_file(GtkWidget *p_widget, gpointer user_data){
GtkWidget *p_dialog_save;
p_dialog_save = gtk_file_chooser_dialog_new ("Enregistrer un fichier",
GTK_WINDOW(widgetCallback.entry1),
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(p_dialog_save), TRUE);
if (gtk_dialog_run(GTK_DIALOG(p_dialog_save)) == GTK_RESPONSE_ACCEPT){ //Nom du fichier a été choisi
char *filename;
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(p_dialog_save));
int grid[9][9] = {{0}};
int grid_fixes[9][9] = {{0}};
//On récupère la grille
get_grid(grid);
get_fixed_grid(grid_fixes);
save_grid_in_file(grid, grid_fixes, filename); //On sauvegarde
}
gtk_widget_destroy(p_dialog_save);
//Parametres inutilises
(void)p_widget;
}
void save_as_dialog(){
char *pth = NULL, *nam = NULL;
dialog = gtk_file_chooser_dialog_new ("Сохранить пазл как",
(GtkWindow *)window,
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);
if(last_opened_file){
pth = get_file_path_name(last_opened_file, TRUE);
nam = get_file_path_name(last_opened_file, FALSE);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), pth);
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), nam);
}
else
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog),
NEW_FILE_NAME);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT){
if(last_opened_file) free(last_opened_file);
last_opened_file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
}
gtk_widget_destroy (dialog);
if(pth) free(pth); if(nam) free(nam);
}
static gchar *file_dlg(lua_State* L, gboolean save, const gchar *path, const gchar *mask, const gchar *name)
{
gchar *rv=NULL;
gchar *fullname = NULL;
GtkWidget*dlg=NULL;
#if NEED_OVERWRITE_PROMPT
gboolean accepted=FALSE;
#endif
gint resp=GTK_RESPONSE_CANCEL;
if (save) {
dlg=gtk_file_chooser_dialog_new(_("Save file"),
GTK_WINDOW(main_widgets->window), GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
#if NEED_OVERWRITE_PROMPT
gtk_signal_connect(GTK_OBJECT(dlg),"response",G_CALLBACK(on_file_dlg_response),&accepted);
#else
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dlg), TRUE);
#endif
} else {
dlg=gtk_file_chooser_dialog_new(_("Open file"),
GTK_WINDOW(main_widgets->window), GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
}
if (name && *name) {
if (g_path_is_absolute(name)) {
fullname=g_strdup(name);
} else if (path) {fullname=g_build_filename(path,name,NULL);}
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dlg), fullname);
if (save) gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dlg), name);
}
if (path && *path) {
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dlg), path);
}
if (!create_file_filter(L, GTK_FILE_CHOOSER(dlg), mask)) {
lua_pushfstring(L, _("Error in module \"%s\" at function pickfile():\n"
"failed to parse filter string at argument #3.\n"),
LUA_MODULE_NAME);
lua_error(L);
return NULL;
}
#if NEED_OVERWRITE_PROMPT
glspi_pause_timer(TRUE,L);
while (!accepted) {
resp=gtk_dialog_run(GTK_DIALOG(dlg));
if (!save) { accepted=TRUE; }
}
glspi_pause_timer(FALSE,L);
#else
resp=glspi_dialog_run(GTK_DIALOG(dlg));
#endif
if (resp == GTK_RESPONSE_ACCEPT) {
rv=gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dlg));
}
gtk_widget_destroy(dlg);
if (fullname) {g_free(fullname);}
return rv;
}
char* _gui_file_choose(int type) {
/*
* create a file choose dialog according to param `type`
*
* */
GtkWidget *dialog = NULL;
GtkFileChooser *chooser = NULL;
if(type == FILE_CHOOSE_OPEN) {
dialog = gtk_file_chooser_dialog_new(
"打开", NULL, GTK_FILE_CHOOSER_ACTION_OPEN,
"取消", GTK_RESPONSE_CANCEL,
"确定", GTK_RESPONSE_ACCEPT, NULL);
} else if(type == FILE_CHOOSE_SAVE) {
dialog = gtk_file_chooser_dialog_new(
"保存", NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
"取消", GTK_RESPONSE_CANCEL,
"确定", GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
}
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
gtk_widget_destroy(dialog);
return filename;
} else {
gtk_widget_destroy(dialog);
return NULL;
}
}
static void gtk_savethread(void *args) {
MSG_FILE *file = args;
//WHY?!
uint16_t fid = file->progress;
file->progress = 0;
//WHY?!
while(1){ //TODO, save current dir, and filename and preload them to gtk dialog if save fails.
/* Create a GTK save window */
void *dialog = gtk_file_chooser_dialog_new((const char *)S(WHERE_TO_SAVE_FILE), NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
"_Cancel", GTK_RESPONSE_CANCEL,
"_Open", GTK_RESPONSE_ACCEPT,
NULL);
/* Get incoming file name*/
char buf[sizeof(file->name) + 1];
memcpy(buf, file->name, file->name_length);
buf[file->name_length] = 0;
/* give gtk the file name our friend is sending. */
gtk_file_chooser_set_current_name(dialog, buf);
/* Prompt to overwrite */
gtk_file_chooser_set_do_overwrite_confirmation(dialog, true);
/* Users can create folders when saving. */ //TODO ENABLE BELOW!
//gtk_file_chooser_set_create_folders(dialog, TRUE);
int result = gtk_dialog_run(dialog);
/* If user is ready to save check then pass to utox. */
if(result == GTK_RESPONSE_ACCEPT) {
char *name = gtk_file_chooser_get_filename(dialog);
char *path = strdup(name);
//g_free_utox(name)
debug("name: %s\npath: %s\n", name, path);
/* can we really write this file? */
FILE *fp = fopen(path, "w");
if(fp == NULL){
/* No, we can't display error, jump to top. */
if(errno == EACCES){
debug("File write permission denied.\n");
void *errordialog = gtk_message_dialog_new(dialog, 1, 3, 2,
//parent, destroy_with_parent, gtk_error_message, gtk_buttons_close
"Error writing to file '%s'", name);
gtk_dialog_run(errordialog);
gtk_widget_destroy(errordialog);
gtk_widget_destroy(dialog);
continue;
} else {
debug("Unknown file write error...\n");
}
} else {
fclose(fp);
/* write test passed, we're done! */
gtk_widget_destroy(dialog);
gtk_main_iteration();
gtk_widget_destroy(dialog);
postmessage(FILE_INCOMING_ACCEPT, fid, (file->filenumber >> 16), path);
break;
}
} else if (result == GTK_RESPONSE_CANCEL) {
/* Game -> Save as activated */
void save_file_dialog(GtkMenuItem *item, gpointer user_data)
{
GtkWidget *dialog;
halt_ai_thread();
dialog = gtk_file_chooser_dialog_new("Save File",
GTK_WINDOW(window),
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);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
char *filename;
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
save_moves_list(filename);
g_free(filename);
}
gtk_widget_destroy(dialog);
start_ai_thread();
}
void
ui_signal_export (GtkMenuItem * item, gpointer data)
{
GtkWidget *dialog;
GtkWidget *window = GET_OBJECT("window");
GtkFileFilter * filter_auto;
GtkFileFilter * filter_pdf;
GtkFileFilter * filter_svg;
GtkFileFilter * filter_png;
dialog = gtk_file_chooser_dialog_new (_("Export"),
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
/* Set filters */
filter_auto = gtk_file_filter_new();
filter_pdf = gtk_file_filter_new();
filter_svg = gtk_file_filter_new();
filter_png = gtk_file_filter_new();
gtk_file_filter_add_pattern (filter_auto, "*");
gtk_file_filter_add_mime_type (filter_pdf, "application/pdf");
gtk_file_filter_add_mime_type (filter_svg, "image/svg+xml");
gtk_file_filter_add_mime_type (filter_png, "image/png");
gtk_file_filter_set_name (filter_pdf, "Portable Document Format (PDF)");
gtk_file_filter_set_name (filter_svg, "Scalable Vector Graphcis (SVG)");
gtk_file_filter_set_name (filter_png, "Portable Networks Graphcis (PNG)");
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_png);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_pdf);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_svg);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
char *filename;
char * ext;
gint width, height;
GtkFileFilter * filter;
gboolean successp;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog));
gdk_window_get_size (hexboard->window, &width, &height);
if (filter == filter_pdf)
ext = "pdf";
else if (filter == filter_png)
ext = "png";
else if (filter == filter_svg)
ext = "svg";
successp = hexboard_save_as_image (HEXBOARD(hexboard), filename, ext, width, height);
if (!successp)
g_message (_("An error ocurred while export the board."));
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Board was exported to %s."), filename);
g_free (filename);
}
gtk_widget_destroy (dialog);
}
void GtkFileChooserDialog_::set_do_overwrite_confirmation(Php::Parameters ¶meters)
{
gboolean select_multiple = (gboolean)parameters[0];
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER(instance), select_multiple);
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1set_1do_1overwrite_1confirmation
(
JNIEnv* env,
jclass cls,
jlong _self,
jboolean _doOverwriteConfirmation
)
{
GtkFileChooser* self;
gboolean doOverwriteConfirmation;
// convert parameter self
self = (GtkFileChooser*) _self;
// convert parameter doOverwriteConfirmation
doOverwriteConfirmation = (gboolean) _doOverwriteConfirmation;
// call function
gtk_file_chooser_set_do_overwrite_confirmation(self, doOverwriteConfirmation);
// cleanup parameter self
// cleanup parameter doOverwriteConfirmation
}
void GtkToolkitFileChooser::SetDialogType(DialogType type)
{
m_action = GTK_FILE_CHOOSER_ACTION_OPEN;
const gchar* accept_text = 0;
switch (type)
{
case FILE_OPEN_MULTI:
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(m_dialog), TRUE);
/* Fallthrough */
case FILE_OPEN:
m_action = GTK_FILE_CHOOSER_ACTION_OPEN;
accept_text = GTK_STOCK_OPEN;
break;
case FILE_SAVE_PROMPT_OVERWRITE:
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(m_dialog), TRUE);
/* Fallthrough */
case FILE_SAVE:
m_action = GTK_FILE_CHOOSER_ACTION_SAVE;
accept_text = GTK_STOCK_SAVE;
break;
case DIRECTORY:
m_action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
accept_text = GTK_STOCK_OPEN;
break;
}
gtk_file_chooser_set_action(GTK_FILE_CHOOSER(m_dialog), m_action);
gtk_dialog_add_button(GTK_DIALOG(m_dialog), accept_text, GTK_RESPONSE_ACCEPT);
}
static void
script_fu_console_save_dialog (ConsoleInterface *console)
{
if (! console->save_dialog)
{
console->save_dialog =
gtk_file_chooser_dialog_new (_("Save Script-Fu Console Output"),
GTK_WINDOW (console->dialog),
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (console->save_dialog),
GTK_RESPONSE_OK);
gimp_dialog_set_alternative_button_order (GTK_DIALOG (console->save_dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (console->save_dialog),
TRUE);
g_object_add_weak_pointer (G_OBJECT (console->save_dialog),
(gpointer) &console->save_dialog);
g_signal_connect (console->save_dialog, "response",
G_CALLBACK (script_fu_console_save_response),
console);
}
gtk_window_present (GTK_WINDOW (console->save_dialog));
}
void ArticleView::on_attachment_button_clicked(GtkWidget *object, gpointer user_data)
{
ResData *pResData = (ResData*)user_data;
const std::string& key = pResData->get_key();
std::string::size_type pos = key.rfind(DB_DIR_SEPARATOR);
// in utf-8, yet a file name
const char* default_file_name = key.c_str() + (pos == std::string::npos ? 0 : pos+1);
GtkWidget *dialog;
dialog = gtk_file_chooser_dialog_new(_("Save File"),
GTK_WINDOW(gpAppFrame->window),
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);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
gpAppFrame->last_selected_directory.c_str());
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), default_file_name);
if(gtk_dialog_run(GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
glib::CharStr filename(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)));
glib::CharStr selected_dir(g_path_get_dirname(get_impl(filename)));
gpAppFrame->last_selected_directory = get_impl(selected_dir);
if(const char* content = pResData->get_content()) {
const guint32 size = get_uint32(content);
const gchar *data = (const gchar *)(content+sizeof(guint32));
if(!g_file_set_contents(get_impl(filename), data, size, NULL))
g_warning("Fail to save file %s", get_impl(filename));
} else {
g_warning("Unable to load resource: %s", pResData->get_key().c_str());
}
}
gtk_widget_destroy(dialog);
}
/* EDITOR: EXPORT LUMP
* ===================
* Saves the pic currently displayed as a PCX file...
*/
gint VID_EditorExportFile(gpointer data)
{
GtkWidget *dialog;
GtkFileChooser *chooser;
GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
gint res;
byte *pic;
if(!ed_file)
return;
dialog = gtk_file_chooser_dialog_new ("NGUNIXEd - Save Picture Exchange (.pcx) File",
NULL,
action,
("_Cancel"),
GTK_RESPONSE_CANCEL,
("_Save"),
GTK_RESPONSE_ACCEPT,
NULL);
chooser = GTK_FILE_CHOOSER (dialog);
gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);
// Set the default path (current directory)
char path[MAX_OSPATH];
sprintf(path, "file://%s", get_current_dir_name());
gtk_file_chooser_set_current_folder_uri(chooser, path);
// Add the filter for .lmp files
GtkFileFilter *filter = gtk_file_filter_new ();
gtk_file_filter_add_pattern (filter, "*.pcx");
gtk_file_chooser_set_filter (chooser, filter);
//if (user_edited_a_new_document)
gtk_file_chooser_set_current_name (chooser,
("untitled.pcx"));
//else
// gtk_file_chooser_set_filename (chooser,
// existing_filename);
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (res == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename (chooser);
Con_Printf("[EDITOR] Exporting PCX to %s...\n", filename);
int w, h;
w = ed_file->width;
h = ed_file->height;
pic = Hunk_Alloc(ed_file->width * ed_file->height);
memcpy(pic, &ed_file->data, (ed_file->width * ed_file->height));
Image_WritePCXfile (filename, pic, w, h, ed_file->width, host_basepal);
g_free (filename);
}
gtk_widget_destroy (dialog);
return 0;
}
void screenshot_dialog(void)
/* Game -> Screenshot activated */
{
GtkWidget *dialog;
halt_ai_thread();
dialog = gtk_file_chooser_dialog_new("Save Screenshot",
GTK_WINDOW(window),
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);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
char *filename;
filename =
gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
draw_screenshot(filename);
g_free(filename);
}
gtk_widget_destroy(dialog);
start_ai_thread();
}
void
ui_signal_save_as (GtkMenuItem * item, gpointer data)
{
GtkWidget *dialog;
GtkWidget *window = GET_OBJECT("window");
dialog = gtk_file_chooser_dialog_new (_("Save"),
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
/* Set filters */
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_sgf);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_lg_sgf);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
g_free (game_file);
game_file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
game_format = dialog_selected_format (dialog);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
if (game_format != HEX_AUTO)
hex_save_sgf (game, game_format, game_file);
update_window_title();
}
gtk_widget_destroy (dialog);
}
static void on_save_button(GtkWidget *button, RendererLaser *self)
{
GtkWidget *dialog;
dialog = gtk_file_chooser_dialog_new("Save Data File", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
g_assert(dialog);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
if (self->last_save_filename)
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), self->last_save_filename);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
char *filename;
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if (NULL != filename) {
FILE *file = fopen(filename, "w");
if (NULL != file) {
/* store selected file into self->last_save_filename */
if (self->last_save_filename)
g_free(self->last_save_filename);
self->last_save_filename = g_strdup(filename);
int count = save_points_to_file(self, file);
DBG("Wrote %d points to file '%s'.\n", count, filename);
fclose(file);
}
else {
ERR("Error: Failed to open file: '%s', error is: '%s'\n",
filename, g_strerror(errno));
}
g_free(filename);
}
}
gtk_widget_destroy(dialog);
}
static char *filedialog(GtkWindow *parent, GtkFileChooserAction mode, const gchar *confirm)
{
GtkWidget *fcd;
GtkFileChooser *fc;
gint response;
char *filename;
fcd = gtk_file_chooser_dialog_new(NULL, parent, mode,
"_Cancel", GTK_RESPONSE_CANCEL,
confirm, GTK_RESPONSE_ACCEPT,
NULL);
fc = GTK_FILE_CHOOSER(fcd);
gtk_file_chooser_set_local_only(fc, FALSE);
gtk_file_chooser_set_select_multiple(fc, FALSE);
gtk_file_chooser_set_show_hidden(fc, TRUE);
gtk_file_chooser_set_do_overwrite_confirmation(fc, TRUE);
gtk_file_chooser_set_create_folders(fc, TRUE);
response = gtk_dialog_run(GTK_DIALOG(fcd));
if (response != GTK_RESPONSE_ACCEPT) {
gtk_widget_destroy(fcd);
return NULL;
}
filename = uiUnixStrdupText(gtk_file_chooser_get_filename(fc));
gtk_widget_destroy(fcd);
return filename;
}
std::string SaveFileDialog()
{
GtkWidget *dialog;
dialog = gtk_file_chooser_dialog_new("Save File",
0,
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);
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), "New DataBase");
std::string path;
if ( gtk_dialog_run( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT ) {
path = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER(dialog) );
}
gtk_widget_destroy(dialog);
path += ".qdb";
return path;
}
/**
* \fn void dialog_draw_save()
* \brief Function to show a dialog to save the graphical view in a PNG file.
*/
void
dialog_draw_save ()
{
char *buffer = NULL;
GtkFileFilter *filter;
GtkFileChooserDialog *dlg;
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, "PNG file");
gtk_file_filter_add_pattern (filter, "*.png");
gtk_file_filter_add_pattern (filter, "*.PNG");
dlg = (GtkFileChooserDialog *) gtk_file_chooser_dialog_new
(gettext ("Save graphical"), dialog_simulator->window,
GTK_FILE_CHOOSER_ACTION_SAVE,
gettext ("_OK"), GTK_RESPONSE_CANCEL,
gettext ("_Cancel"), GTK_RESPONSE_OK, NULL);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), filter);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dlg), 1);
if (gtk_dialog_run ((GtkDialog *) dlg) == GTK_RESPONSE_OK)
buffer = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dlg));
gtk_widget_destroy (GTK_WIDGET (dlg));
if (buffer)
{
draw ();
while (gtk_events_pending ())
gtk_main_iteration ();
draw_save (buffer);
g_free (buffer);
}
}
G_MODULE_EXPORT void on_save_as1_activate (GtkMenuItem *menuitem, gpointer user_data)
{
gchar *filename;
GtkWidget *dialog, *widget;
widget = GTK_WIDGET(gtk_builder_get_object (main_window_gtkb, "main_window"));
dialog = gtk_file_chooser_dialog_new (_("Save CA database as..."),
GTK_WINDOW(widget),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
gtk_widget_destroy (dialog);
} else {
gtk_widget_destroy (dialog);
return;
}
if (ca_file_save_as (filename))
__recent_add_utf8_filename (filename);
}
int32 ShowSaveDialog(ExtensionString title,
ExtensionString initialDirectory,
ExtensionString proposedNewFilename,
ExtensionString& newFilePath)
{
GtkWidget *openSaveDialog;
openSaveDialog = gtk_file_chooser_dialog_new(title.c_str(),
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 (openSaveDialog), TRUE);
if (!initialDirectory.empty())
{
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (openSaveDialog), proposedNewFilename.c_str());
ExtensionString folderURI = std::string("file:///") + initialDirectory;
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (openSaveDialog), folderURI.c_str());
}
if (gtk_dialog_run (GTK_DIALOG (openSaveDialog)) == GTK_RESPONSE_ACCEPT)
{
char* filePath;
filePath = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (openSaveDialog));
newFilePath = filePath;
g_free (filePath);
}
gtk_widget_destroy (openSaveDialog);
return NO_ERROR;
}
/* Finish up the user's Release command by choosing a location to store the
project. This is a callback and the GDK lock is held when entering this
function. */
void
i7_story_save_compiler_output(I7Story *story, const gchar *dialog_title)
{
I7_STORY_USE_PRIVATE(story, priv);
GFile *file = NULL;
if(priv->copy_blorb_dest_file == NULL) {
/* ask the user for a release file name if cBlorb didn't provide one */
/* Create a file chooser */
GtkFileFilter *filter = gtk_file_filter_new();
if(i7_story_get_story_format(story) == I7_STORY_FORMAT_GLULX) {
gtk_file_filter_set_name(filter, _("Glulx games (.ulx,.gblorb)"));
gtk_file_filter_add_pattern(filter, "*.ulx");
gtk_file_filter_add_pattern(filter, "*.gblorb");
} else {
gtk_file_filter_set_name(filter, _("Z-code games (.z?,.zblorb)"));
gtk_file_filter_add_pattern(filter, "*.z?");
gtk_file_filter_add_pattern(filter, "*.zblorb");
}
GtkWidget *dialog = gtk_file_chooser_dialog_new(dialog_title,
GTK_WINDOW(story), 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);
char *curfilename = g_file_get_basename(priv->compiler_output_file);
gchar *title = i7_document_get_display_name(I7_DOCUMENT(story));
char *extension = strrchr(curfilename, '.'); /* not allocated */
char *suggestname;
if(title != NULL) {
*(strrchr(title, '.')) = '\0';
suggestname = g_strconcat(title, extension, NULL);
g_free(title);
} else {
suggestname = g_strconcat("Untitled", extension, NULL);
}
g_free(curfilename);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), suggestname);
g_free(suggestname);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
file = gtk_file_chooser_get_file(GTK_FILE_CHOOSER(dialog));
gtk_widget_destroy(dialog);
} else {
file = g_object_ref(priv->copy_blorb_dest_file);
}
if(file) {
/* Move the finished file to the release location */
GError *err = NULL;
if(!g_file_move(priv->compiler_output_file, file, G_FILE_COPY_OVERWRITE, NULL, NULL, NULL, &err)) {
IO_ERROR_DIALOG(GTK_WINDOW(story), file, err, _("copying compiler output"));
}
g_object_unref(file);
}
}
CMasterBiasDlg::CMasterBiasDlg(GtkWindow *pParent):m_pParent(pParent), m_InFiles(0),
m_FileList(NULL), m_FilePath(NULL)
{
GtkWidget *vbox, *xbox, *bbox;
GSList *group;
GtkFileFilter *filters[2];
// Dialog with buttons
m_pDlg = gtk_file_chooser_dialog_new("Master bias frame", pParent,
GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL);
gtk_file_chooser_standard_tooltips(GTK_FILE_CHOOSER(m_pDlg));
gtk_dialog_set_tooltip_by_response(GTK_DIALOG(m_pDlg), GTK_RESPONSE_ACCEPT, "Create a master bias frame and save it to the specified file");
g_signal_connect(G_OBJECT(m_pDlg), "response", G_CALLBACK(response_dialog), this);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(m_pDlg), true);
// Filters
filters[0] = gtk_file_filter_new();
gtk_file_filter_add_pattern(filters[0], "*." FILE_EXTENSION_FITS);
gtk_file_filter_set_name(filters[0], "FITS files");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(m_pDlg), filters[0]);
filters[1] = gtk_file_filter_new();
gtk_file_filter_add_pattern(filters[1], "*");
gtk_file_filter_set_name(filters[1], "All files");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(m_pDlg), filters[1]);
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(m_pDlg), filters[0]);
// Dialog icon
gchar *icon = get_icon_file("masterbias");
gtk_window_set_icon(GTK_WINDOW(m_pDlg), gdk_pixbuf_new_from_file(icon, NULL));
g_free(icon);
// Frame selection
xbox = gtk_vbox_new(FALSE, 8);
m_ProcFrame = gtk_frame_new("Process");
gtk_box_pack_start(GTK_BOX(xbox), m_ProcFrame, FALSE, TRUE, 0);
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_add(GTK_CONTAINER(m_ProcFrame), vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
m_AllBtn = gtk_radio_button_new_with_label(NULL, "all files in current project");
gtk_widget_set_tooltip_text(m_AllBtn, "Include all frames in the current project");
gtk_box_pack_start(GTK_BOX(vbox), m_AllBtn, TRUE, TRUE, 0);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(m_AllBtn));
m_SelBtn = gtk_radio_button_new_with_label(group, "selected files only");
gtk_widget_set_tooltip_text(m_SelBtn, "Include frames that are selected in the main window");
gtk_box_pack_start(GTK_BOX(vbox), m_SelBtn, TRUE, TRUE, 0);
// Options
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_START);
gtk_box_pack_start(GTK_BOX(xbox), bbox, FALSE, TRUE, 0);
m_OptionsBtn = gtk_button_new_with_label("Options");
gtk_widget_set_tooltip_text(m_OptionsBtn, "Edit project settings");
gtk_box_pack_start(GTK_BOX(bbox), m_OptionsBtn, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(m_OptionsBtn), "clicked", G_CALLBACK(button_clicked), this);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(m_pDlg), xbox);
gtk_widget_show_all(xbox);
}
/* Caller must g_free() the returned filename. */
gchar *
ghid_dialog_file_select_save (gchar * title, gchar ** path, gchar * file,
gchar * shortcuts)
{
GtkWidget *dialog;
gchar *result = NULL, *folder, *seed;
GHidPort *out = &ghid_port;
dialog = gtk_file_chooser_dialog_new (title,
GTK_WINDOW (out->top_window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
TRUE);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
if (path && *path && **path)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), *path);
if (file && *file)
{
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog),
g_path_get_basename(file));
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
g_path_get_dirname (file));
}
if (shortcuts && *shortcuts)
{
folder = g_strdup (shortcuts);
seed = folder;
while ((folder = strtok (seed, ":")) != NULL)
{
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
folder, NULL);
seed = NULL;
}
g_free (folder);
}
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
result = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
folder =
gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
if (folder && path)
{
dup_string (path, folder);
g_free (folder);
}
}
gtk_widget_destroy (dialog);
return result;
}
static gchar *
audit_run_save_dialog (void)
{
const gchar *key = GVA_SETTING_ERROR_FILE;
GtkFileChooser *file_chooser;
GtkWidget *dialog;
GSettings *settings;
gchar *filename;
gchar *folder;
gchar *name;
settings = gva_get_settings ();
dialog = gtk_file_chooser_dialog_new (
_("Save As"),
GTK_WINDOW (GVA_WIDGET_AUDIT_WINDOW),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
file_chooser = GTK_FILE_CHOOSER (dialog);
/* Suggest the previous filename, if available. */
filename = g_settings_get_string (settings, key);
if (filename != NULL && *filename != '\0')
{
name = g_path_get_basename (filename);
folder = g_path_get_dirname (filename);
}
else
{
name = g_strdup ("rom-errors.txt");
folder = g_strdup (g_get_home_dir ());
}
gtk_file_chooser_set_current_folder (file_chooser, folder);
gtk_file_chooser_set_current_name (file_chooser, name);
gtk_file_chooser_set_do_overwrite_confirmation (file_chooser, TRUE);
g_free (name);
g_free (folder);
g_free (filename);
filename = NULL;
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
filename = gtk_file_chooser_get_filename (file_chooser);
g_settings_set_string (settings, key, filename);
}
gtk_widget_destroy (dialog);
return filename;
}
static void gtk_savethread(void *args){
MSG_FILE *file = args;
//WHY?!
uint16_t fid = file->progress;
file->progress = 0;
//WHY?!
// We're going to save this file somewhere, so we should start the transfer to save time.
// TODO restart this idea
// postmessage(FILE_START_TEMP, fid, (file->filenumber >> 16), file);
// debug("GTK:\tSaving file to temp dir...(%u & %u)\n", fid, file->filenumber);
while(1){ //TODO, save current dir, and filename and preload them to gtk dialog if save fails.
/* Create a GTK save window */
void *dialog = gtk_file_chooser_dialog_new(S(SAVE_FILE), NULL, 1, "gtk-cancel", -6, "gtk-save", -3, NULL);
/* Get incoming file name*/
char buf[sizeof(file->name) + 1];
memcpy(buf, file->name, file->name_length);
buf[file->name_length] = 0;
/* give gtk the file name our friend is sending. */
gtk_file_chooser_set_current_name(dialog, buf);
/* Prompt to overwrite */
gtk_file_chooser_set_do_overwrite_confirmation(dialog, (void*)1);
/* Users can create folders when saving. */ //TODO ENABLE BELOW!
//gtk_file_chooser_set_create_folders(dialog, TRUE);
int result = gtk_dialog_run(dialog);
/* If user is ready to save check then pass to utox. */
if(result == -3) { // -3 == GTK_RESPONSE_ACCEPT
char *name = gtk_file_chooser_get_filename(dialog);
char *path = strdup(name);
//g_free(name)
debug("name: %s\npath: %s\n", name, path);
/* can we really write this file? */
FILE *fp = fopen(path, "w");
if(fp == NULL){
/* No, we can't display error, jump to top. */
if(errno == EACCES){
debug("File write permission denied.\n");
void *errordialog = gtk_message_dialog_new(dialog, 1, 3, 2,
//parent, destroy_with_parent, gtk_error_message, gtk_buttons_close
"Error writing to file '%s'", name);
gtk_dialog_run(errordialog);
gtk_widget_destroy(errordialog);
gtk_widget_destroy(dialog);
continue;
} else {
debug("Unknown file write error...\n");
}
} else {
/* write test passed, we're done! */
gtk_widget_destroy(dialog);
postmessage(SAVE_FILE, fid, (file->filenumber >> 16), path);
break;
}
} else if (-6) { // -6 == GTK_RESPONSE_CANCEL
int ui_messages_save_file_chooser(gboolean filtered)
{
int result = RC_OK;
GtkWidget *filechooser;
/* Check if there is something to save */
if (xml_raw_data_size > 0)
{
static const char *title[] =
{
"Save file (all messages)",
"Save file (filtered messages)",
};
filechooser = gtk_file_chooser_dialog_new (title[filtered], GTK_WINDOW (ui_main_data.window),
GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
gtk_filter_add (filechooser, "Log files", "*.log");
gtk_filter_add (filechooser, "All files", "*");
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (filechooser), TRUE);
if (ui_main_data.messages_file_name != NULL)
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filechooser), ui_main_data.messages_file_name);
}
else
{
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filechooser), "messages.log");
}
/* Process the response */
if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filechooser));
result = ui_messages_file_write (filename, filtered);
if (result == RC_OK)
{
/* Update filters file name for future use */
if (ui_main_data.messages_file_name != NULL)
{
g_free (ui_main_data.messages_file_name);
}
ui_main_data.messages_file_name = filename;
}
else
{
g_free (filename);
}
}
gtk_widget_destroy (filechooser);
}
return result;
}
