Esempio n. 1
0
File: scripts.c Progetto: IR4T4/xqf
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);
}
Esempio n. 2
0
/*
 * 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);
   }
}
Esempio n. 3
0
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());
}
Esempio n. 4
0
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);
}
Esempio n. 5
0
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 */
}
Esempio n. 6
0
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;
}
Esempio n. 7
0
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);
}
Esempio n. 8
0
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);
}
Esempio n. 9
0
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;
}
Esempio n. 10
0
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;
}
Esempio n. 11
0
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));
}
Esempio n. 12
0
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);
}
Esempio n. 13
0
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;
}
Esempio n. 14
0
/*
 * 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);
}
Esempio n. 15
0
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);
}
Esempio n. 16
0
/* +-----------------------------------+
 * | 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);
    }

}
Esempio n. 17
0
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();
}
Esempio n. 18
0
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);
}
Esempio n. 19
0
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);
}
Esempio n. 21
0
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);
}
Esempio n. 22
0
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 */
}
Esempio n. 23
0
File: ggcov.c Progetto: ggcov/ggcov
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);
}
Esempio n. 24
0
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();
}
Esempio n. 25
0
/*
 * 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;
  }
}
Esempio n. 27
0
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;
}
Esempio n. 28
0
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);
}
Esempio n. 29
0
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);
}
Esempio n. 30
0
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));
}