Beispiel #1
0
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);
}
Beispiel #2
0
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;
}
Beispiel #3
0
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()));
}
Beispiel #5
0
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;
}
Beispiel #6
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;
}
Beispiel #7
0
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());
}
Beispiel #9
0
/* 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;
}
Beispiel #10
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);
}
Beispiel #11
0
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()
Beispiel #12
0
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);
    }
}
Beispiel #13
0
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);
}
Beispiel #14
0
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);
}
Beispiel #15
0
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);
}
Beispiel #16
0
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);
}
Beispiel #17
0
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);
}
Beispiel #18
0
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;
}
Beispiel #20
0
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);
    }
}
Beispiel #21
0
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);
}
Beispiel #22
0
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);
}
Beispiel #24
0
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);
}
Beispiel #25
0
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);
}
Beispiel #26
0
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);
}
Beispiel #27
0
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);
    }
}
Beispiel #29
0
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 &parameters)
{
	std::string s_name = parameters[0];
	gchar *name = (gchar *)s_name.c_str();

	gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(instance), name);

}