void install_file_dialog_ok_callback (GtkWidget *widget, gpointer data) { const char *filename = NULL; char dest[PATH_MAX]; GtkWidget* filesel = topmost_parent(widget); const char* msg; filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (filesel)); if (!filename) { return; } mkdir((const char*)scriptdirs->data, 0777); snprintf(dest, sizeof(dest), "%s/%s", (const char*)scriptdirs->data, g_path_get_basename(filename)); if (!access(dest, F_OK)) { if (!dialog_yesno(NULL, 0, NULL, NULL, _("Script %s already exists, overwrite?"), dest)) { return; } } if ((msg = copy_file(filename, dest))) { dialog_ok(NULL, "%s", msg); return; } g_datalist_remove_data(&scriptdata, g_path_get_basename(filename)); scripts_load(); dialog_ok(NULL, _("Script saved as\n%s\nPlease close and reopen the preferences dialog"), dest); }
/* * display the file open dialog */ static void gtkui_file_open(void) { GtkWidget *dialog; const char *filename; int response = 0; DEBUG_MSG("gtk_file_open"); dialog = gtk_file_selection_new ("Select a pcap file..."); response = gtk_dialog_run (GTK_DIALOG (dialog)); if (response == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog)); /* destroy needs to come before read_pcapfile so gtk_main_quit can reside inside read_pcapfile, which is why destroy is here twice and not after the if() block */ gtk_widget_destroy (dialog); read_pcapfile (filename); } else { gtk_widget_destroy (dialog); } }
void on_flashfile_ok_button2_clicked (GtkButton *button, gpointer user_data) { GtkWidget *w; gchar *filename; gchar buffer[1024]; gchar *ext = NULL; filename = gtk_file_selection_get_filename(GTK_FILE_SELECTION(user_data)); ext = strrchr(filename, '.'); if(str_cmp(ext, ".tib") && str_cmp(ext, ".89u") && str_cmp(ext, ".9xu")) { msg_box(_("Error"), _("Invalid file")); gtk_widget_destroy(GTK_WIDGET(user_data)); gtk_widget_show(create_step1_dbox()); return; } gtk_widget_show((w = create_wait_dbox())); while( gtk_events_pending() ) { gtk_main_iteration(); } ti68k_convertTibToRom(filename, buffer); wizard_rom = g_strdup(buffer); gtk_widget_destroy(w); while( gtk_events_pending() ) { gtk_main_iteration(); } gtk_widget_destroy(GTK_WIDGET(user_data)); gtk_widget_show(create_step3_dbox()); }
void GTK_browse_server_executable(GtkWidget *entry, gpointer user_data) { GtkWidget *w; const gchar *path = gtk_entry_get_text(GTK_ENTRY(entry)); const gchar *os_path; gchar *s; w = gtk_file_selection_new("Select Local Executable"); gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(w)); if (*path) { os_path = g_filename_from_utf8(path, -1, NULL, NULL, NULL); if (os_path) { s = g_find_program_in_path(os_path); gtk_file_selection_set_filename(GTK_FILE_SELECTION(w), s ? s : os_path); g_free(s); g_free((void *)os_path); } } if (gtk_dialog_run(GTK_DIALOG(w)) == GTK_RESPONSE_OK) { os_path = gtk_file_selection_get_filename(GTK_FILE_SELECTION(w)); path = g_filename_to_utf8(os_path, -1, NULL, NULL, NULL); if (path) { gtk_entry_set_text(GTK_ENTRY(entry), path); g_free((void *)path); } } gtk_widget_destroy(w); }
void do_scene_detection(GtkWidget *w, GtkFileSelection *fs) { char *lav2yuv_command[256]; char temp1[256], temp2[256]; int n=0,i; lav2yuv_command[n] = app_name(LAV2YUV_S); n++; lav2yuv_command[n] = "-v2"; n++; lav2yuv_command[n] = "-D"; n++; sprintf(temp1, "%d", scene_detection_width_decimation); lav2yuv_command[n] = temp1; n++; lav2yuv_command[n] = "-T"; n++; sprintf(temp2, "%d", scene_detection_treshold); lav2yuv_command[n] = temp2; n++; lav2yuv_command[n] = "-S"; n++; sprintf(eli_file, gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs))); lav2yuv_command[n] = eli_file; n++; for(i=0;i<current_file;i++) { lav2yuv_command[n] = files_recorded[i]; n++; } lav2yuv_command[n] = NULL; create_scene_detection_window(); start_pipe_command(lav2yuv_command, LAV2YUV_S); /* lav2yuv */ }
static void cb_import_select_row(GtkWidget *file_clist, gint row, gint column, GdkEventButton *bevent, gpointer data) { const char *sel; struct stat statb; int guessed_type; int i; jp_logf(JP_LOG_DEBUG, "cb_import_select_row\n"); sel = gtk_file_selection_get_filename(GTK_FILE_SELECTION(filew)); /* Check to see if its a regular file */ if (stat(sel, &statb)) { jp_logf(JP_LOG_DEBUG, "File selected was not stat-able\n"); return; } if (!S_ISREG(statb.st_mode)) { jp_logf(JP_LOG_DEBUG, "File selected was not a regular file\n"); return; } guessed_type=guess_file_type(sel); for (i=0; i<MAX_IMPORT_TYPES; i++) { if (radio_types[i]==NULL) break; if (guessed_type==radio_file_types[i]) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_types[i]), TRUE); break; } } return; }
static void openOK(GtkObject *object, gpointer data) { GtkFileSelection *fileselection = GTK_FILE_SELECTION(data); GtkWidget *app = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(fileselection), "app")); Context *context = (Context *) gtk_object_get_data(GTK_OBJECT(app), "context"); gchar *fileName = g_strdup(gtk_file_selection_get_filename(fileselection)); pf_flow *newPara; gtk_widget_destroy(GTK_WIDGET(fileselection)); newPara = pf_factory(fileName, font, guiSupport); if (newPara != NULL) { gchar *title = prettyTitle(fileName); GtkWidget *area = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(app), "area")); if (context->paragraph != NULL) { pf_close(context->paragraph); } context->paragraph = newPara; gtk_window_set_title(GTK_WINDOW(app), title); gtk_widget_hide(area); pf_breakLines(context->paragraph, context->width, context->height); gtk_widget_show_all(area); g_free(title); } g_free(fileName); }
static void cb_quit(GtkWidget *widget, gpointer data) { const char *sel; char dir[MAX_PREF_LEN+2]; int i; jp_logf(JP_LOG_DEBUG, "Quit\n"); sel = gtk_file_selection_get_filename(GTK_FILE_SELECTION(filew)); strncpy(dir, sel, MAX_PREF_LEN); dir[MAX_PREF_LEN]='\0'; i=strlen(dir)-1; if (i<0) i=0; if (dir[i]!='/') { for (i=strlen(dir); i>=0; i--) { if (dir[i]=='/') { dir[i+1]='\0'; break; } } } set_pref(PREF_MEMO_IMPORT_PATH, 0, dir, TRUE); filew = NULL; gtk_widget_destroy(data); }
char* store_filename(GtkWidget* file_selection_box) { const gchar* name = gtk_file_selection_get_filename(GTK_FILE_SELECTION(file_selection_box)); char* ret_val = malloc(strlen(name) + 1); strcpy(ret_val, name); return ret_val; }
IDataSource * choosePalette() { FileSystem * filesys = FileSystem::get_instance(); GtkWidget *file_sel; gchar *filename; gboolean selected = FALSE; file_sel = gtk_file_selection_new( "Choose a Palette" ); gtk_window_set_modal( GTK_WINDOW( file_sel ), TRUE ); gtk_signal_connect( GTK_OBJECT( file_sel ), "destroy", GTK_SIGNAL_FUNC( file_sel_delete ), &file_sel ); gtk_signal_connect( GTK_OBJECT( GTK_FILE_SELECTION( file_sel )->cancel_button ), "clicked", GTK_SIGNAL_FUNC( file_sel_delete ), &file_sel ); gtk_signal_connect( GTK_OBJECT( GTK_FILE_SELECTION( file_sel )->ok_button ), "clicked", GTK_SIGNAL_FUNC( file_selected ), &selected ); gtk_widget_show( file_sel ); while( ( ! selected ) && ( file_sel ) ) gtk_main_iteration(); /* canceled or window was closed */ if( ! selected ) return 0; /* ok */ filename = g_strdup( gtk_file_selection_get_filename( GTK_FILE_SELECTION( file_sel ) ) ); gtk_widget_destroy( file_sel ); IDataSource * ds = filesys->ReadFile(filename); return ds; }
void on_import_activate(GtkAction * action, gpointer user_data) { GtkFileSelection *fs; GtkResponseType response; const gchar *filename; gchar last_dir[PATH_MAX]; g_strlcpy(last_dir, prefs.last_dir, sizeof(last_dir)); if (!la_str_has_suffix_case(prefs.last_dir, G_DIR_SEPARATOR_S)) g_strlcat(last_dir, "/", sizeof(last_dir)); fs = GTK_FILE_SELECTION(gtk_file_selection_new (_("Select .pls Files to Import..."))); gtk_file_selection_set_select_multiple(fs, FALSE); gtk_file_selection_set_filename(fs, last_dir); gtk_widget_show_all(GTK_WIDGET(fs)); response = gtk_dialog_run(GTK_DIALOG(fs)); if (response == GTK_RESPONSE_OK) { filename = gtk_file_selection_get_filename(fs); playlist_import_pls(get_playlist(app), filename); g_free(prefs.last_dir); prefs.last_dir = g_path_get_dirname(filename); } gtk_widget_destroy(GTK_WIDGET(fs)); }
static void on_select_output_file_clicked(GtkWidget *widget, AnimationRenderUi *self) { GtkWidget *dialog; #if (GTK_CHECK_VERSION(2, 4, 0)) dialog = gtk_file_chooser_dialog_new ("Select Output File", GTK_WINDOW (glade_xml_get_widget (self->xml, "window")), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { gchar *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); gtk_entry_set_text (GTK_ENTRY (glade_xml_get_widget (self->xml, "output_file")), filename); g_free (filename); } #else dialog = gtk_file_selection_new ("Select Output File"); gtk_file_selection_set_filename (GTK_FILE_SELECTION (dialog), gtk_entry_get_text (GTK_ENTRY (glade_xml_get_widget (self->xml, "output_file")))); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { gtk_entry_set_text (GTK_ENTRY (glade_xml_get_widget (self->xml, "output_file")), gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog))); } #endif gtk_widget_destroy (dialog); }
void nsSetupTypeDlg::SelectFolderOK(GtkWidget *aWidget, GtkFileSelection *aFileSel) { DUMP("SelectFolderOK"); struct stat destStat; const gchar *selDir = gtk_file_selection_get_filename(GTK_FILE_SELECTION(aFileSel)); // put the candidate file name in the global variable, then verify it strcpy(gCtx->opt->mDestination, selDir); if (0 == stat(selDir, &destStat)) if (!S_ISDIR(destStat.st_mode) || VerifyDestination() != OK ) /* not a directory, or we don't have access permissions, so don't tear down */ return; // update folder path displayed gtk_label_set_text(GTK_LABEL(sFolder), gCtx->opt->mDestination); gtk_widget_show(sFolder); // tear down file sel dlg gtk_object_destroy(GTK_OBJECT(aFileSel)); sFilePickerUp = FALSE; }
/* * display the file open dialog */ void gtkui_load_filter(void) { GtkWidget *dialog; char *filename; int response = 0; char *path = get_full_path("share", ""); DEBUG_MSG("gtk_load_filter"); dialog = gtk_file_selection_new ("Select a precompiled filter file..."); gtk_file_selection_set_filename(GTK_FILE_SELECTION(dialog), path); SAFE_FREE(path); response = gtk_dialog_run (GTK_DIALOG (dialog)); if (response == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog)); /* * load the filters chain. * errors are spawned by the function itself */ filter_load_file(filename, GBL_FILTERS); } gtk_widget_destroy (dialog); }
static void dosave_directory_listing (GtkWidget * widget, gftp_save_dir_struct * str) { const char *filename; gftp_file * tempfle; GList * templist; char *tempstr; FILE * fd; filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (str->filew)); if ((fd = fopen (filename, "w")) == NULL) { ftp_log (gftp_logging_error, NULL, _("Error: Cannot open %s for writing: %s\n"), filename, g_strerror (errno)); return; } for (templist = str->wdata->files; templist != NULL; templist = templist->next) { tempfle = templist->data; if (!tempfle->shown) continue; tempstr = gftp_gen_ls_string (NULL, tempfle, NULL, NULL); fprintf (fd, "%s\n", tempstr); g_free (tempstr); } fclose (fd); }
/* +-----------------------------------+ * | Export Related Functions | * +-----------------------------------+ */ void on_export_file_okbutton_clicked (GtkButton *button, gpointer user_data) { gchar *filename; GtkWidget *dialog; gint result = GTK_RESPONSE_OK; filename = (char*) gtk_file_selection_get_filename(GTK_FILE_SELECTION (export_file_window)); if( !access(filename, F_OK) ) { dialog = gtk_message_dialog_new(GTK_WINDOW(save_file_window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL, "File '%s' exists. Overwrite?", filename); result = gtk_dialog_run( GTK_DIALOG(dialog) ); gtk_widget_destroy( dialog ); } gtk_widget_hide(export_file_window); flush(); if( GTK_RESPONSE_OK == result ) { save_file(filename); } }
static void load_file(GtkWidget *w, GtkFileSelection *selector) { int texnum; gchar *filename; if(curr_obj < 0) { quick_message("No object selected."); gtk_widget_hide(GTK_WIDGET(selector)); return; } filename = gtk_file_selection_get_filename(selector); texnum = bind_tex(filename, 256, 256, 0); if(texnum == 0) { quick_message("Unable to load image."); gtk_widget_hide(GTK_WIDGET(selector)); return; } if(aw_object[curr_obj].texnum) glDeleteTextures(1, (GLuint*)&aw_object[curr_obj].texnum); aw_object[curr_obj].texnum = texnum; aw_object[curr_obj].object_changed = TRUE; gtk_widget_hide(GTK_WIDGET(selector)); gl_redraw_all(); }
void on_save_ok_button_clicked(GtkButton * button, gpointer user_data) { GtkWidget *save_select; FILE *outfile; gchar *file, *text; save_select = gtk_widget_get_ancestor(GTK_WIDGET(button),GTK_TYPE_FILE_SELECTION); file = gtk_file_selection_get_filename(GTK_FILE_SELECTION(save_select)); gtk_widget_hide(save_select); outfile = fopen(file,"w"); if(outfile == NULL) { fprintf(stderr,"IOL: couldn't open %s\n",file); gtk_widget_destroy(save_select); return; } gtk_widget_destroy(save_select); gtk_text_freeze(script_text); text = gtk_editable_get_chars(GTK_EDITABLE(script_text),0,-1); fprintf(outfile,"%s",text); fclose(outfile); g_free(text); gtk_text_thaw(script_text); }
static void filesel_ok(GtkWidget *widget, GtkFileSelection *fs) { gchar *dir; gchar *text; GtkTextBuffer *buffer; GtkTextIter start, end; LOG(LOG_DEBUG, "IN : filesel_ok()"); dir = (gchar *)gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)); strcpy(last_dir, dir); dir = fs_to_unicode(dir); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(dirgroup_view)); gtk_text_buffer_get_bounds (buffer, &start, &end); text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE); if(strlen(text) != 0) gtk_text_buffer_insert(buffer, &end, "\n", 1); gtk_text_buffer_insert(buffer, &end, dir, strlen(dir)); g_free(text); g_free(dir); gtk_grab_remove(GTK_WIDGET(fs)); gtk_widget_destroy(GTK_WIDGET(fs)); LOG(LOG_DEBUG, "OUT : filesel_ok()"); }
void accept_file_dialog(GtkWidget *widget, gpointer data) { add_file(gtk_file_selection_get_filename(GTK_FILE_SELECTION(filew))); update_list(); gtk_widget_destroy(filew); }
void on_load_ok_button_clicked(GtkButton *button, gpointer user_data) { GtkWidget *load_select; FILE *infile; char *filename; char text[512]; load_select = gtk_widget_get_ancestor(GTK_WIDGET(button),GTK_TYPE_FILE_SELECTION); filename = gtk_file_selection_get_filename(GTK_FILE_SELECTION(load_select)); gtk_widget_hide(load_select); infile = fopen(filename,"r"); if(infile == NULL) { fprintf(stderr,"IOL: can't open %s\n",filename); gtk_widget_destroy(load_select); return; } gtk_widget_destroy(load_select); gtk_text_freeze(script_text); /* since GTK+ (lamely) has no gtk_text_empty() or whatever, so we have to revert to kludges :( */ gtk_text_set_point(script_text,0); gtk_text_forward_delete(script_text,gtk_text_get_length(script_text)); while(fgets(text,512,infile) != NULL) gtk_text_insert(script_text,script_font,NULL,NULL,text,strlen(text)); fclose(infile); gtk_text_set_point(script_text,0); gtk_text_thaw(script_text); }
static void onokay(GtkFileSelection *widget, void *data) { strcpy(filename, gtk_file_selection_get_filename(GTK_FILE_SELECTION(filedlog))); gtk_widget_destroy(filedlog); filedlog = NULL; gtk_main_quit(); /* un-recurse back to normal loop */ }
GLADE_CALLBACK void on_open_ok_button_clicked(GtkWidget *w, gpointer userdata) { const char *filename; _log.debug("on_open_ok_button_clicked\n"); filename = gtk_file_selection_get_filename( GTK_FILE_SELECTION(open_window)); if (filename != 0 && *filename != '\0') { cov_pre_read(); if (ggcov_read_file(filename)) cov_post_read(); } gtk_widget_hide(open_window); /* * No files loaded: user started ggcov without a commandline * argument and failed to load a file in the Open dialog. */ if (!*cov_file_t::first()) exit(1); }
static void ButtonOk( GtkWidget * hWnd, gpointer data ) { hb_retc( ( char * ) gtk_file_selection_get_filename( GTK_FILE_SELECTION( data ) ) ); gtk_widget_destroy( ( GtkWidget * ) data ); gtk_main_quit(); }
/* * display the file open dialog */ void gtkui_plugin_load(void) { GtkWidget *dialog; char *filename; int response = 0; #ifdef OS_WINDOWS char *path = get_full_path("/lib/", ""); #else char *path = INSTALL_LIBDIR "/" EC_PROGRAM "/"; #endif DEBUG_MSG("gtk_plugin_load"); dialog = gtk_file_selection_new ("Select a plugin..."); gtk_file_selection_set_filename(GTK_FILE_SELECTION(dialog), path); #ifdef OS_WINDOWS SAFE_FREE(path); #endif response = gtk_dialog_run (GTK_DIALOG (dialog)); if (response == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog)); gtkui_load_plugin(filename); /* update the list */ gtkui_create_plug_array(); } gtk_widget_destroy (dialog); }
void save_list_init(gpointer data) { save_list(gtk_file_selection_get_filename(GTK_FILE_SELECTION(list_dialog))); if( list_dialog != NULL ) { gtk_widget_destroy(list_dialog); list_dialog = NULL; } }
static gboolean set_filename(gpointer data) { filesel_data *fsd = (filesel_data*)data; gtk_entry_set_text(GTK_ENTRY(fsd->entry), gtk_file_selection_get_filename(GTK_FILE_SELECTION(fsd->filesel))); gtk_widget_destroy(fsd->filesel); g_free(fsd); return TRUE; }
static void file_selected(GtkWidget *w, GtkFileSelection *fs) { const char *fn = gtk_file_selection_get_filename(GTK_FILE_SELECTION(w)); (void)fs; /* unused */ if (filename) free(filename); filename = strdup(fn); gtk_widget_destroy(w); }
void file_ok_open_global(GtkWidget *widget, GtkWidget *fs) { /* get file from the fileselection box */ char *file; file = (char*)gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)); global_open_location(file); }
static void file_selection_ok(GtkWidget *w, GtkFileSelection *gfs) { file_selection_t *fsp = (file_selection_t *)gfs; GtkFileSelection *fs = (GtkFileSelection *)fsp->fs; char *p; UNUSED(w); p = (char *)gtk_file_selection_get_filename(fs); if (p) { struct stat st; if (stat(p, &st) == 0) { if (!S_ISDIR(st.st_mode)) { switch (fsp->type) { case 1: // open MIMPI tone map gtk_entry_set_text(GTK_ENTRY(fsp->arg), p); strncpy(ConfigProp.ToneMapFile, p, sizeof(ConfigProp.ToneMapFile)); break; case 2: // open SASI HDD { sasi_hdd_t *sasi_hdd = (sasi_hdd_t *)fsp->arg; strncpy(ConfigProp.HDImage[sasi_hdd->idx], p, sizeof(ConfigProp.HDImage[0])); gtk_entry_set_text(GTK_ENTRY(sasi_hdd->entry), p); } break; } } } else if (errno == ENOENT) { switch (fsp->type) { case 3: // create SASI HDD image { sasi_hdd_t *sasi_hdd = (sasi_hdd_t *)fsp->arg; char buf[0x1000]; FILEH *fh; int i; fh = File_Create(p, FTYPE_NONE); if (fh == INVALID_HANDLE_VALUE) break; bzero(buf, sizeof(buf)); for (i = 0; i < 0x2793 /* 40Mb/0x1000 */; ++i) File_Write(fh, buf, 0x1000); File_Close(fh); strncpy(ConfigProp.HDImage[sasi_hdd->idx], p, sizeof(ConfigProp.HDImage[0])); gtk_entry_set_text(GTK_ENTRY(sasi_hdd->entry), p); } break; } } } gtk_widget_destroy(GTK_WIDGET(fs)); }