vmap/libs/gtkutil/filechooser.cpp

/*
   Copyright (C) 2001-2006, William Joseph.
   All Rights Reserved.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "filechooser.h"

#include "ifiletypes.h"

#include <list>
#include <vector>
#include <gtk/gtk.h>
#include <uilib/uilib.h>

#include "string/string.h"
#include "stream/stringstream.h"
#include "container/array.h"
#include "os/path.h"
#include "os/file.h"

#include "messagebox.h"


struct filetype_pair_t {
	filetype_pair_t()
		: m_moduleName("")
	{
	}

	filetype_pair_t(const char *moduleName, filetype_t type)
		: m_moduleName(moduleName), m_type(type)
	{
	}

	const char *m_moduleName;
	filetype_t m_type;
};

class FileTypeList : public IFileTypeList {
struct filetype_copy_t {
	filetype_copy_t(const filetype_pair_t &other)
		: m_moduleName(other.m_moduleName), m_name(other.m_type.name), m_pattern(other.m_type.pattern)
	{
	}

	CopiedString m_moduleName;
	CopiedString m_name;
	CopiedString m_pattern;
};

typedef std::list<filetype_copy_t> Types;
Types m_types;
public:

typedef Types::const_iterator const_iterator;

const_iterator begin() const
{
	return m_types.begin();
}

const_iterator end() const
{
	return m_types.end();
}

std::size_t size() const
{
	return m_types.size();
}

void addType(const char *moduleName, filetype_t type)
{
	m_types.push_back(filetype_pair_t(moduleName, type));
}
};


class GTKMasks {
const FileTypeList &m_types;
public:
std::vector<CopiedString> m_filters;
std::vector<CopiedString> m_masks;

GTKMasks(const FileTypeList &types) : m_types(types)
{
	m_masks.reserve(m_types.size());
	for (FileTypeList::const_iterator i = m_types.begin(); i != m_types.end(); ++i) {
		std::size_t len = strlen((*i).m_name.c_str()) + strlen((*i).m_pattern.c_str()) + 3;
		StringOutputStream buffer(len + 1); // length + null char

		buffer << (*i).m_name.c_str() << " <" << (*i).m_pattern.c_str() << ">";

		m_masks.push_back(buffer.c_str());
	}

	m_filters.reserve(m_types.size());
	for (FileTypeList::const_iterator i = m_types.begin(); i != m_types.end(); ++i) {
		m_filters.push_back((*i).m_pattern);
	}
}

filetype_pair_t GetTypeForGTKMask(const char *mask) const
{
	std::vector<CopiedString>::const_iterator j = m_masks.begin();
	for (FileTypeList::const_iterator i = m_types.begin(); i != m_types.end(); ++i, ++j) {
		if (string_equal((*j).c_str(), mask)) {
			return filetype_pair_t((*i).m_moduleName.c_str(),
			                       filetype_t((*i).m_name.c_str(), (*i).m_pattern.c_str()));
		}
	}
	return filetype_pair_t();
}

};

static char g_file_dialog_file[1024];

const char *
file_dialog_show(ui::Window parent, bool open, const char *title, const char *path, const char *pattern, bool want_load,
                 bool want_import, bool want_save)
{
	filetype_t type;

	if (pattern == 0) {
		pattern = "*";
	}

	FileTypeList typelist;
	GlobalFiletypes().getTypeList(pattern, &typelist, want_load, want_import, want_save);

	GTKMasks masks(typelist);

	if (title == 0) {
		title = open ? "Open File" : "Save File";
	}

	ui::Dialog dialog{ui::null};
	if (open) {
		dialog = ui::Dialog::from(gtk_file_chooser_dialog_new(title,
		                                                      parent,
		                                                      GTK_FILE_CHOOSER_ACTION_OPEN,
		                                                      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
		                                                      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
		                                                      NULL));
	} else {
		dialog = ui::Dialog::from(gtk_file_chooser_dialog_new(title,
		                                                      parent,
		                                                      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), "unnamed");
	}

	gtk_window_set_modal(dialog, TRUE);
	gtk_window_set_position(dialog, GTK_WIN_POS_CENTER_ON_PARENT);

	// we expect an actual path below, if the path is 0 we might crash
	if (path != 0 && !string_empty(path)) {
		ASSERT_MESSAGE(path_is_absolute(path), "file_dialog_show: path not absolute: " << makeQuoted(path));

		Array<char> new_path(strlen(path) + 1);

		// copy path, replacing dir separators as appropriate
		Array<char>::iterator w = new_path.begin();
		for (const char *r = path; *r != '\0'; ++r) {
			*w++ = (*r == '/') ? G_DIR_SEPARATOR : *r;
		}
		// remove separator from end of path if required
		if (*(w - 1) == G_DIR_SEPARATOR) {
			--w;
		}
		// terminate string
		*w = '\0';

		gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), new_path.data());
	}

	// we should add all important paths as shortcut folder...
	// gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog), "/tmp/", NULL);


	for (std::size_t i = 0; i < masks.m_filters.size(); ++i) {
		GtkFileFilter *filter = gtk_file_filter_new();
		gtk_file_filter_add_pattern(filter, masks.m_filters[i].c_str());
		gtk_file_filter_set_name(filter, masks.m_masks[i].c_str());
		gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
	}

	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
		strcpy(g_file_dialog_file, gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)));

		if (!string_equal(pattern, "*")) {
			GtkFileFilter *filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog));
			if (filter !=
			    0) { // no filter set? some file-chooser implementations may allow the user to set no filter, which we treat as 'all files'
				type = masks.GetTypeForGTKMask(gtk_file_filter_get_name(filter)).m_type;
				// last ext separator
				const char *extension = path_get_extension(g_file_dialog_file);
				// no extension
				if (string_empty(extension)) {
					strcat(g_file_dialog_file, type.pattern + 1);
				} else {
					strcpy(g_file_dialog_file + (extension - g_file_dialog_file), type.pattern + 2);
				}
			}
		}

		// convert back to unix format
		for (char *w = g_file_dialog_file; *w != '\0'; w++) {
			if (*w == '\\') {
				*w = '/';
			}
		}
	} else {
		g_file_dialog_file[0] = '\0';
	}

	ui::Widget(dialog).destroy();

	// don't return an empty filename
	if (g_file_dialog_file[0] == '\0') {
		return NULL;
	}

	return g_file_dialog_file;
}

char *dir_dialog(ui::Window parent, const char *title, const char *path)
{
	auto dialog = ui::Dialog::from(gtk_file_chooser_dialog_new(title,
	                                                           parent,
	                                                           GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
	                                                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
	                                                           GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
	                                                           NULL));

	gtk_window_set_modal(dialog, TRUE);
	gtk_window_set_position(dialog, GTK_WIN_POS_CENTER_ON_PARENT);

	if (!string_empty(path)) {
		gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path);
	}

	char *filename = 0;
	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
		filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
	}

	dialog.destroy();

	return filename;
}

const char *
file_dialog(ui::Window parent, bool open, const char *title, const char *path, const char *pattern, bool want_load,
            bool want_import, bool want_save)
{
	for (;;) {
		const char *file = file_dialog_show(parent, open, title, path, pattern, want_load, want_import, want_save);

		if (open
		    || !file
		    || !file_exists(file)
		    || ui::alert(parent, "The file specified already exists.\nDo you want to replace it?", title,
		                 ui::alert_type::NOYES, ui::alert_icon::Question) == ui::alert_response::YES) {
			return file;
		}
	}
}