void GtkToolkitFileChooser::SetInitialPath(const char* path) { char* converted_path = g_filename_from_utf8(path, -1, 0, 0, 0); if (!converted_path) return; struct stat statinfo; bool exists = lstat(converted_path, &statinfo) == 0; if (exists) { if (S_ISDIR(statinfo.st_mode)) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(m_dialog), converted_path); } else { gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(m_dialog), converted_path); char* name = basename(converted_path); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(m_dialog), name); } } else { char* name = basename(converted_path); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(m_dialog), name); // dirname has to be executed last; on some systems (GNU libc) it modifies its argument char* folder = dirname(converted_path); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(m_dialog), folder); } g_free(converted_path); }
bool FileSelector::Execute(bool open, const char *title) { Ctrl::ReleaseCtrlCapture(); if(!title) title = open ? t_("Open") : t_("Save as"); Ctrl *w = Ctrl::GetActiveWindow(); GtkWidget *fc = gtk_file_chooser_dialog_new(title, w ? w->gtk() : NULL, open ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, open ? GTK_STOCK_OPEN : GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL); gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(fc), confirm); gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(fc), true); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(fc), multi); gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(fc), hidden); if(IsFullPath(ipath)) { FindFile ff(ipath); if(ff) if(ff.IsFolder()) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc), ipath); else gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fc), ipath); else { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc), GetFileFolder(ipath)); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(fc), GetFileName(ipath)); } } else gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(fc), ipath); ipath.Clear(); for(int i = 0; i < type.GetCount(); i++) { GtkFileFilter *filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, type[i].a); gtk_file_filter_add_pattern(filter, type[i].b); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fc), filter); if(i == activetype) gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(fc), filter); } bool ret = false; path.Clear(); if(gtk_dialog_run(GTK_DIALOG(fc)) == GTK_RESPONSE_OK) { GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(fc)); if(list) { GSList *l; for(l = list; l; l = l->next) { path.Add((const char *)l->data); g_free(l->data); } g_slist_free (list); } ret = true; } gtk_widget_destroy(fc); return ret; }
static void run_dialog(GtkWidget *dialog, GtkWidget *entry) { /* set filename in the file chooser dialog */ const gchar *utf8_filename = gtk_entry_get_text(GTK_ENTRY(entry)); gchar *locale_filename = utils_get_locale_from_utf8(utf8_filename); if (g_path_is_absolute(locale_filename)) { if (g_file_test(locale_filename, G_FILE_TEST_EXISTS)) { /* if the current filename is a directory, we must use * gtk_file_chooser_set_current_folder(which expects a locale filename) otherwise * we end up in the parent directory */ if (g_file_test(locale_filename, G_FILE_TEST_IS_DIR)) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_filename); else gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), utf8_filename); } else /* if the file doesn't yet exist, use at least the current directory */ { gchar *locale_dir = g_path_get_dirname(locale_filename); gchar *name = g_path_get_basename(utf8_filename); if (g_file_test(locale_dir, G_FILE_TEST_EXISTS)) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_dir); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), name); g_free(name); g_free(locale_dir); } } else if (gtk_file_chooser_get_action(GTK_FILE_CHOOSER(dialog)) != GTK_FILE_CHOOSER_ACTION_OPEN) { gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), utf8_filename); } g_free(locale_filename); /* run it */ if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); gchar *tmp_utf8_filename = utils_get_utf8_from_locale(filename); gtk_entry_set_text(GTK_ENTRY(entry), tmp_utf8_filename); g_free(tmp_utf8_filename); g_free(filename); } gtk_widget_destroy(dialog); }
void XAP_UnixDialog_FileOpenSaveAs::fileTypeChanged(GtkWidget * w) { if (!m_bSave) return; UT_sint32 nFileType = XAP_comboBoxGetActiveInt(GTK_COMBO_BOX(w)); UT_DEBUGMSG(("File type widget is %p filetype number is %d \n",w,nFileType)); // I have no idea for 0, but XAP_DIALOG_FILEOPENSAVEAS_FILE_TYPE_AUTO // definitely means "skip this" if((nFileType == 0) || (nFileType == XAP_DIALOG_FILEOPENSAVEAS_FILE_TYPE_AUTO)) { return; } gchar * filename = gtk_file_chooser_get_filename(m_FC); UT_String sFileName = filename; FREEP(filename); UT_String sSuffix = m_szSuffixes[nFileType-1]; sSuffix = sSuffix.substr(1,sSuffix.length()-1); UT_sint32 i = 0; bool bFoundComma = false; for(i=0; i< static_cast<UT_sint32>(sSuffix.length()); i++) { if(sSuffix[i] == ';') { bFoundComma = true; break; } } if(bFoundComma) { sSuffix = sSuffix.substr(0,i); } // // Hard code a suffix // if(strstr(sSuffix.c_str(),"gz") != NULL) { sSuffix = ".zabw"; } bool bFoundSuffix = false; for(i= sFileName.length()-1; i> 0; i--) { if(sFileName[i] == '.') { bFoundSuffix = true; break; } } if(!bFoundSuffix) { return; } sFileName = sFileName.substr(0,i); sFileName += sSuffix; gtk_file_chooser_set_current_name(m_FC, UT_basename(sFileName.c_str())); }
static void gtk_savedatathread(void *args) { MSG_FILE *file = args; void *dialog = gtk_file_chooser_dialog_new("Save File", NULL, 1, "gtk-cancel", -6, "gtk-save", -3, NULL); gtk_file_chooser_set_current_name(dialog, "inline.png"); int result = gtk_dialog_run(dialog); if(result == -3) { char *name = gtk_file_chooser_get_filename(dialog); FILE *fp = fopen(name, "wb"); if(fp) { fwrite(file->path, file->size, 1, fp); fclose(fp); free(file->path); file->path = (uint8_t*)strdup(name); file->inline_png = 0; } } gtk_widget_destroy(dialog); while(gtk_events_pending()) { gtk_main_iteration(); } gtk_open = 0; }
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; }
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) {
void FileDialog::SetFilename(const wxString& name) { if (GetWindowStyle() & wxFD_SAVE) gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(m_widget), wxConvFileName->cWX2MB(name)); else SetPath(wxFileName(GetDirectory(), name).GetFullPath()); }
/* 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 cir_gtk_file_save() { // Save a file using a GTK+ dialog GtkWidget *dialog = gtk_file_chooser_dialog_new("Save ROM (.nes)", GTK_WINDOW(mainwindow), GTK_FILE_CHOOSER_ACTION_SAVE, ("_Cancel"), GTK_RESPONSE_CANCEL, ("_Save"), GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "edited.nes"); if (gtk_dialog_run(GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { if (romloaded) { char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); cir_rom_write(filename); char message[128]; snprintf(message, sizeof(message), "Saved: %s", filename); cir_gtk_status_update(message); g_free(filename); } } gtk_widget_destroy(dialog); }
void load_patch() //Choose file to load { clear_rack(); //Clear rack before populating again GtkWidget *dialog; std::string filename; dialog = gtk_file_chooser_dialog_new ( "Load Patch", (GtkWindow*)(mainwindow), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), ""); //Default directory gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), "*.xml"); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); parcefile(filename); g_free (filename); } gtk_widget_destroy (dialog); } //end load_patch()
static void file_export_dialog_response (GtkWidget *dialog, gint response_id, gpointer data) { if (response_id == FILE_SAVE_RESPONSE_OTHER_DIALOG) { GimpFileDialog *file_dialog = GIMP_FILE_DIALOG (dialog); GtkWindow *parent; GtkWidget *other; gchar *folder; gchar *uri; gchar *name; parent = gtk_window_get_transient_for (GTK_WINDOW (dialog)); folder = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (dialog)); uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog)); name = file_utils_uri_display_basename (uri); g_free (uri); other = file_save_dialog_show (file_dialog->image->gimp, file_dialog->image, GTK_WIDGET (parent), _("Save Image"), FALSE, FALSE, NULL); gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (other), folder); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (other), name); g_free (folder); g_free (name); } }
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); }
void cb_save_graphic() { Shell *shell = shell_get_main_shell(); GtkWidget *dialog; gchar *filename; /* save the pixbuf to a png file */ dialog = gtk_file_chooser_dialog_new("Save Image", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); filename = g_strconcat(shell->selected->name, ".png", NULL); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), filename); g_free(filename); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); gtk_widget_destroy(dialog); shell_status_update("Saving image..."); tree_view_save_image(filename); shell_status_update("Done."); g_free(filename); return; } gtk_widget_destroy(dialog); }
void fileio_do_state_save(void) { Nes::Api::Machine machine( emulator ); GtkWidget *dialog; char defname[512]; defname[0] = '\0'; strcpy(defname, rootname); strcat(defname, ".nst"); dialog = gtk_file_chooser_dialog_new ("Save state (.nst)", GTK_WINDOW(mainwindow), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), defname); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { char *filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); std::ofstream stateFile( filename, std::ifstream::out|std::ifstream::binary ); if (stateFile.is_open()) { machine.SaveState(stateFile); } g_free (filename); } gtk_widget_destroy(dialog); }
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); }
JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1set_1current_1name ( JNIEnv* env, jclass cls, jlong _self, jstring _name ) { GtkFileChooser* self; const gchar* name; // convert parameter self self = (GtkFileChooser*) _self; // convert parameter name name = (const gchar*) bindings_java_getString(env, _name); if (name == NULL) { return; // Java Exception already thrown } // call function gtk_file_chooser_set_current_name(self, name); // cleanup parameter self // cleanup parameter name bindings_java_releaseString(name); }
static gchar *report_get_filename(void) { GtkWidget *dialog; gchar *filename = NULL; dialog = gtk_file_chooser_dialog_new("Save File", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "hardinfo_report"); file_chooser_add_filters(dialog, file_types); file_chooser_open_expander(dialog); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { gchar *ext = file_chooser_get_extension(dialog, file_types); filename = file_chooser_build_filename(dialog, ext); } gtk_widget_destroy(dialog); return 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; }
static void overwrite_response_cb (GtkFileChooser *chooser, gint response, gpointer data) { struct confirm_overwrite_closure *closure = data; char *filename; if (g_test_verbose()) printf ("plong!\n"); if (response != GTK_RESPONSE_ACCEPT) return; filename = gtk_file_chooser_get_filename (chooser); if (!g_str_has_suffix (filename, closure->extension)) { char *basename; basename = g_path_get_basename (filename); g_free (filename); filename = g_strconcat (basename, closure->extension, NULL); gtk_file_chooser_set_current_name (chooser, filename); g_signal_stop_emission_by_name (chooser, "response"); gtk_dialog_response (GTK_DIALOG (chooser), GTK_RESPONSE_ACCEPT); } }
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); }
static char * save_file (const char *title, const char *suggested_filename, GtkWidget * parent, int *success) { GtkWidget *dialog; char *filename = NULL; *success = 0; dialog = gtk_file_chooser_dialog_new (title, GTK_WINDOW (parent), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); if (suggested_filename && *suggested_filename) { gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), suggested_filename); } if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); *success = 1; } gtk_widget_destroy (dialog); return filename; }
void action_equ_save_preset_file(void) { GtkWidget *dialog; gchar *file_uri, *title; dialog = make_filebrowser(_("Save equalizer preset"), TRUE); title = aud_drct_get_title (); if (title != NULL) { gchar * ext = EQUALIZER_DEFAULT_PRESET_EXT; gchar * eqname = g_strdup_printf ("%s.%s", title, ext); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), eqname); g_free (eqname); str_unref (title); } if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { file_uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog)); EqualizerPreset * preset = aud_equalizer_preset_new (""); equalizerwin_update_preset (preset); aud_save_preset_file(preset, file_uri); aud_equalizer_preset_free(preset); g_free(file_uri); } gtk_widget_destroy(dialog); }
static void load_save_settings(GtkamSave *save) { gchar buf[1024]; gchar *dir; /* directory */ if (gp_setting_get("gtkam","save-dir",buf) == GP_OK) { dir = g_strdup (buf); strcat (buf, G_DIR_SEPARATOR_S); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (save), buf); } else { dir = g_strdup (gtk_file_chooser_get_filename ( GTK_FILE_CHOOSER (save))); } /* prefix entry */ gp_setting_get ("gtkam", "save-prefix", buf); gtk_entry_set_text (GTK_ENTRY (save->priv->prefix_entry), buf); /* toggle buttons */ #define LOAD_TOGGLE(NAME) \ gp_setting_get("gtkam","save-" #NAME,buf); \ gtk_toggle_button_set_active(save->priv->toggle_ ## NAME, atoi(buf)) LOAD_TOGGLE(preview); LOAD_TOGGLE(normal); LOAD_TOGGLE(raw); LOAD_TOGGLE(audio); LOAD_TOGGLE(exif); LOAD_TOGGLE(filename_camera); g_free(dir); }
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); }
static void cb_ts_export() { GtkWidget *file_selector = gtk_file_chooser_dialog_new( _("Please input filename for exporting data"), GTK_WINDOW(main_window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_alternative_button_order( GTK_DIALOG(file_selector), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); char hime_dir[512]; get_hime_dir(hime_dir); char cmd[512]; char fname[256]; char *filename=inmd[default_input_method].filename; char tt[256]; if (inmd[default_input_method].method_type==method_type_TSIN) { get_hime_user_fname(tsin32_f, fname); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (file_selector), tsin32_f); } else if (filename) { strcat(strcpy(tt, filename), ".append.gtab.tsin-db"); if (!get_hime_user_fname(tt, fname)) { strcat(strcpy(tt, filename), ".tsin-db"); if (!get_hime_user_fname(tt, fname)) p_err("cannot find %s", fname); } gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (file_selector), tt); } gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (file_selector), TRUE); if (gtk_dialog_run (GTK_DIALOG (file_selector)) == GTK_RESPONSE_ACCEPT) { gchar *selected_filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (file_selector)); snprintf(cmd, sizeof(cmd), HIME_BIN_DIR"/hime-tsd2a32 %s -o %s", fname, selected_filename); dbg("exec %s\n", cmd); int res = system(cmd); res = 0; // some problem in system(), the exit code is not reliable create_result_win(res, cmd); } gtk_widget_destroy (file_selector); }
static void pidgin_whiteboard_button_save_press(GtkWidget *widget, gpointer data) { PidginWhiteboard *gtkwb = (PidginWhiteboard*)(data); GdkPixbuf *pixbuf; GtkWidget *dialog; int result; dialog = gtk_file_chooser_dialog_new (_("Save File"), GTK_WINDOW(gtkwb->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), (gboolean)(TRUE)); */ /* if(user_edited_a_new_document) */ { /* gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), default_folder_for_saving); */ gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "whiteboard.jpg"); } /* else gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog), filename_for_existing_document); */ result = gtk_dialog_run(GTK_DIALOG(dialog)); if(result == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); gtk_widget_destroy(dialog); /* Makes an icon from the whiteboard's canvas 'image' */ pixbuf = gdk_pixbuf_get_from_drawable(NULL, (GdkDrawable*)(gtkwb->pixmap), gdk_drawable_get_colormap(gtkwb->pixmap), 0, 0, 0, 0, gtkwb->width, gtkwb->height); if(gdk_pixbuf_save(pixbuf, filename, "jpeg", NULL, "quality", "100", NULL)) purple_debug_info("gtkwhiteboard", "File Saved...\n"); else purple_debug_info("gtkwhiteboard", "File not Saved... Error\n"); g_free(filename); } else if(result == GTK_RESPONSE_CANCEL) { gtk_widget_destroy(dialog); purple_debug_info("gtkwhiteboard", "File not Saved... Cancelled\n"); } }
/* 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); } }
void saa_export_dialog_format_changed(SaaExportDialog * d) { gchar * name; int index = gtk_combo_box_get_active (GTK_COMBO_BOX(d->format)); switch(index) { case 0: name = g_strdup_printf("%s%s", d->visuel->solide->nom, ".ps"); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(d->chooser), name); g_free(name); break; case 1: case 2: name = g_strdup_printf("%s%s", d->visuel->solide->nom, ".svg"); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(d->chooser), name); g_free(name); break; } }
void GtkFileChooserDialog_::set_current_name(Php::Parameters ¶meters) { std::string s_name = parameters[0]; gchar *name = (gchar *)s_name.c_str(); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(instance), name); }