static void baseuri_changed_cb (GSettings *settings, const gchar *key, gpointer user_data)
{
/*
* The conflict between separation of the prefs and the main window,
* and the problem of duplication, is very clear here. This code is
* identical to the code in the main key listener, but modifying the
* prefs window from the main is ugly. Maybe put the validation code
* into sj-utils?
*/
const char* base_uri, *current_uri;
g_return_if_fail (strcmp (key, SJ_SETTINGS_BASEURI) == 0);
base_uri = g_settings_get_string (settings, key);
if (base_uri == NULL || base_uri[0] == '\0') {
GFile *dir;
char *dir_uri;
dir = sj_get_default_music_directory ();
dir_uri = g_file_get_uri (dir);
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (basepath_fcb), dir_uri);
g_free (dir_uri);
g_object_unref (dir);
} else {
current_uri = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (basepath_fcb));
if (current_uri == NULL || strcmp (current_uri, base_uri) != 0)
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (basepath_fcb), base_uri);
}
}
void on_open1_activate(GtkWidget *widget)
{
GtkWidget *file_selection_box;
gchar *folder;
const gchar *last_opened_folder;
// Create the selector widget
file_selection_box = gtk_file_chooser_dialog_new("Please select files for editing", GTK_WINDOW(main_window.window),
GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(file_selection_box), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG(file_selection_box), GTK_RESPONSE_ACCEPT);
//Add filters to the open dialog
add_file_filters(GTK_FILE_CHOOSER(file_selection_box));
last_opened_folder = get_preferences_manager_last_opened_folder(main_window.prefmg);
gphpedit_debug_message(DEBUG_MAIN_WINDOW,"last_opened_folder: %s", last_opened_folder);
/* opening of multiple files at once */
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_selection_box), TRUE);
gchar *filename = (gchar *)document_get_filename(document_manager_get_current_document(main_window.docmg));
if (filename && !document_get_untitled(document_manager_get_current_document(main_window.docmg))) {
folder = filename_parent_uri(filename);
gphpedit_debug_message(DEBUG_MAIN_WINDOW,"folder: %s", folder);
gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(file_selection_box), folder);
g_free(folder);
}
else if (last_opened_folder) {
gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(file_selection_box), last_opened_folder);
}
if (gtk_dialog_run(GTK_DIALOG(file_selection_box)) == GTK_RESPONSE_ACCEPT) {
open_file_ok(GTK_FILE_CHOOSER(file_selection_box));
}
gtk_widget_destroy(file_selection_box);
}
int32 ShowOpenDialog(bool allowMultipleSelection,
bool chooseDirectory,
ExtensionString title,
ExtensionString initialDirectory,
ExtensionString fileTypes,
CefRefPtr<CefListValue>& selectedFiles)
{
GtkWidget *dialog;
GtkFileChooserAction file_or_directory = chooseDirectory ? GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER : GTK_FILE_CHOOSER_ACTION_OPEN ;
dialog = gtk_file_chooser_dialog_new (title.c_str(),
NULL,
file_or_directory,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
if (!initialDirectory.empty())
{
ExtensionString folderURI = std::string("file:///") + initialDirectory;
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (dialog), folderURI.c_str());
}
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
selectedFiles->SetString(0,filename);
g_free (filename);
}
gtk_widget_destroy (dialog);
return NO_ERROR;
}
static void
sync_widgets_with_options (DialogData *data,
const char *base_dir,
const char *filename,
const char *include_files,
const char *exclude_files,
const char *exclude_folders,
gboolean update,
gboolean recursive,
gboolean no_symlinks)
{
if ((base_dir == NULL) || (strcmp (base_dir, "") == 0))
base_dir = fr_window_get_add_default_dir (data->window);
if ((filename != NULL) && (strcmp (filename, base_dir) != 0))
gtk_file_chooser_select_uri (GTK_FILE_CHOOSER (data->dialog), filename);
else
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (data->dialog), base_dir);
if (include_files != NULL)
gtk_entry_set_text (GTK_ENTRY (data->include_files_entry), include_files);
if (exclude_files != NULL)
gtk_entry_set_text (GTK_ENTRY (data->exclude_files_entry), exclude_files);
if (exclude_folders != NULL)
gtk_entry_set_text (GTK_ENTRY (data->exclude_folders_entry), exclude_folders);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->add_if_newer_checkbutton), update);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->include_subfold_checkbutton), recursive);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->exclude_symlinks), no_symlinks);
}
static char * select_file (bool_t save, const char * default_filename)
{
GtkWidget * dialog = gtk_file_chooser_dialog_new (save ?
_("Export Playlist") : _("Import Playlist"), NULL, save ?
GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN, NULL, NULL);
if (default_filename)
gtk_file_chooser_set_uri ((GtkFileChooser *) dialog, default_filename);
gtk_dialog_add_button ((GtkDialog *) dialog, GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT);
gtk_dialog_add_button ((GtkDialog *) dialog, save ? GTK_STOCK_SAVE :
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT);
gtk_dialog_set_default_response ((GtkDialog *) dialog, GTK_RESPONSE_ACCEPT);
char * path = aud_get_string ("audgui", "playlist_path");
if (path[0])
gtk_file_chooser_set_current_folder_uri ((GtkFileChooser *) dialog, path);
g_free (path);
char * filename = NULL;
if (gtk_dialog_run ((GtkDialog *) dialog) == GTK_RESPONSE_ACCEPT)
filename = gtk_file_chooser_get_uri ((GtkFileChooser *) dialog);
path = gtk_file_chooser_get_current_folder_uri ((GtkFileChooser *) dialog);
aud_set_string ("audgui", "playlist_path", path);
g_free (path);
gtk_widget_destroy (dialog);
return filename;
}
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);
}
}
/* 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;
}
void
on_prop_browse_file (GtkButton *button, gpointer user_data) {
GtkWidget *dlg = gtk_file_chooser_dialog_new (_("Open file..."), GTK_WINDOW (mainwin), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dlg), FALSE);
// restore folder
deadbeef->conf_lock ();
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (dlg), deadbeef->conf_get_str_fast ("filechooser.lastdir", ""));
deadbeef->conf_unlock ();
int response = gtk_dialog_run (GTK_DIALOG (dlg));
// store folder
gchar *folder = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (dlg));
if (folder) {
deadbeef->conf_set_str ("filechooser.lastdir", folder);
g_free (folder);
deadbeef->sendmessage (DB_EV_CONFIGCHANGED, 0, 0, 0);
}
if (response == GTK_RESPONSE_OK) {
gchar *file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dlg));
gtk_widget_destroy (dlg);
if (file) {
GtkWidget *entry = GTK_WIDGET (user_data);
gtk_entry_set_text (GTK_ENTRY (entry), file);
g_free (file);
}
}
else {
gtk_widget_destroy (dlg);
}
}
bool ChooseDirectory(
fs::path& outDirectory)
{
GtkWidget* dialog = nil;
bool result = false;
try
{
dialog =
gtk_file_chooser_dialog_new(_("Select Folder"), nil,
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
THROW_IF_NIL(dialog);
string currentFolder = gApp->GetCurrentFolder();
if (currentFolder.length() > 0)
{
gtk_file_chooser_set_current_folder_uri(
GTK_FILE_CHOOSER(dialog), currentFolder.c_str());
}
if (fs::exists(outDirectory) and outDirectory != fs::path())
{
gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog),
outDirectory.string().c_str());
}
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char* uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog));
if (uri != nil)
{
MFile url(uri, true);
outDirectory = url.GetPath();
g_free(uri);
result = true;
}
//
// gApp->SetCurrentFolder(
// gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog)));
}
}
catch (exception& e)
{
if (dialog)
gtk_widget_destroy(dialog);
throw;
}
gtk_widget_destroy(dialog);
return result;
}
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;
}
Php::Value GtkFileChooserDialog_::set_current_folder_uri(Php::Parameters ¶meters)
{
std::string s_uri = parameters[0];
gchar *uri = (gchar *)s_uri.c_str();
gboolean ret = gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER(instance), uri);
return ret;
}
/* EDITOR: COLORMAP VIEWER
* =======================
* Colormaps differ from lump files in the way that they don't start with a width | height header
* Otherwise they are identical in how they refer to palette indexes for their color
*/
gint VID_EditorViewColormap(gpointer data)
{
int i;
GtkWidget *dialog;
GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
gint res;
loadedfile_t *pic;
dialog = gtk_file_chooser_dialog_new ("NGUNIXEd - Open Colormap (.lmp) File",
NULL,
action,
("_Cancel"),
GTK_RESPONSE_CANCEL,
("_Open"),
GTK_RESPONSE_ACCEPT,
NULL);
// Set the dialog and the default path (current directory)
GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
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, "*.lmp");
gtk_file_chooser_set_filter (chooser, filter);
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (res == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename (chooser);
pic = COM_LoadFile (filename, 2);
if(pic)
{
Con_Printf("[EDITOR] Previewing Colormap %s\n", filename);
ed_file = malloc(16385 + (sizeof(int) * 2));
ed_file->width = 256;
ed_file->height = 64;
for(i = 0; i < 256 * 64; i++)
ed_file->data[i] = pic->data[i];
gtk_window_resize(ed_window, ed_file->width + ed_palfile->width, ed_file->height + ed_menubar->allocation.height);
}
g_free (filename);
}
gtk_widget_destroy (dialog);
return 0;
}
GFile *
gtkhtml_editor_run_open_dialog (GtkhtmlEditor *editor,
const gchar *title,
GtkCallback customize_func,
gpointer customize_data)
{
GtkFileChooser *file_chooser;
GFile *chosen_file = NULL;
GtkWidget *dialog;
gchar *uri;
g_return_val_if_fail (GTKHTML_IS_EDITOR (editor), NULL);
dialog = gtk_file_chooser_dialog_new (
title, GTK_WINDOW (editor),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
file_chooser = GTK_FILE_CHOOSER (dialog);
gtk_dialog_set_default_response (
GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
gtk_file_chooser_set_local_only (file_chooser, FALSE);
/* Restore the current folder from the previous file chooser. */
uri = (gchar *) gtkhtml_editor_get_current_folder (editor);
if (uri != NULL)
gtk_file_chooser_set_current_folder_uri (file_chooser, uri);
/* Allow further customizations before running the dialog. */
if (customize_func != NULL)
customize_func (dialog, customize_data);
if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_ACCEPT)
goto exit;
chosen_file = gtk_file_chooser_get_file (file_chooser);
/* Save the current folder for subsequent file choosers. */
uri = gtk_file_chooser_get_current_folder_uri (file_chooser);
gtkhtml_editor_set_current_folder (editor, uri);
g_free (uri);
exit:
gtk_widget_destroy (dialog);
return chosen_file;
}
static GtkWidget *
impl_get_config_widget (RBDisplayPage *page, RBShellPreferences *prefs)
{
RBPodcastMainSource *source = RB_PODCAST_MAIN_SOURCE (page);
RBPodcastManager *podcast_mgr;
GtkBuilder *builder;
GtkWidget *update_interval;
GtkWidget *btn_file;
GSettings *settings;
char *download_dir;
if (source->priv->config_widget)
return source->priv->config_widget;
builder = rb_builder_load ("podcast-prefs.ui", source);
source->priv->config_widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast_vbox"));
btn_file = GTK_WIDGET (gtk_builder_get_object (builder, "location_chooser"));
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (btn_file),
rb_music_dir (),
NULL);
g_object_get (source,
"podcast-manager", &podcast_mgr,
NULL);
download_dir = rb_podcast_manager_get_podcast_dir (podcast_mgr);
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (btn_file),
download_dir);
g_object_unref (podcast_mgr);
g_free (download_dir);
g_signal_connect_object (btn_file,
"selection-changed",
G_CALLBACK (rb_podcast_main_source_btn_file_change_cb),
source, 0);
update_interval = GTK_WIDGET (gtk_builder_get_object (builder, "update_interval"));
g_object_set (update_interval, "id-column", 1, NULL);
settings = g_settings_new (PODCAST_SETTINGS_SCHEMA);
g_settings_bind (settings, PODCAST_DOWNLOAD_INTERVAL,
update_interval, "active-id",
G_SETTINGS_BIND_DEFAULT);
g_object_unref (settings);
return source->priv->config_widget;
}
int
clip_GTK_FILECHOOSERSETCURRENTFOLDERURI(ClipMachine * ClipMachineMemory)
{
C_object *cchooser = _fetch_co_arg(ClipMachineMemory);
gchar *uri = _clip_parc(ClipMachineMemory, 2);
CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object));
CHECKARG(2, CHARACTER_type_of_ClipVarType);
LOCALE_TO_UTF(uri);
_clip_retl(ClipMachineMemory, gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(cchooser->object), uri));
FREE_TEXT(uri);
return 0;
err:
return 1;
}
/* EDITOR: GENERATE COLORMAP
* ===============
* Generate a colormap for the current palette...
* makes use of our builtin function for generating them
*/
gint VID_EditorGenerateColormap(gpointer data)
{
GtkWidget *dialog;
GtkFileChooser *chooser;
GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
gint res;
byte *pic;
dialog = gtk_file_chooser_dialog_new ("NGUNIXEd - Save Generated Colormap (.lmp) 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, "*.lmp");
gtk_file_chooser_set_filter (chooser, filter);
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (res == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename (chooser);
byte out_colormap[16384];
Con_Printf("[EDITOR] Generating colormap based on current palette...\n");
Colormap_Generate(ed_palette, out_colormap);
COM_WriteFile (filename, out_colormap, 16384);
g_free (filename);
}
gtk_widget_destroy (dialog);
return 0;
}
static GtkWidget *
impl_get_config_widget (RBSource *asource, RBShellPreferences *prefs)
{
RBPodcastMainSource *source = RB_PODCAST_MAIN_SOURCE (asource);
RBPodcastManager *podcast_mgr;
GtkBuilder *builder;
GtkWidget *cb_update_interval;
GtkWidget *btn_file;
char *download_dir;
if (source->priv->config_widget)
return source->priv->config_widget;
builder = rb_builder_load ("podcast-prefs.ui", source);
source->priv->config_widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast_vbox"));
btn_file = GTK_WIDGET (gtk_builder_get_object (builder, "location_chooser"));
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (btn_file),
rb_music_dir (),
NULL);
g_object_get (source, "podcast-manager", &podcast_mgr, NULL);
download_dir = rb_podcast_manager_get_podcast_dir (podcast_mgr);
g_object_unref (podcast_mgr);
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (btn_file),
download_dir);
g_free (download_dir);
g_signal_connect (btn_file,
"selection-changed",
G_CALLBACK (rb_podcast_main_source_btn_file_change_cb),
CONF_STATE_PODCAST_DOWNLOAD_DIR);
cb_update_interval = GTK_WIDGET (gtk_builder_get_object (builder, "cb_update_interval"));
gtk_combo_box_set_active (GTK_COMBO_BOX (cb_update_interval),
eel_gconf_get_integer (CONF_STATE_PODCAST_DOWNLOAD_INTERVAL));
g_signal_connect (cb_update_interval,
"changed",
G_CALLBACK (rb_podcast_main_source_cb_interval_changed_cb),
source);
return source->priv->config_widget;
}
void
activate_action_open (GtkAction *action,
gpointer data)
{
GtkWidget *file_sel;
FrWindow *window = data;
GtkFileFilter *filter;
int i;
file_sel = gtk_file_chooser_dialog_new (_("Open"),
GTK_WINDOW (window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (file_sel), GTK_RESPONSE_OK);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_sel), FALSE);
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (file_sel), fr_window_get_open_default_dir (window));
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("All archives"));
for (i = 0; open_type[i] != -1; i++)
gtk_file_filter_add_mime_type (filter, mime_type_desc[open_type[i]].mime_type);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_sel), filter);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (file_sel), filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("All files"));
gtk_file_filter_add_pattern (filter, "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_sel), filter);
/**/
g_object_set_data (G_OBJECT (file_sel), "fr_window", window);
g_signal_connect (G_OBJECT (file_sel),
"response",
G_CALLBACK (open_file_response_cb),
file_sel);
gtk_window_set_modal (GTK_WINDOW (file_sel), TRUE);
gtk_widget_show (file_sel);
}
/* See VikDataSourceInterface */
static void datasource_geotag_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data )
{
datasource_geotag_user_data_t *userdata = (datasource_geotag_user_data_t *)user_data;
/* The files selector */
userdata->files = gtk_file_chooser_widget_new ( GTK_FILE_CHOOSER_ACTION_OPEN );
// try to make it a nice size - otherwise seems to default to something impractically small
gtk_window_set_default_size ( GTK_WINDOW (dialog) , 600, 300 );
if ( last_folder_uri )
gtk_file_chooser_set_current_folder_uri ( GTK_FILE_CHOOSER(userdata->files), last_folder_uri );
GtkFileChooser *chooser = GTK_FILE_CHOOSER ( userdata->files );
/* Add filters */
GtkFileFilter *filter;
filter = gtk_file_filter_new ();
gtk_file_filter_set_name ( filter, _("All") );
gtk_file_filter_add_pattern ( filter, "*" );
gtk_file_chooser_add_filter ( chooser, filter );
filter = gtk_file_filter_new ();
gtk_file_filter_set_name ( filter, _("JPG") );
gtk_file_filter_add_mime_type ( filter, "image/jpeg");
gtk_file_chooser_add_filter ( chooser, filter );
// Default to jpgs
gtk_file_chooser_set_filter ( chooser, filter );
// Allow selecting more than one
gtk_file_chooser_set_select_multiple ( chooser, TRUE );
// Could add code to setup a default symbol (see dialog.c for symbol usage)
// Store in user_data type and then apply when creating the waypoints
// However not much point since these will have images associated with them!
/* Packing all widgets */
GtkBox *box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
gtk_box_pack_start ( box, userdata->files, TRUE, TRUE, 0 );
gtk_widget_show_all ( dialog );
}
GFile * ImageOpenDlg::show(GtkWindow * win, Settings * settings, bool localOnly, bool * attach) {
GtkWidget * dialog = gtk_file_chooser_dialog_new(_("Open Image"), win, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
GTK_RESPONSE_OK, NULL);
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), localOnly);
GtkFileFilter * filterSupported = gtk_file_filter_new();
gtk_file_filter_set_name(filterSupported, _("Images"));
gtk_file_filter_add_pixbuf_formats(filterSupported);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterSupported);
if (!settings->getLastImagePath().isEmpty()) {
gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(dialog), settings->getLastImagePath().c_str());
}
GtkWidget * cbAttach = NULL;
if (attach) {
cbAttach = gtk_check_button_new_with_label(_("Attach file to the journal"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbAttach), false);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), cbAttach);
}
GtkWidget * image = gtk_image_new();
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), image);
g_signal_connect(dialog, "update-preview", G_CALLBACK(updatePreviewCallback), NULL);
gtk_window_set_transient_for(GTK_WINDOW(dialog), win);
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
gtk_widget_destroy(dialog);
return NULL;
}
GFile * file = gtk_file_chooser_get_file(GTK_FILE_CHOOSER(dialog));
if (attach) {
*attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cbAttach));
}
char * folder = gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog));
settings->setLastImagePath(folder);
g_free(folder);
gtk_widget_destroy(dialog);
return file;
}
static void create_selector (ImportExportJob * job, const char * filename, const char * folder)
{
const char * title, * verb, * icon;
GtkFileChooserAction action;
if (job->save)
{
title = _("Export Playlist");
verb = _("Export");
icon = "document-save";
action = GTK_FILE_CHOOSER_ACTION_SAVE;
}
else
{
title = _("Import Playlist");
verb = _("Import");
icon = "document-open";
action = GTK_FILE_CHOOSER_ACTION_OPEN;
}
job->selector = gtk_file_chooser_dialog_new (title, NULL, action, NULL, NULL);
if (filename)
gtk_file_chooser_set_uri ((GtkFileChooser *) job->selector, filename);
else if (folder)
gtk_file_chooser_set_current_folder_uri ((GtkFileChooser *) job->selector, folder);
GtkWidget * button1 = audgui_button_new (verb, icon, check_overwrite, job);
GtkWidget * button2 = audgui_button_new (_("Cancel"), "process-stop",
(AudguiCallback) gtk_widget_destroy, job->selector);
gtk_dialog_add_action_widget ((GtkDialog *) job->selector, button2, GTK_RESPONSE_NONE);
gtk_dialog_add_action_widget ((GtkDialog *) job->selector, button1, GTK_RESPONSE_NONE);
gtk_widget_set_can_default (button1, TRUE);
gtk_widget_grab_default (button1);
g_signal_connect_swapped (job->selector, "destroy", (GCallback) cleanup_job, job);
gtk_widget_show_all (job->selector);
}
/* See VikDataSourceInterface */
static void datasource_file_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data )
{
datasource_file_widgets_t *widgets = (datasource_file_widgets_t *)user_data;
GtkWidget *filename_label, *type_label;
/* The file selector */
filename_label = gtk_label_new (_("File:"));
widgets->file = gtk_file_chooser_button_new (_("File to import"), GTK_FILE_CHOOSER_ACTION_OPEN);
if (last_folder_uri)
gtk_file_chooser_set_current_folder_uri ( GTK_FILE_CHOOSER(widgets->file), last_folder_uri);
/* Add filters */
g_list_foreach ( a_babel_file_list, add_file_filter, widgets->file );
GtkFileFilter *all_filter = gtk_file_filter_new ();
gtk_file_filter_add_pattern ( all_filter, "*" );
gtk_file_filter_set_name ( all_filter, _("All files") );
gtk_file_chooser_add_filter ( GTK_FILE_CHOOSER(widgets->file), all_filter );
if ( last_file_filter == NULL )
/* No previously selected filter or 'All files' selected */
gtk_file_chooser_set_filter ( GTK_FILE_CHOOSER(widgets->file), all_filter );
/* The file format selector */
type_label = gtk_label_new (_("File type:"));
/* Propose any readable file */
BabelMode mode = { 1, 0, 1, 0, 1, 0 };
widgets->type = a_babel_ui_file_type_selector_new ( mode );
g_signal_connect ( G_OBJECT(widgets->type), "changed",
G_CALLBACK(a_babel_ui_type_selector_dialog_sensitivity_cb), dialog );
gtk_combo_box_set_active ( GTK_COMBO_BOX(widgets->type), last_type );
/* Manually call the callback to fix the state */
a_babel_ui_type_selector_dialog_sensitivity_cb ( GTK_COMBO_BOX(widgets->type), dialog );
/* Packing all these widgets */
GtkBox *box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
gtk_box_pack_start ( box, filename_label, FALSE, FALSE, 5 );
gtk_box_pack_start ( box, widgets->file, FALSE, FALSE, 5 );
gtk_box_pack_start ( box, type_label, FALSE, FALSE, 5 );
gtk_box_pack_start ( box, widgets->type, FALSE, FALSE, 5 );
gtk_widget_show_all(dialog);
}
static void
file_open_dialog_show (Gimp *gimp,
GtkWidget *parent,
const gchar *title,
GimpImage *image,
const gchar *uri,
gboolean open_as_layers)
{
GtkWidget *dialog;
dialog = gimp_dialog_factory_dialog_new (gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (parent),
NULL /*ui_manager*/,
"gimp-file-open-dialog", -1, FALSE);
if (dialog)
{
if (! uri && image)
uri = gimp_image_get_uri (image);
if (! uri)
uri = g_object_get_data (G_OBJECT (gimp), GIMP_FILE_OPEN_LAST_URI_KEY);
if (uri)
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog), uri);
else if (gimp->default_folder)
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (dialog),
gimp->default_folder);
gimp_file_dialog_set_open_image (GIMP_FILE_DIALOG (dialog),
image, open_as_layers);
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (gtk_widget_get_toplevel (parent)));
gtk_window_present (GTK_WINDOW (dialog));
}
}
static void datasource_geojson_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data )
{
datasource_geojson_user_data_t *ud = (datasource_geojson_user_data_t *)user_data;
ud->files = gtk_file_chooser_widget_new ( GTK_FILE_CHOOSER_ACTION_OPEN );
// try to make it a nice size - otherwise seems to default to something impractically small
gtk_window_set_default_size ( GTK_WINDOW (dialog) , 600, 300 );
if ( last_folder_uri )
gtk_file_chooser_set_current_folder_uri ( GTK_FILE_CHOOSER(ud->files), last_folder_uri );
GtkFileChooser *chooser = GTK_FILE_CHOOSER ( ud->files );
// Add filters
GtkFileFilter *filter;
filter = gtk_file_filter_new ();
gtk_file_filter_set_name ( filter, _("All") );
gtk_file_filter_add_pattern ( filter, "*" );
gtk_file_chooser_add_filter ( chooser, filter );
filter = gtk_file_filter_new ();
gtk_file_filter_set_name ( filter, _("GeoJSON") );
gtk_file_filter_add_pattern ( filter, "*.geojson" );
gtk_file_chooser_add_filter ( chooser, filter );
// Default to geojson
gtk_file_chooser_set_filter ( chooser, filter );
// Allow selecting more than one
gtk_file_chooser_set_select_multiple ( chooser, TRUE );
// Packing all widgets
GtkBox *box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
gtk_box_pack_start ( box, ud->files, TRUE, TRUE, 0 );
gtk_widget_show_all ( dialog );
}
/* See VikDataSourceInterface */
static void datasource_file_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data )
{
datasource_file_widgets_t *widgets = (datasource_file_widgets_t *)user_data;
GtkWidget *filename_label, *type_label;
/* The file selector */
filename_label = gtk_label_new (_("File:"));
widgets->file = gtk_file_chooser_button_new (_("File to import"), GTK_FILE_CHOOSER_ACTION_OPEN);
if (last_folder_uri)
gtk_file_chooser_set_current_folder_uri ( GTK_FILE_CHOOSER(widgets->file), last_folder_uri);
/* Add filters */
g_list_foreach ( a_babel_file_list, add_file_filter, widgets->file );
GtkFileFilter *all_filter = gtk_file_filter_new ();
gtk_file_filter_add_pattern ( all_filter, "*" );
gtk_file_filter_set_name ( all_filter, _("All files") );
gtk_file_chooser_add_filter ( GTK_FILE_CHOOSER(widgets->file), all_filter );
if ( last_file_filter == NULL )
/* No previously selected filter or 'All files' selected */
gtk_file_chooser_set_filter ( GTK_FILE_CHOOSER(widgets->file), all_filter );
/* The file format selector */
type_label = gtk_label_new (_("File type:"));
#if GTK_CHECK_VERSION (2,24,0)
widgets->type = gtk_combo_box_text_new ();
#else
widgets->type = gtk_combo_box_new_text ();
#endif
g_list_foreach (a_babel_file_list, fill_combo_box, widgets->type);
gtk_combo_box_set_active (GTK_COMBO_BOX (widgets->type), last_type);
/* Packing all these widgets */
gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), filename_label, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), widgets->file, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), type_label, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), widgets->type, FALSE, FALSE, 5 );
gtk_widget_show_all(dialog);
}
JNIEXPORT jboolean JNICALL
Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1set_1current_1folder_1uri
(
JNIEnv* env,
jclass cls,
jlong _self,
jstring _uri
)
{
gboolean result;
jboolean _result;
GtkFileChooser* self;
const gchar* uri;
// convert parameter self
self = (GtkFileChooser*) _self;
// convert parameter uri
uri = (const gchar*) bindings_java_getString(env, _uri);
if (uri == NULL) {
return JNI_FALSE; // Java Exception already thrown
}
// call function
result = gtk_file_chooser_set_current_folder_uri(self, uri);
// cleanup parameter self
// cleanup parameter uri
bindings_java_releaseString(uri);
// translate return value to JNI type
_result = (jboolean) result;
// and finally
return _result;
}
void on_save_as1_activate(GtkWidget *widget)
{
GtkWidget *file_selection_box;
gchar *filename;
const gchar *last_opened_folder;
if (document_manager_get_current_document(main_window.docmg)) {
// Create the selector widget
file_selection_box = gtk_file_chooser_dialog_new (_("Please type the filename to save as..."),
GTK_WINDOW(main_window.window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(file_selection_box), FALSE);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER(file_selection_box), TRUE);
gtk_dialog_set_default_response (GTK_DIALOG(file_selection_box), GTK_RESPONSE_ACCEPT);
if (document_manager_get_current_document(main_window.docmg)) { //FIXME: rework this code
filename = document_get_filename(document_manager_get_current_document(main_window.docmg));
if (!document_get_untitled(document_manager_get_current_document(main_window.docmg))) {
gtk_file_chooser_set_uri(GTK_FILE_CHOOSER(file_selection_box), filename);
}
else {
last_opened_folder = get_preferences_manager_last_opened_folder(main_window.prefmg);
gphpedit_debug_message(DEBUG_MAIN_WINDOW,"last_opened_folder: %s", last_opened_folder);
if (last_opened_folder) {
gphpedit_debug_message(DEBUG_MAIN_WINDOW,"Setting current_folder_uri to %s", last_opened_folder);
gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(file_selection_box), last_opened_folder);
}
}
g_free(filename);
}
if (gtk_dialog_run (GTK_DIALOG(file_selection_box)) == GTK_RESPONSE_ACCEPT) {
save_file_as_ok(GTK_FILE_CHOOSER(file_selection_box));
}
gtk_widget_destroy(file_selection_box);
}
}
bool ChooseFiles(
bool inLocalOnly,
std::vector<MFile>& outFiles)
{
GtkWidget* dialog = nil;
try
{
dialog =
gtk_file_chooser_dialog_new(_("Open"), nil,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
THROW_IF_NIL(dialog);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), true);
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), inLocalOnly);
if (gApp->GetCurrentFolder().length() > 0)
{
gtk_file_chooser_set_current_folder_uri(
GTK_FILE_CHOOSER(dialog), gApp->GetCurrentFolder().c_str());
}
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
GSList* uris = gtk_file_chooser_get_uris(GTK_FILE_CHOOSER(dialog));
GSList* file = uris;
while (file != nil)
{
MFile url(reinterpret_cast<char*>(file->data), true);
g_free(file->data);
file->data = nil;
outFiles.push_back(url);
file = file->next;
}
g_slist_free(uris);
}
char* cwd = gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog));
if (cwd != nil)
{
gApp->SetCurrentFolder(cwd);
g_free(cwd);
}
}
catch (exception& e)
{
if (dialog)
gtk_widget_destroy(dialog);
throw;
}
gtk_widget_destroy(dialog);
return outFiles.size() > 0;
}
bool PdfExportJob::showFilechooser()
{
XOJ_CHECK_TYPE(PdfExportJob);
Settings* settings = control->getSettings();
Document* doc = control->getDocument();
GtkWidget* dialog = gtk_file_chooser_dialog_new(_("Export PDF"),
(GtkWindow*) *control->getWindow(), GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), false);
GtkFileFilter* filterPdf = gtk_file_filter_new();
gtk_file_filter_set_name(filterPdf, _("PDF files"));
gtk_file_filter_add_pattern(filterPdf, "*.pdf");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterPdf);
if (!settings->getLastSavePath().isEmpty())
{
gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(dialog),
settings->getLastSavePath().c_str());
}
String saveFilename = "";
doc->lock();
if (!doc->getFilename().isEmpty())
{
saveFilename = control->getFilename(doc->getFilename());
}
else if (!doc->getPdfFilename().isEmpty())
{
saveFilename = control->getFilename(doc->getPdfFilename());
saveFilename += ".xoj";
}
else
{
time_t curtime = time(NULL);
char stime[128];
strftime(stime, sizeof(stime), settings->getDefaultSaveName().c_str(),
localtime(&curtime));
saveFilename = stime;
if (saveFilename.substring(-4) == ".xoj")
{
saveFilename = saveFilename.substring(0, -4);
}
}
doc->unlock();
saveFilename += ".pdf";
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
saveFilename.c_str());
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), true);
gtk_window_set_transient_for(GTK_WINDOW(dialog),
GTK_WINDOW(this->control->getWindow()->getWindow()));
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK)
{
gtk_widget_destroy(dialog);
return false;
}
char* name = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog));
this->filename = name;
char* folder = gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(
dialog));
settings->setLastSavePath(folder);
g_free(folder);
g_free(name);
gtk_widget_destroy(dialog);
return true;
}
bool ChooseOneFile(
MFile& ioFile)
{
GtkWidget* dialog = nil;
bool result = false;
try
{
dialog =
gtk_file_chooser_dialog_new(_("Select File"), nil,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
THROW_IF_NIL(dialog);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), false);
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), false);
if (ioFile.IsValid())
{
gtk_file_chooser_select_uri(GTK_FILE_CHOOSER(dialog),
ioFile.GetURI().c_str());
}
else if (gApp->GetCurrentFolder().length() > 0)
{
gtk_file_chooser_set_current_folder_uri(
GTK_FILE_CHOOSER(dialog), gApp->GetCurrentFolder().c_str());
}
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char* uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog));
if (uri != nil)
{
ioFile = MFile(uri, true);
g_free(uri);
gApp->SetCurrentFolder(
gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog)));
result = true;
}
}
}
catch (exception& e)
{
if (dialog)
gtk_widget_destroy(dialog);
throw;
}
gtk_widget_destroy(dialog);
return result;
}
