/* See VikDataSourceInterface */
static void datasource_file_get_process_options ( datasource_file_widgets_t *widgets, ProcessOptions *po, gpointer not_used, const gchar *not_used2, const gchar *not_used3 )
{
/* Retrieve the file selected */
gchar *filename = gtk_file_chooser_get_filename ( GTK_FILE_CHOOSER(widgets->file) );
/* Memorize the directory for later use */
g_free (last_folder_uri);
last_folder_uri = gtk_file_chooser_get_current_folder_uri ( GTK_FILE_CHOOSER(widgets->file) );
/* Memorize the file filter for later use */
GtkFileFilter *filter = gtk_file_chooser_get_filter ( GTK_FILE_CHOOSER(widgets->file) );
last_file_filter = g_object_get_data ( G_OBJECT(filter), "Babel" );
/* Retrieve and memorize file format selected */
gchar *type = NULL;
last_type = gtk_combo_box_get_active ( GTK_COMBO_BOX (widgets->type) );
type = (a_babel_ui_file_type_selector_get ( widgets->type ))->name;
/* Generate the process options */
po->babelargs = g_strdup_printf( "-i %s", type);
po->filename = g_strdup(filename);
/* Free memory */
g_free (filename);
g_debug(_("using babel args '%s' and file '%s'"), po->babelargs, po->filename);
}
/* See VikDataSourceInterface */
static void datasource_file_get_cmd_string ( datasource_file_widgets_t *widgets, gchar **cmd, gchar **input_file )
{
gchar *filename, *type;
/* Retrieve the file selected */
filename = gtk_file_chooser_get_filename ( GTK_FILE_CHOOSER(widgets->file) );
/* Memorize the directory for later use */
g_free (last_folder_uri);
last_folder_uri = gtk_file_chooser_get_current_folder_uri ( GTK_FILE_CHOOSER(widgets->file) );
last_folder_uri = g_strdup (last_folder_uri);
/* Memorize the file filter for later use */
GtkFileFilter *filter = gtk_file_chooser_get_filter ( GTK_FILE_CHOOSER(widgets->file) );
last_file_filter = g_object_get_data ( G_OBJECT(filter), "Babel" );
/* Retrieve and memorize file format selected */
last_type = gtk_combo_box_get_active ( GTK_COMBO_BOX (widgets->type) );
type = ((BabelFile*)g_list_nth_data (a_babel_file_list, last_type))->name;
/* Build the string */
*cmd = g_strdup_printf( "-i %s", type);
*input_file = g_strdup(filename);
/* Free memory */
g_free (filename);
g_debug(_("using babel args '%s' and file '%s'"), *cmd, *input_file);
}
int GtkToolkitFileChooser::GetSelectedFilter()
{
GSList* list = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(m_dialog));
GtkFileFilter* selected_filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(m_dialog));
return g_slist_index(list, selected_filter);
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1get_1filter
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
GtkFileFilter* result;
jlong _result;
GtkFileChooser* self;
// convert parameter self
self = (GtkFileChooser*) _self;
// call function
result = gtk_file_chooser_get_filter(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jlong) result;
// cleanup return value
if (result != NULL) {
bindings_java_memory_cleanup((GObject*)result, FALSE);
}
// and finally
return _result;
}
void
nsFilePicker::ReadValuesFromFileChooser(GtkWidget *file_chooser)
{
mFiles.Clear();
if (mMode == nsIFilePicker::modeOpenMultiple) {
mFileURL.Truncate();
GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser));
g_slist_foreach(list, ReadMultipleFiles, static_cast<gpointer>(&mFiles));
g_slist_free(list);
} else {
gchar *filename = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(file_chooser));
mFileURL.Assign(filename);
g_free(filename);
}
GtkFileFilter *filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(file_chooser));
GSList *filter_list = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(file_chooser));
mSelectedType = static_cast<PRInt16>(g_slist_index(filter_list, filter));
g_slist_free(filter_list);
// Remember last used directory.
nsCOMPtr<nsILocalFile> file;
GetFile(getter_AddRefs(file));
if (file) {
nsCOMPtr<nsIFile> dir;
file->GetParent(getter_AddRefs(dir));
nsCOMPtr<nsILocalFile> localDir(do_QueryInterface(dir));
if (localDir) {
localDir.swap(mPrevDisplayDirectory);
}
}
}
void
ui_signal_export (GtkMenuItem * item, gpointer data)
{
GtkWidget *dialog;
GtkWidget *window = GET_OBJECT("window");
GtkFileFilter * filter_auto;
GtkFileFilter * filter_pdf;
GtkFileFilter * filter_svg;
GtkFileFilter * filter_png;
dialog = gtk_file_chooser_dialog_new (_("Export"),
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
/* Set filters */
filter_auto = gtk_file_filter_new();
filter_pdf = gtk_file_filter_new();
filter_svg = gtk_file_filter_new();
filter_png = gtk_file_filter_new();
gtk_file_filter_add_pattern (filter_auto, "*");
gtk_file_filter_add_mime_type (filter_pdf, "application/pdf");
gtk_file_filter_add_mime_type (filter_svg, "image/svg+xml");
gtk_file_filter_add_mime_type (filter_png, "image/png");
gtk_file_filter_set_name (filter_pdf, "Portable Document Format (PDF)");
gtk_file_filter_set_name (filter_svg, "Scalable Vector Graphcis (SVG)");
gtk_file_filter_set_name (filter_png, "Portable Networks Graphcis (PNG)");
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_png);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_pdf);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_svg);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
char *filename;
char * ext;
gint width, height;
GtkFileFilter * filter;
gboolean successp;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog));
gdk_window_get_size (hexboard->window, &width, &height);
if (filter == filter_pdf)
ext = "pdf";
else if (filter == filter_png)
ext = "png";
else if (filter == filter_svg)
ext = "svg";
successp = hexboard_save_as_image (HEXBOARD(hexboard), filename, ext, width, height);
if (!successp)
g_message (_("An error ocurred while export the board."));
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Board was exported to %s."), filename);
g_free (filename);
}
gtk_widget_destroy (dialog);
}
Php::Value GtkFileChooserDialog_::get_filter()
{
GtkFileFilter *ret = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER(instance));
GtkFileFilter_ *return_parsed = new GtkFileFilter_();
return_parsed->set_instance((gpointer *)ret);
return Php::Object("GtkFileFilter", return_parsed);
}
static void reset_filter (GtkWidget *widget, GParamSpec *spec, gpointer user_data)
{
if (!gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (widget))) {
g_signal_handlers_block_by_func (widget, reset_filter, user_data);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (widget), GTK_FILE_FILTER (user_data));
g_signal_handlers_unblock_by_func (widget, reset_filter, user_data);
}
}
const char * get_current_filter_name ( GtkWidget * dialog )
{
GtkFileFilter *filter ;
filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER ( dialog ) );
if ( filter != NULL )
return ( gtk_file_filter_get_name ( filter ) );
else
return "\0" ;
}
static void load_profile_from_file_cb(RoccatProfilePage *profile_page, gpointer user_data) {
ArvoconfigWindow *window = ARVOCONFIG_WINDOW(user_data);
ArvoconfigWindowPrivate *priv = window->priv;
GtkWidget *dialog;
gchar *filename, *path;
GError *error = NULL;
GtkFileFilter *windows_filter;
GtkFileFilter *linux_filter;
GtkFileFilter *all_filter;
GtkFileFilter *filter;
ArvoRkp *rkp;
dialog = gtk_file_chooser_dialog_new(_("Load profile"),
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
windows_filter = windows_file_filter_new();
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), windows_filter);
linux_filter = linux_file_filter_new();
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), linux_filter);
all_filter = all_file_filter_new();
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), all_filter);
path = arvo_configuration_get_rkp_save_path(priv->config);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path);
g_free(path);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog));
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
path = g_path_get_dirname(filename);
arvo_configuration_set_rkp_save_path(priv->config, path);
g_free(path);
rkp = arvo_rkp_read_with_path(filename, &error);
if (filter != linux_filter)
arvo_windows_rkp_to_linux(rkp);
if (error) {
roccat_warning_dialog(GTK_WINDOW(dialog), _("Could not load profile"), error->message);
g_error_free(error);
} else {
arvo_rkp_set_modified(rkp);
arvoconfig_profile_page_set_rkp(ARVOCONFIG_PROFILE_PAGE(profile_page), rkp);
arvo_rkp_free(rkp);
}
g_free(filename);
}
gtk_widget_destroy(dialog);
}
void GtkToolkitFileChooser::FilterChanged()
{
GtkFileFilter* current_filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(m_dialog));
if (m_action == GTK_FILE_CHOOSER_ACTION_SAVE && current_filter)
{
int filter_index = GetSelectedFilter();
gchar * current_full_filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(m_dialog));
if (current_full_filename)
{
char* current_filename = basename((char *)current_full_filename);
GString *file_extension; // or use gchar
file_extension = static_cast<GString*>(g_slist_nth_data(m_extensions, filter_index));
if (file_extension)
{
char *extension = (char *)file_extension->str;
int extpos = 0;
for (size_t i=0; i< strlen(extension); i++)
if (extension[i] == '.')
extpos = i;
if (extpos > 0 && strlen(extension) > 2 && strstr(extension, "*.") && !strstr(extension, "*.*")) // Check this one
{
GString *current_filename_g = g_string_new(current_filename);
if (current_filename_g)
{
char *ptr = (char *)current_filename;
int len = strlen(ptr);
int pos = len;
for (int i=0; i<len; i++)
if (ptr[i] == '.')
pos = i;
g_string_erase(current_filename_g, (gssize)pos, (gssize)(len-pos));
g_string_append(current_filename_g, (gchar*)extension+extpos);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(m_dialog), current_filename_g->str);
gchar * current_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(m_dialog));
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(m_dialog), current_folder);
g_free(current_folder);
g_string_free(current_filename_g, TRUE);
}
}
}
g_free(current_full_filename); // Check this one
}
}
}
static hex_format_t
dialog_selected_format (GtkWidget * dialog)
{
GtkFileFilter * filter;
filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog));
if (filter == filter_auto)
return HEX_AUTO;
else if (filter == filter_sgf)
return HEX_SGF;
else if (filter == filter_lg_sgf)
return HEX_LG_SGF;
else
abort ();
}
int wxGtkFileChooser::GetFilterIndex() const
{
GtkFileChooser *chooser = m_widget;
GtkFileFilter *filter = gtk_file_chooser_get_filter( chooser );
GSList *filters = gtk_file_chooser_list_filters( chooser );
const gint index = g_slist_index( filters, filter );
g_slist_free( filters );
if ( index == -1 )
{
wxFAIL_MSG( wxT( "wxGtkFileChooser::GetFilterIndex - bad filter index returned by gtk+" ) );
return 0;
}
else
return index;
}
int FileDialog::GetFilterIndex() const
{
GtkFileChooser *chooser = GTK_FILE_CHOOSER(m_widget);
GtkFileFilter *filter = gtk_file_chooser_get_filter(chooser);
GSList *filters = gtk_file_chooser_list_filters(chooser);
gint index = g_slist_index(filters, filter);
g_slist_free(filters);
if (index == -1)
{
wxFAIL_MSG( wxT("FileDialog::GetFilterIndex - bad filter index returned by gtk+") );
return 0;
}
else
return index;
}
gchar *file_chooser_get_extension(GtkWidget * chooser, FileTypes * filters)
{
GtkFileFilter *filter;
const gchar *filter_name;
gint i;
filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(chooser));
filter_name = gtk_file_filter_get_name(filter);
for (i = 0; filters[i].name; i++) {
if (g_str_equal(filter_name, filters[i].name)) {
return filters[i].extension;
}
}
return NULL;
}
void ui_save_file_cb(GtkWidget* widget, gpointer data)
{
GtkWidget *filedialog;
GtkFileFilter *filefilter;
filedialog = gtk_file_chooser_dialog_new("Save...",
GTK_WINDOW(ui_window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE,
GTK_RESPONSE_ACCEPT,
NULL);
GList *handlers = io_get_save_handlers();
GList *iter;
for(iter = g_list_first(handlers); iter; iter = g_list_next(iter)) {
plugin_save_handler_t *handler = (plugin_save_handler_t *) iter->data;
filefilter = gtk_file_filter_new();
gtk_file_filter_set_name(GTK_FILE_FILTER(filefilter),
handler->desc);
int i;
for(i=0; i<handler->nfilters; i++) {
gtk_file_filter_add_pattern(GTK_FILE_FILTER(filefilter),
(char*) handler->filters[i]);
}
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filedialog),
filefilter);
g_object_set_data(G_OBJECT(filefilter), "handler", (gpointer) handler);
}
g_list_free(handlers);
if(gtk_dialog_run(GTK_DIALOG(filedialog)) == GTK_RESPONSE_ACCEPT) {
GtkWidget* filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(filedialog));
plugin_save_handler_t *handler = g_object_get_data(G_OBJECT(filter), "handler");
gchar *path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filedialog));
io_save_image(path, handler);
}
gtk_widget_destroy(GTK_WIDGET(filedialog));
}
int wxFileDialog::GetFilterIndex() const
{
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
GtkFileChooser *chooser = GTK_FILE_CHOOSER(m_widget);
GtkFileFilter *filter = gtk_file_chooser_get_filter(chooser);
GSList *filters = gtk_file_chooser_list_filters(chooser);
gint index = g_slist_index(filters, filter);
g_slist_free(filters);
if (index == -1)
{
wxFAIL_MSG( wxT("wxFileDialog::GetFilterIndex - bad filter index returned by gtk+") );
return 0;
}
else
return index;
}
else
#endif
return wxGenericFileDialog::GetFilterIndex();
}
int
clip_GTK_FILECHOOSERGETFILTER(ClipMachine * ClipMachineMemory)
{
C_object *cchooser = _fetch_co_arg(ClipMachineMemory);
C_object *cfilter;
GtkFileFilter *filter;
CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object));
filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(cchooser->object));
if (filter)
{
cfilter = _list_get_cobject(ClipMachineMemory, filter);
if (!cfilter)
cfilter = _register_object(ClipMachineMemory, filter, GTK_TYPE_FILE_FILTER, NULL, NULL);
if (cfilter)
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cfilter->obj);
}
return 0;
err:
return 1;
}
static void
on_chooser_dialog_response (GtkDialog *dialog, gint response_id, gpointer user_data)
{
GcrCertificateExporter *self = GCR_CERTIFICATE_EXPORTER (user_data);
GtkFileFilter *filter;
PrepareDataFunc prepare_data;
if (response_id != GTK_RESPONSE_ACCEPT) {
g_set_error (&self->pv->error, G_IO_ERROR, G_IO_ERROR_CANCELLED,
_("The operation was cancelled."));
complete_async_result (self);
return;
}
if (self->pv->output_file)
g_object_unref (self->pv->output_file);
self->pv->output_file = gtk_file_chooser_get_file (self->pv->chooser_dialog);
g_return_if_fail (self->pv->output_file);
filter = gtk_file_chooser_get_filter (self->pv->chooser_dialog);
prepare_data = g_object_get_data (G_OBJECT (filter), "prepare-data-func");
g_assert (prepare_data);
if (self->pv->buffer)
g_byte_array_free (self->pv->buffer, TRUE);
self->pv->buffer = NULL;
self->pv->buffer_at = 0;
/* Prepare the for writing out */
(prepare_data) (self);
/* Try to open the file */
g_file_create_async (self->pv->output_file, G_FILE_CREATE_NONE, G_PRIORITY_DEFAULT,
self->pv->cancellable, on_create_file_ready,
self);
}
static void
fsok(GtkWidget *dlg)
{
struct nGetOpenFileData *data;
char *file, *file2, **farray;
const char *filter_name;
int i, k, len, n;
GStatBuf buf;
GSList *top, *list;
GtkFileFilter *filter;
data = &FileSelection;
top = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dlg));
filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dlg));
if (filter) {
filter_name = gtk_file_filter_get_name(filter);
} else {
filter_name = NULL;
}
if (filter_name == NULL || strcmp(filter_name, _("All")) == 0) {
data->ext = NULL;
}
n = g_slist_length(top);
farray = g_malloc(sizeof(*farray) * (n + 1));
if (farray == NULL) {
free_str_list(top);
return;
}
data->file = farray;
k = 0;
for (list = top; list; list = list->next) {
char *tmp;
tmp = (char *) list->data;
if (tmp == NULL || strlen(tmp) < 1) {
gdk_beep();
continue;
}
file = get_utf8_filename(tmp);
for (i = strlen(file) - 1; (i > 0) && (file[i] != '/') && (file[i] != '.'); i--);
if ((file[i] != '.') && data->ext) {
len = strlen(data->ext) + 1;
} else {
len = 0;
}
if (len) {
file2 = g_strdup_printf("%s.%s", file, data->ext);
g_free(file);
} else {
file2 = file;
}
if (file2) {
if (data->mustexist) {
if ((nstat(file2, &buf) != 0) || ((buf.st_mode & S_IFMT) != S_IFREG)
|| (naccess(file2, R_OK) != 0)) {
gdk_beep();
error22(NULL, 0, "I/O error", file2);
g_free(file2);
continue;
}
} else {
if ((nstat(file2, &buf) == 0) && ((buf.st_mode & S_IFMT) != S_IFREG)) {
gdk_beep();
error22(NULL, 0, "I/O error", file2);
g_free(file2);
continue;
}
}
farray[k] = file2;
k++;
}
}
if (k == 0)
return;
if (data->changedir && k > 0) {
data->chdir = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->chdir_cb));
if (data->chdir && data->init_dir) {
char *dir;
g_free(*(data->init_dir));
dir = g_path_get_dirname(farray[0]);
*(data->init_dir) = dir;
}
}
farray[k] = NULL;
free_str_list(top);
data->ret = IDOK;
}
gboolean
gtk_file_chooser_native_win32_show (GtkFileChooserNative *self)
{
GThread *thread;
FilechooserWin32ThreadData *data;
GtkWindow *transient_for;
GtkFileChooserAction action;
guint update_preview_signal;
GSList *filters, *l;
int n_filters, i;
if (gtk_file_chooser_get_extra_widget (GTK_FILE_CHOOSER (self)) != NULL)
return FALSE;
update_preview_signal = g_signal_lookup ("update-preview", GTK_TYPE_FILE_CHOOSER);
if (g_signal_has_handler_pending (self, update_preview_signal, 0, TRUE))
return FALSE;
data = g_new0 (FilechooserWin32ThreadData, 1);
filters = gtk_file_chooser_list_filters (GTK_FILE_CHOOSER (self));
n_filters = g_slist_length (filters);
if (n_filters > 0)
{
data->filters = g_new0 (COMDLG_FILTERSPEC, n_filters + 1);
for (l = filters, i = 0; l != NULL; l = l->next, i++)
{
if (!file_filter_to_win32 (l->data, &data->filters[i]))
{
filechooser_win32_thread_data_free (data);
return FALSE;
}
}
self->current_filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (self));
}
else
{
self->current_filter = NULL;
}
self->mode_data = data;
data->self = g_object_ref (self);
data->shortcut_uris =
gtk_file_chooser_list_shortcut_folder_uris (GTK_FILE_CHOOSER (self->dialog));
data->accept_label = translate_mnemonics (self->accept_label);
data->cancel_label = translate_mnemonics (self->cancel_label);
action = gtk_file_chooser_get_action (GTK_FILE_CHOOSER (self->dialog));
if (action == GTK_FILE_CHOOSER_ACTION_SAVE ||
action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
data->save = TRUE;
if (action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
data->folder = TRUE;
if ((action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
action == GTK_FILE_CHOOSER_ACTION_OPEN) &&
gtk_file_chooser_get_select_multiple (GTK_FILE_CHOOSER (self->dialog)))
data->select_multiple = TRUE;
if (gtk_file_chooser_get_do_overwrite_confirmation (GTK_FILE_CHOOSER (self->dialog)))
data->overwrite_confirmation = TRUE;
if (gtk_file_chooser_get_show_hidden (GTK_FILE_CHOOSER (self->dialog)))
data->show_hidden = TRUE;
transient_for = gtk_native_dialog_get_transient_for (GTK_NATIVE_DIALOG (self));
if (transient_for)
{
gtk_widget_realize (GTK_WIDGET (transient_for));
data->parent = gdk_win32_surface_get_handle (gtk_widget_get_surface (GTK_WIDGET (transient_for)));
if (gtk_native_dialog_get_modal (GTK_NATIVE_DIALOG (self)))
data->modal = TRUE;
}
data->title =
g_strdup (gtk_native_dialog_get_title (GTK_NATIVE_DIALOG (self)));
if (self->current_file)
data->current_file = g_object_ref (self->current_file);
else
{
if (self->current_folder)
data->current_folder = g_object_ref (self->current_folder);
if (action == GTK_FILE_CHOOSER_ACTION_SAVE ||
action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
data->current_name = g_strdup (self->current_name);
}
data->events = file_dialog_events_new (!data->modal, data);
thread = g_thread_new ("win32 filechooser", filechooser_win32_thread, data);
if (thread == NULL)
{
filechooser_win32_thread_data_free (data);
return FALSE;
}
return TRUE;
}
bool wxGtkFileChooser::HasFilterChoice() const
{
return gtk_file_chooser_get_filter( m_widget ) != NULL;
}
static char *
gtk_openfile( Bool open)
{
char *result = NULL;
struct MsgDlg message_dlg, **storage;
if ( gtk_dialog) return NULL; /* we're not reentrant */
gtk_dialog = gtk_file_chooser_dialog_new (
gtk_dialog_title_ptr ?
gtk_dialog_title_ptr :
( open ? "Open File" : "Save File"),
NULL,
open ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_local_only( GTK_FILE_CHOOSER (gtk_dialog), TRUE);
if (open)
gtk_file_chooser_set_select_multiple( GTK_FILE_CHOOSER (gtk_dialog), gtk_select_multiple);
#if GTK_MAJOR_VERSION >= 2 && GTK_MINOR_VERSION >= 8
gtk_file_chooser_set_do_overwrite_confirmation( GTK_FILE_CHOOSER (gtk_dialog), gtk_overwrite_prompt);
gtk_file_chooser_set_show_hidden( GTK_FILE_CHOOSER (gtk_dialog), gtk_show_hidden_files);
#endif
if ( gtk_current_folder_ptr)
gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER (gtk_dialog), gtk_current_folder_ptr);
if ( gtk_filters) {
int i;
for ( i = 0; i < gtk_filters-> count; i++) {
gtk_file_chooser_add_filter(
GTK_FILE_CHOOSER (gtk_dialog),
GTK_FILE_FILTER (gtk_filters-> items[i])
);
if ( i == gtk_filter_index)
gtk_file_chooser_set_filter(
GTK_FILE_CHOOSER (gtk_dialog),
GTK_FILE_FILTER (gtk_filters-> items[i])
);
}
}
/* lock prima interactions */
bzero( &message_dlg, sizeof(message_dlg));
storage = &guts. message_boxes;
while ( *storage) storage = &((*storage)-> next);
*storage = &message_dlg;
g_idle_add( do_events, NULL);
if (gtk_dialog_run (GTK_DIALOG (gtk_dialog)) == GTK_RESPONSE_ACCEPT) {
/* files */
if ( gtk_select_multiple) {
int size;
char * ptr;
GSList *names, *iter;
names = gtk_file_chooser_get_filenames ( GTK_FILE_CHOOSER (gtk_dialog));
/* count total length with escaped spaces and backslashes */
size = 1;
iter = names;
while ( iter) {
char * c = (char*) iter-> data;
while ( *c) {
if ( *c == ' ' || *c == '\\')
size++;
size++;
c++;
}
size++;
iter = iter-> next;
}
if (( result = ptr = malloc( size))) {
/* copy and encode */
iter = names;
while ( iter) {
char * c = (char*) iter-> data;
while ( *c) {
if ( *c == ' ' || *c == '\\')
*(ptr++) = '\\';
*(ptr++) = *c;
c++;
}
iter = iter-> next;
*(ptr++) = ' ';
}
*(ptr - 1) = 0;
} else {
warn("gtk_openfile: cannot allocate %d bytes of memory", size);
}
/* free */
iter = names;
while ( iter) {
g_free( iter-> data);
iter = iter-> next;
}
g_slist_free( names);
} else {
char * filename = gtk_file_chooser_get_filename ( GTK_FILE_CHOOSER (gtk_dialog));
result = duplicate_string( filename);
g_free (filename);
}
/* directory */
{
char * d = gtk_file_chooser_get_current_folder( GTK_FILE_CHOOSER (gtk_dialog));
if ( d) {
strncpy( gtk_current_folder, d, MAXPATHLEN);
gtk_current_folder_ptr = gtk_current_folder;
g_free( d);
} else {
gtk_current_folder_ptr = NULL;
}
}
/* filter index */
gtk_filter_index = 0;
if ( gtk_filters) {
int i;
Handle f = ( Handle) gtk_file_chooser_get_filter( GTK_FILE_CHOOSER (gtk_dialog));
for ( i = 0; i < gtk_filters-> count; i++)
if ( gtk_filters-> items[i] == f) {
gtk_filter_index = i;
break;
}
}
}
if ( gtk_filters) {
plist_destroy( gtk_filters);
gtk_filters = NULL;
}
*storage = message_dlg. next; /* unlock */
gtk_widget_destroy (gtk_dialog);
gtk_dialog = NULL;
while ( gtk_events_pending()) gtk_main_iteration();
return result;
}
char* get_save_filename( GtkWindow* parent, const char* cwd, char** type )
{
char* file = NULL;
GtkFileChooser* dlg = (GtkFileChooser*)gtk_file_chooser_dialog_new( NULL, parent,
GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL );
GSList* modules, *module;
GtkFileFilter *filter;
gtk_file_chooser_set_current_folder( dlg, cwd );
GtkWidget* img = gtk_image_new();
gtk_widget_set_size_request( img, 128, 128 );
gtk_file_chooser_set_preview_widget( dlg, img );
g_signal_connect( dlg, "update-preview", G_CALLBACK(on_update_preview), img );
g_signal_connect( dlg, "notify::filter", G_CALLBACK(on_file_save_filter_changed), NULL );
/*
/// TODO: determine file type from file name
filter = gtk_file_filter_new();
gtk_file_filter_set_name( filter, _("Determined by File Name") );
gtk_file_filter_add_pixbuf_formats( filter );
gtk_file_chooser_add_filter( dlg, filter );
*/
modules = gdk_pixbuf_get_formats();
for( module = modules; module; module = module->next )
{
char *name, *desc, *tmp;
char **exts, **mimes, **mime;
GdkPixbufFormat* format = (GdkPixbufFormat*)module->data;
if( ! gdk_pixbuf_format_is_writable( format ) )
continue;
filter = gtk_file_filter_new();
name = gdk_pixbuf_format_get_name( format );
desc = gdk_pixbuf_format_get_description( format );
exts = gdk_pixbuf_format_get_extensions( format );
mimes = gdk_pixbuf_format_get_mime_types( format );
tmp = g_strdup_printf( "%s (*.%s)", desc, exts[0], NULL );
g_object_set_data_full(G_OBJECT(filter), "type", name, (GDestroyNotify)g_free);
g_strfreev(exts);
g_free( desc );
gtk_file_filter_set_name( filter, tmp );
g_free( tmp );
for( mime = mimes; *mime ; ++mime )
gtk_file_filter_add_mime_type( filter, *mime );
g_strfreev( mimes );
gtk_file_chooser_add_filter( dlg, filter );
}
g_slist_free( modules );
int initial_jpg_quality = pref.jpg_quality;
int initial_png_compression = pref.png_compression;
if( gtk_dialog_run( (GtkDialog*)dlg ) == GTK_RESPONSE_OK )
{
filter = gtk_file_chooser_get_filter( dlg );
file = gtk_file_chooser_get_filename( dlg );
*type = g_object_steal_data(G_OBJECT(filter), "type");
if( !*type ) // auto detection
{
/// TODO: auto file type
}
else
{
/* TODO: append appropriate extension if needed. */
}
}
gtk_widget_destroy( (GtkWidget*)dlg );
if ((initial_jpg_quality != pref.jpg_quality) || (initial_png_compression != pref.png_compression))
save_preferences();
return file;
}
static void save_profile_to_file_cb(RoccatProfilePage *profile_page, gpointer user_data) {
ArvoconfigWindow *window = ARVOCONFIG_WINDOW(user_data);
ArvoconfigWindowPrivate *priv = window->priv;
GtkWidget *dialog;
gchar *filename, *path;
gchar *temp_filename;
GError *error = NULL;
GtkFileFilter *windows_filter;
GtkFileFilter *linux_filter;
GtkFileFilter *all_filter;
GtkFileFilter *filter;
guint profile_index = roccat_config_window_get_page_index(ROCCAT_CONFIG_WINDOW(window), profile_page);
ArvoRkp *rkp;
rkp = arvoconfig_profile_page_get_rkp(ARVOCONFIG_PROFILE_PAGE(profile_page));
dialog = gtk_file_chooser_dialog_new(_("Save profile"),
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
windows_filter = windows_file_filter_new();
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), windows_filter);
linux_filter = linux_file_filter_new();
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), linux_filter);
all_filter = all_file_filter_new();
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), all_filter);
path = arvo_configuration_get_rkp_save_path(priv->config);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path);
g_free(path);
filename = arvo_create_filename_proposition(rkp, profile_index);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), filename);
g_free(filename);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog));
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
temp_filename = roccat_create_filename_with_extension(filename, ROCCAT_KEYBOARD_PROFILE_EXTENSION);
g_free(filename);
path = g_path_get_dirname(temp_filename);
arvo_configuration_set_rkp_save_path(priv->config, path);
g_free(path);
if (filter != linux_filter)
arvo_linux_rkp_to_windows(rkp);
arvo_rkp_write_with_path(temp_filename, rkp, &error);
g_free(temp_filename);
if (error) {
roccat_warning_dialog(GTK_WINDOW(dialog), _("Could not save profile"), error->message);
g_error_free(error);
}
}
gtk_widget_destroy(dialog);
arvo_rkp_free(rkp);
}
static void on_file_save_filter_changed(GObject* obj, GParamSpec* pspec, gpointer user_data)
{
GtkFileChooser* dlg = (GtkFileChooser*)obj;
GtkFileFilter* filter = gtk_file_chooser_get_filter( dlg );
const char* type = (const char*)g_object_get_data(G_OBJECT(filter), "type");
GtkWidget* extra = gtk_file_chooser_get_extra_widget(dlg);
if(extra)
{
gtk_file_chooser_set_extra_widget(dlg, NULL);
extra = NULL;
}
if( type )
{
GtkWidget* label, *label2;
GtkWidget* scale;
if( strcmp( type, "jpeg" ) == 0 )
{
extra = gtk_hbox_new(FALSE, 12);
label = gtk_label_new(_("JPEG Quality:"));
label2 = gtk_label_new(_("Lower quality values yield smaller file sizes,\nbut the image quality will be poorer."));
scale = gtk_hscale_new_with_range( 0, 100, 5 );
gtk_range_set_value(GTK_RANGE(scale), pref.jpg_quality);
#if GTK_CHECK_VERSION(2, 24, 0)
#else
gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DISCONTINUOUS);
#endif
g_signal_connect(G_OBJECT(scale), "value-changed", G_CALLBACK(on_int_val_changed), &pref.jpg_quality);
gtk_scale_set_draw_value(GTK_SCALE(scale), TRUE);
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_RIGHT);
gtk_box_pack_start(GTK_BOX(extra), label, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(extra), scale, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(extra), label2, FALSE, TRUE, 0);
}
else if( strcmp( type, "png" ) == 0 )
{
extra = gtk_hbox_new(FALSE, 12);
label = gtk_label_new(_("PNG Compression Level:"));
label2 = gtk_label_new(_("Higher compression levels yield smaller file sizes,\nbut takes more time to do the compression."));
scale = gtk_hscale_new_with_range( 0, 9, 1 );
gtk_range_set_value(GTK_RANGE(scale), pref.png_compression);
#if GTK_CHECK_VERSION(2, 24, 0)
#else
gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DISCONTINUOUS);
#endif
g_signal_connect(G_OBJECT(scale), "value-changed", G_CALLBACK(on_int_val_changed), &pref.png_compression);
gtk_scale_set_draw_value(GTK_SCALE(scale), TRUE);
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_RIGHT);
gtk_box_pack_start(GTK_BOX(extra), label, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(extra), scale, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(extra), label2, FALSE, TRUE, 0);
}
/* FIXME: provide "depth settings for *.ico files" */
if( extra )
{
gtk_widget_show_all(extra);
gtk_file_chooser_set_extra_widget(dlg, extra);
}
}
}
void image_exporter_export_svg (ImageExporterRenderer renderer, void* renderer_target) {
gchar* filename = NULL;
gchar* _tmp0_ = NULL;
ImageExporterImageFormat imageFormat = 0;
PropertySet* propertySet = NULL;
PropertySet* _tmp1_ = NULL;
PropertyItemSelection* formatProperty = NULL;
PropertyItemSelection* _tmp2_ = NULL;
PropertyItemSelection* _tmp3_ = NULL;
PropertyItemSelection* _tmp4_ = NULL;
PropertyItemSelection* _tmp5_ = NULL;
PropertySet* _tmp6_ = NULL;
PropertyItemSelection* _tmp7_ = NULL;
PropertiesQuery* propertiesQuery = NULL;
PropertySet* _tmp8_ = NULL;
PropertiesQuery* _tmp9_ = NULL;
PropertiesQuery* _tmp10_ = NULL;
gint _tmp11_ = 0;
const gchar* _tmp47_ = NULL;
_tmp0_ = g_strdup ("");
filename = _tmp0_;
imageFormat = IMAGE_EXPORTER_IMAGE_FORMAT_SVG;
_tmp1_ = property_set_new ("SVG Export", "SVG image export options.");
propertySet = _tmp1_;
_tmp2_ = property_item_selection_new ("Background", "The background for the SVG to use.");
formatProperty = _tmp2_;
_tmp3_ = formatProperty;
property_item_selection_add_option (_tmp3_, "White Background", NULL);
_tmp4_ = formatProperty;
property_item_selection_add_option (_tmp4_, "Transparent Background", NULL);
_tmp5_ = formatProperty;
property_item_selection_set_option (_tmp5_, "White Background");
_tmp6_ = propertySet;
_tmp7_ = formatProperty;
property_set_add_item (_tmp6_, (PropertyItem*) _tmp7_);
_tmp8_ = propertySet;
_tmp9_ = properties_query_new ("Export SVG Options", NULL, _tmp8_);
propertiesQuery = _tmp9_;
_tmp10_ = propertiesQuery;
_tmp11_ = properties_query_run (_tmp10_);
if (_tmp11_ == ((gint) GTK_RESPONSE_APPLY)) {
GtkFileFilter* svgFileFilter = NULL;
GtkFileFilter* _tmp12_ = NULL;
GtkFileFilter* _tmp13_ = NULL;
GtkFileFilter* _tmp14_ = NULL;
GtkFileFilter* anyFileFilter = NULL;
GtkFileFilter* _tmp15_ = NULL;
GtkFileFilter* _tmp16_ = NULL;
GtkFileFilter* _tmp17_ = NULL;
GtkFileChooserDialog* fileChooser = NULL;
GtkFileChooserDialog* _tmp18_ = NULL;
GtkFileChooserDialog* _tmp19_ = NULL;
GtkFileFilter* _tmp20_ = NULL;
GtkFileFilter* _tmp21_ = NULL;
GtkFileChooserDialog* _tmp22_ = NULL;
GtkFileFilter* _tmp23_ = NULL;
GtkFileFilter* _tmp24_ = NULL;
GtkFileChooserDialog* _tmp25_ = NULL;
gboolean stillChoosing = FALSE;
GtkFileChooserDialog* _tmp46_ = NULL;
_tmp12_ = gtk_file_filter_new ();
g_object_ref_sink (_tmp12_);
svgFileFilter = _tmp12_;
_tmp13_ = svgFileFilter;
gtk_file_filter_set_name (_tmp13_, "Scalable Vector Graphic (.svg)");
_tmp14_ = svgFileFilter;
gtk_file_filter_add_pattern (_tmp14_, "*.svg");
_tmp15_ = gtk_file_filter_new ();
g_object_ref_sink (_tmp15_);
anyFileFilter = _tmp15_;
_tmp16_ = anyFileFilter;
gtk_file_filter_set_name (_tmp16_, "Any File");
_tmp17_ = anyFileFilter;
gtk_file_filter_add_pattern (_tmp17_, "*");
_tmp18_ = (GtkFileChooserDialog*) gtk_file_chooser_dialog_new ("Export to SVG", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
g_object_ref_sink (_tmp18_);
fileChooser = _tmp18_;
_tmp19_ = fileChooser;
_tmp20_ = svgFileFilter;
_tmp21_ = _g_object_ref0 (_tmp20_);
gtk_file_chooser_add_filter ((GtkFileChooser*) _tmp19_, _tmp21_);
_tmp22_ = fileChooser;
_tmp23_ = anyFileFilter;
_tmp24_ = _g_object_ref0 (_tmp23_);
gtk_file_chooser_add_filter ((GtkFileChooser*) _tmp22_, _tmp24_);
_tmp25_ = fileChooser;
gtk_file_chooser_set_do_overwrite_confirmation ((GtkFileChooser*) _tmp25_, TRUE);
stillChoosing = TRUE;
while (TRUE) {
gboolean _tmp26_ = FALSE;
GtkFileChooserDialog* _tmp27_ = NULL;
gint _tmp28_ = 0;
_tmp26_ = stillChoosing;
if (!_tmp26_) {
break;
}
_tmp27_ = fileChooser;
_tmp28_ = gtk_dialog_run ((GtkDialog*) _tmp27_);
if (_tmp28_ == ((gint) GTK_RESPONSE_ACCEPT)) {
GtkFileChooserDialog* _tmp29_ = NULL;
gchar* _tmp30_ = NULL;
const gchar* _tmp31_ = NULL;
gboolean _tmp32_ = FALSE;
const gchar* _tmp40_ = NULL;
gboolean _tmp41_ = FALSE;
_tmp29_ = fileChooser;
_tmp30_ = gtk_file_chooser_get_filename ((GtkFileChooser*) _tmp29_);
_g_free0 (filename);
filename = _tmp30_;
_tmp31_ = filename;
_tmp32_ = string_contains (_tmp31_, ".");
if (_tmp32_) {
FILE* _tmp33_ = NULL;
_tmp33_ = stdout;
fprintf (_tmp33_, "File extension already given\n");
} else {
GtkFileChooserDialog* _tmp34_ = NULL;
GtkFileFilter* _tmp35_ = NULL;
GtkFileFilter* _tmp36_ = NULL;
GtkFileFilter* _tmp37_ = NULL;
_tmp34_ = fileChooser;
_tmp35_ = gtk_file_chooser_get_filter ((GtkFileChooser*) _tmp34_);
_tmp36_ = _tmp35_;
_tmp37_ = svgFileFilter;
if (_tmp36_ == _tmp37_) {
const gchar* _tmp38_ = NULL;
gchar* _tmp39_ = NULL;
_tmp38_ = filename;
_tmp39_ = g_strconcat (_tmp38_, ".svg", NULL);
_g_free0 (filename);
filename = _tmp39_;
}
}
_tmp40_ = filename;
_tmp41_ = g_file_test (_tmp40_, G_FILE_TEST_EXISTS);
if (_tmp41_) {
GtkFileChooserDialog* _tmp42_ = NULL;
const gchar* _tmp43_ = NULL;
gint _tmp44_ = 0;
_tmp42_ = fileChooser;
_tmp43_ = filename;
_tmp44_ = basic_dialog_ask_overwrite ((GtkWindow*) _tmp42_, _tmp43_);
if (_tmp44_ == ((gint) GTK_RESPONSE_YES)) {
stillChoosing = FALSE;
}
} else {
stillChoosing = FALSE;
}
} else {
GtkFileChooserDialog* _tmp45_ = NULL;
_tmp45_ = fileChooser;
gtk_widget_destroy ((GtkWidget*) _tmp45_);
_g_object_unref0 (fileChooser);
_g_object_unref0 (anyFileFilter);
_g_object_unref0 (svgFileFilter);
_properties_query_unref0 (propertiesQuery);
_property_item_unref0 (formatProperty);
_property_item_unref0 (propertySet);
_g_free0 (filename);
return;
}
}
_tmp46_ = fileChooser;
gtk_widget_destroy ((GtkWidget*) _tmp46_);
_g_object_unref0 (fileChooser);
_g_object_unref0 (anyFileFilter);
_g_object_unref0 (svgFileFilter);
}
_tmp47_ = filename;
if (g_strcmp0 (_tmp47_, "") != 0) {
PropertySet* _tmp48_ = NULL;
gchar* _tmp49_ = NULL;
gchar* _tmp50_ = NULL;
GQuark _tmp52_ = 0U;
static GQuark _tmp51_label0 = 0;
static GQuark _tmp51_label1 = 0;
ImageExporterRenderer _tmp53_ = NULL;
void* _tmp53__target = NULL;
const gchar* _tmp54_ = NULL;
ImageExporterImageFormat _tmp55_ = 0;
_tmp48_ = propertySet;
_tmp49_ = property_item_selection_get_data (_tmp48_, "Background");
_tmp50_ = _tmp49_;
_tmp52_ = (NULL == _tmp50_) ? 0 : g_quark_from_string (_tmp50_);
g_free (_tmp50_);
if (_tmp52_ == ((0 != _tmp51_label0) ? _tmp51_label0 : (_tmp51_label0 = g_quark_from_static_string ("White Background")))) {
switch (0) {
default:
{
imageFormat = IMAGE_EXPORTER_IMAGE_FORMAT_SVG;
break;
}
}
} else if (_tmp52_ == ((0 != _tmp51_label1) ? _tmp51_label1 : (_tmp51_label1 = g_quark_from_static_string ("Transparent Background")))) {
switch (0) {
default:
{
imageFormat = IMAGE_EXPORTER_IMAGE_FORMAT_SVG_CLEAR;
break;
}
}
}
_tmp53_ = renderer;
_tmp53__target = renderer_target;
_tmp54_ = filename;
_tmp55_ = imageFormat;
_tmp53_ (_tmp54_, _tmp55_, (gdouble) 1, _tmp53__target);
}
_properties_query_unref0 (propertiesQuery);
_property_item_unref0 (formatProperty);
_property_item_unref0 (propertySet);
_g_free0 (filename);
}
void image_exporter_export_pdf (ImageExporterRenderer renderer, void* renderer_target) {
gchar* filename = NULL;
gchar* _tmp0_ = NULL;
GtkFileFilter* pdfFileFilter = NULL;
GtkFileFilter* _tmp1_ = NULL;
GtkFileFilter* _tmp2_ = NULL;
GtkFileFilter* _tmp3_ = NULL;
GtkFileFilter* anyFileFilter = NULL;
GtkFileFilter* _tmp4_ = NULL;
GtkFileFilter* _tmp5_ = NULL;
GtkFileFilter* _tmp6_ = NULL;
GtkFileChooserDialog* fileChooser = NULL;
GtkFileChooserDialog* _tmp7_ = NULL;
GtkFileChooserDialog* _tmp8_ = NULL;
GtkFileFilter* _tmp9_ = NULL;
GtkFileFilter* _tmp10_ = NULL;
GtkFileChooserDialog* _tmp11_ = NULL;
GtkFileFilter* _tmp12_ = NULL;
GtkFileFilter* _tmp13_ = NULL;
GtkFileChooserDialog* _tmp14_ = NULL;
gboolean stillChoosing = FALSE;
GtkFileChooserDialog* _tmp35_ = NULL;
const gchar* _tmp36_ = NULL;
_tmp0_ = g_strdup ("");
filename = _tmp0_;
_tmp1_ = gtk_file_filter_new ();
g_object_ref_sink (_tmp1_);
pdfFileFilter = _tmp1_;
_tmp2_ = pdfFileFilter;
gtk_file_filter_set_name (_tmp2_, "Portable Document Format (.pdf)");
_tmp3_ = pdfFileFilter;
gtk_file_filter_add_pattern (_tmp3_, "*.pdf");
_tmp4_ = gtk_file_filter_new ();
g_object_ref_sink (_tmp4_);
anyFileFilter = _tmp4_;
_tmp5_ = anyFileFilter;
gtk_file_filter_set_name (_tmp5_, "Any File");
_tmp6_ = anyFileFilter;
gtk_file_filter_add_pattern (_tmp6_, "*");
_tmp7_ = (GtkFileChooserDialog*) gtk_file_chooser_dialog_new ("Export to PDF", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
g_object_ref_sink (_tmp7_);
fileChooser = _tmp7_;
_tmp8_ = fileChooser;
_tmp9_ = pdfFileFilter;
_tmp10_ = _g_object_ref0 (_tmp9_);
gtk_file_chooser_add_filter ((GtkFileChooser*) _tmp8_, _tmp10_);
_tmp11_ = fileChooser;
_tmp12_ = anyFileFilter;
_tmp13_ = _g_object_ref0 (_tmp12_);
gtk_file_chooser_add_filter ((GtkFileChooser*) _tmp11_, _tmp13_);
_tmp14_ = fileChooser;
gtk_file_chooser_set_do_overwrite_confirmation ((GtkFileChooser*) _tmp14_, TRUE);
stillChoosing = TRUE;
while (TRUE) {
gboolean _tmp15_ = FALSE;
GtkFileChooserDialog* _tmp16_ = NULL;
gint _tmp17_ = 0;
_tmp15_ = stillChoosing;
if (!_tmp15_) {
break;
}
_tmp16_ = fileChooser;
_tmp17_ = gtk_dialog_run ((GtkDialog*) _tmp16_);
if (_tmp17_ == ((gint) GTK_RESPONSE_ACCEPT)) {
GtkFileChooserDialog* _tmp18_ = NULL;
gchar* _tmp19_ = NULL;
const gchar* _tmp20_ = NULL;
gboolean _tmp21_ = FALSE;
const gchar* _tmp29_ = NULL;
gboolean _tmp30_ = FALSE;
_tmp18_ = fileChooser;
_tmp19_ = gtk_file_chooser_get_filename ((GtkFileChooser*) _tmp18_);
_g_free0 (filename);
filename = _tmp19_;
_tmp20_ = filename;
_tmp21_ = string_contains (_tmp20_, ".");
if (_tmp21_) {
FILE* _tmp22_ = NULL;
_tmp22_ = stdout;
fprintf (_tmp22_, "File extension already given\n");
} else {
GtkFileChooserDialog* _tmp23_ = NULL;
GtkFileFilter* _tmp24_ = NULL;
GtkFileFilter* _tmp25_ = NULL;
GtkFileFilter* _tmp26_ = NULL;
_tmp23_ = fileChooser;
_tmp24_ = gtk_file_chooser_get_filter ((GtkFileChooser*) _tmp23_);
_tmp25_ = _tmp24_;
_tmp26_ = pdfFileFilter;
if (_tmp25_ == _tmp26_) {
const gchar* _tmp27_ = NULL;
gchar* _tmp28_ = NULL;
_tmp27_ = filename;
_tmp28_ = g_strconcat (_tmp27_, ".pdf", NULL);
_g_free0 (filename);
filename = _tmp28_;
}
}
_tmp29_ = filename;
_tmp30_ = g_file_test (_tmp29_, G_FILE_TEST_EXISTS);
if (_tmp30_) {
GtkFileChooserDialog* _tmp31_ = NULL;
const gchar* _tmp32_ = NULL;
gint _tmp33_ = 0;
_tmp31_ = fileChooser;
_tmp32_ = filename;
_tmp33_ = basic_dialog_ask_overwrite ((GtkWindow*) _tmp31_, _tmp32_);
if (_tmp33_ == ((gint) GTK_RESPONSE_YES)) {
stillChoosing = FALSE;
}
} else {
stillChoosing = FALSE;
}
} else {
GtkFileChooserDialog* _tmp34_ = NULL;
_tmp34_ = fileChooser;
gtk_widget_destroy ((GtkWidget*) _tmp34_);
_g_object_unref0 (fileChooser);
_g_object_unref0 (anyFileFilter);
_g_object_unref0 (pdfFileFilter);
_g_free0 (filename);
return;
}
}
_tmp35_ = fileChooser;
gtk_widget_destroy ((GtkWidget*) _tmp35_);
_tmp36_ = filename;
if (g_strcmp0 (_tmp36_, "") != 0) {
ImageExporterRenderer _tmp37_ = NULL;
void* _tmp37__target = NULL;
const gchar* _tmp38_ = NULL;
_tmp37_ = renderer;
_tmp37__target = renderer_target;
_tmp38_ = filename;
_tmp37_ (_tmp38_, IMAGE_EXPORTER_IMAGE_FORMAT_PDF, (gdouble) 1, _tmp37__target);
}
_g_object_unref0 (fileChooser);
_g_object_unref0 (anyFileFilter);
_g_object_unref0 (pdfFileFilter);
_g_free0 (filename);
}
const char* file_dialog_show(GtkWidget* parent, bool open, const char* title, const char* path, const char* pattern)
{
filetype_t type;
if(pattern == 0)
{
pattern = "*";
}
FileTypeList typelist;
GlobalFiletypes().getTypeList(pattern, &typelist);
GTKMasks masks(typelist);
if (title == 0)
title = open ? "Open File" : "Save File";
GtkWidget* dialog;
if (open)
{
dialog = gtk_file_chooser_dialog_new(title,
GTK_WINDOW(parent),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
}
else
{
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);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "unnamed");
}
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_position(GTK_WINDOW(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';
}
gtk_widget_destroy(dialog);
// don't return an empty filename
if(g_file_dialog_file[0] == '\0') return NULL;
return g_file_dialog_file;
}
static int gtkFileDlgPopup(Ihandle* ih, int x, int y)
{
InativeHandle* parent = iupDialogGetNativeParent(ih);
GtkWidget* dialog;
GtkWidget* preview_canvas = NULL;
GtkFileChooserAction action;
IFnss file_cb;
char* value;
int response, filter_count = 0;
iupAttribSetInt(ih, "_IUPDLG_X", x); /* used in iupDialogUpdatePosition */
iupAttribSetInt(ih, "_IUPDLG_Y", y);
value = iupAttribGetStr(ih, "DIALOGTYPE");
if (iupStrEqualNoCase(value, "SAVE"))
action = GTK_FILE_CHOOSER_ACTION_SAVE;
else if (iupStrEqualNoCase(value, "DIR"))
action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
else
action = GTK_FILE_CHOOSER_ACTION_OPEN;
value = iupAttribGet(ih, "TITLE");
if (!value)
{
GtkStockItem item;
if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
value = GTK_STOCK_SAVE_AS;
else
value = GTK_STOCK_OPEN;
gtk_stock_lookup(value, &item);
value = item.label;
iupAttribStoreStr(ih, "TITLE", iupgtkStrConvertFromUTF8(value));
value = iupAttribGet(ih, "TITLE");
iupStrRemoveChar(value, '_');
}
dialog = gtk_file_chooser_dialog_new(iupgtkStrConvertToUTF8(value), (GtkWindow*)parent, action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
if (!dialog)
return IUP_ERROR;
if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_SAVE, GTK_RESPONSE_OK);
else if (action == GTK_FILE_CHOOSER_ACTION_OPEN)
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OPEN, GTK_RESPONSE_OK);
else
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK);
if (IupGetCallback(ih, "HELP_CB"))
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_HELP, GTK_RESPONSE_HELP);
#if GTK_CHECK_VERSION(2, 6, 0)
if (iupAttribGetBoolean(ih, "SHOWHIDDEN"))
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE);
#endif
if (iupAttribGetBoolean(ih, "MULTIPLEFILES") && action == GTK_FILE_CHOOSER_ACTION_OPEN)
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
#if GTK_CHECK_VERSION(2, 8, 0)
if (!iupAttribGetBoolean(ih, "NOOVERWRITEPROMPT") && action == GTK_FILE_CHOOSER_ACTION_SAVE)
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
#endif
/* just check for the path inside FILE */
value = iupAttribGet(ih, "FILE");
if (value && (value[0] == '/' || value[1] == ':'))
{
char* dir = iupStrFileGetPath(value);
int len = strlen(dir);
iupAttribStoreStr(ih, "DIRECTORY", dir);
free(dir);
iupAttribStoreStr(ih, "FILE", value+len);
}
value = iupAttribGet(ih, "DIRECTORY");
if (value)
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value));
value = iupAttribGet(ih, "FILE");
if (value)
{
if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value));
else
{
if (iupdrvIsFile(value)) /* check if file exists */
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value));
}
}
value = iupAttribGet(ih, "EXTFILTER");
if (value)
{
char *name, *pattern, *filters = iupStrDup(value), *p;
char atrib[30];
int i;
int filter_index = iupAttribGetInt(ih, "FILTERUSED");
if (!filter_index)
filter_index = 1;
filter_count = iupStrReplace(filters, '|', 0) / 2;
p = filters;
for (i=0; i<filter_count; i++)
{
GtkFileFilter *filter = gtk_file_filter_new();
gtkFileDlgGetNextFilter(&p, &name, &pattern);
gtk_file_filter_set_name(filter, iupgtkStrConvertToUTF8(name));
gtk_file_filter_add_pattern(filter, pattern);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
sprintf(atrib, "_IUPDLG_FILTER%d", i+1);
iupAttribSetStr(ih, atrib, (char*)filter);
if (i+1 == filter_index)
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
}
free(filters);
}
else
{
value = iupAttribGet(ih, "FILTER");
if (value)
{
GtkFileFilter *filter = gtk_file_filter_new();
char* info = iupAttribGet(ih, "FILTERINFO");
if (!info)
info = value;
gtk_file_filter_set_name(filter, iupgtkStrConvertToUTF8(info));
gtk_file_filter_add_pattern(filter, value);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
}
}
file_cb = (IFnss)IupGetCallback(ih, "FILE_CB");
if (file_cb && action != GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
{
g_signal_connect(GTK_FILE_CHOOSER(dialog), "update-preview", G_CALLBACK(gtkFileDlgUpdatePreview), ih);
g_signal_connect(dialog, "realize", G_CALLBACK(gtkFileDlgRealize), ih);
if (iupAttribGetBoolean(ih, "SHOWPREVIEW"))
{
GtkWidget* frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
gtk_widget_set_size_request(frame, 180, 150);
preview_canvas = gtk_drawing_area_new();
gtk_widget_set_double_buffered(preview_canvas, FALSE);
gtk_container_add(GTK_CONTAINER(frame), preview_canvas);
gtk_widget_show(preview_canvas);
g_signal_connect(preview_canvas, "configure-event", G_CALLBACK(gtkFileDlgPreviewConfigureEvent), ih);
g_signal_connect(preview_canvas, "expose-event", G_CALLBACK(gtkFileDlgPreviewExposeEvent), ih);
g_signal_connect(preview_canvas, "realize", G_CALLBACK(gtkFileDlgPreviewRealize), ih);
iupAttribSetStr(ih, "_IUPDLG_FILE_CHOOSER", (char*)dialog);
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), frame);
}
}
/* initialize the widget */
gtk_widget_realize(GTK_WIDGET(dialog));
ih->handle = GTK_WIDGET(dialog);
iupDialogUpdatePosition(ih);
ih->handle = NULL; /* reset handle */
do
{
response = gtk_dialog_run(GTK_DIALOG(dialog));
if (response == GTK_RESPONSE_HELP)
{
Icallback cb = IupGetCallback(ih, "HELP_CB");
if (cb && cb(ih) == IUP_CLOSE)
response = GTK_RESPONSE_CANCEL;
}
else if (response == GTK_RESPONSE_OK)
{
char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
int file_exist = iupdrvIsFile(filename);
int dir_exist = iupdrvIsDirectory(filename);
g_free(filename);
if (action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
{
if (!dir_exist)
{
iupStrMessageShowError(ih, "IUP_INVALIDDIR");
response = GTK_RESPONSE_HELP; /* to leave the dialog open */
continue;
}
}
else if (!iupAttribGetBoolean(ih, "MULTIPLEFILES"))
{
if (dir_exist)
{
iupStrMessageShowError(ih, "IUP_FILEISDIR");
response = GTK_RESPONSE_HELP; /* to leave the dialog open */
continue;
}
if (!file_exist) /* if do not exist check ALLOWNEW */
{
value = iupAttribGet(ih, "ALLOWNEW");
if (!value)
{
if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
value = "YES";
else
value = "NO";
}
if (!iupStrBoolean(value))
{
iupStrMessageShowError(ih, "IUP_FILENOTEXIST");
response = GTK_RESPONSE_HELP; /* to leave the dialog open */
continue;
}
}
if (file_cb)
{
char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
int ret = file_cb(ih, iupgtkStrConvertFromFilename(filename), "OK");
g_free(filename);
if (ret == IUP_IGNORE)
{
response = GTK_RESPONSE_HELP; /* to leave the dialog open */
continue;
}
}
}
}
} while (response == GTK_RESPONSE_HELP);
if (file_cb)
{
if (iupAttribGetBoolean(ih, "SHOWPREVIEW"))
iupgtkReleaseNativeGraphicsContext(preview_canvas, (void*)iupAttribGet(ih, "PREVIEWDC"));
file_cb(ih, NULL, "FINISH");
}
if (response == GTK_RESPONSE_OK)
{
int file_exist, dir_exist;
if (filter_count)
{
int i;
char atrib[30];
GtkFileFilter* filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog));
for (i=0; i<filter_count; i++)
{
sprintf(atrib, "_IUPDLG_FILTER%d", i+1);
if (filter == (GtkFileFilter*)iupAttribGet(ih, atrib))
iupAttribSetInt(ih, "FILTERUSED", i+1);
}
}
if (iupAttribGetBoolean(ih, "MULTIPLEFILES"))
{
GSList* file_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
if (file_list->next) /* if more than one file */
gtkFileDlgGetMultipleFiles(ih, file_list);
else
{
char* filename = (char*)file_list->data;
iupAttribStoreStr(ih, "VALUE", iupgtkStrConvertFromFilename(filename));
g_free(filename);
}
g_slist_free(file_list);
file_exist = 1;
dir_exist = 0;
}
else
{
char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
iupAttribStoreStr(ih, "VALUE", iupgtkStrConvertFromFilename(filename));
file_exist = iupdrvIsFile(filename);
dir_exist = iupdrvIsDirectory(filename);
g_free(filename);
}
if (dir_exist)
{
iupAttribSetStr(ih, "FILEEXIST", NULL);
iupAttribSetStr(ih, "STATUS", "0");
}
else
{
if (file_exist) /* check if file exists */
{
iupAttribSetStr(ih, "FILEEXIST", "YES");
iupAttribSetStr(ih, "STATUS", "0");
}
else
{
iupAttribSetStr(ih, "FILEEXIST", "NO");
iupAttribSetStr(ih, "STATUS", "1");
}
}
if (action != GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER && !iupAttribGetBoolean(ih, "NOCHANGEDIR")) /* do change the current directory */
{
/* GtkFileChooser does not change the current directory */
char* dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog));
if (dir) iupdrvSetCurrentDirectory(dir);
g_free(dir);
}
}
else
{
iupAttribSetStr(ih, "FILTERUSED", NULL);
iupAttribSetStr(ih, "VALUE", NULL);
iupAttribSetStr(ih, "FILEEXIST", NULL);
iupAttribSetStr(ih, "STATUS", "-1");
}
gtk_widget_destroy(GTK_WIDGET(dialog));
return IUP_NOERROR;
}
