/* Add shortcut for default ICC profile location */
static void
gimp_profile_chooser_dialog_add_shortcut (GimpProfileChooserDialog *dialog)
{
#ifdef G_OS_WIN32
{
const gchar *prefix = g_getenv ("SystemRoot");
gchar *folder;
if (! prefix)
prefix = "c:\\windows";
folder = g_strconcat (prefix, "\\system32\\spool\\drivers\\color", NULL);
if (g_file_test (folder, G_FILE_TEST_IS_DIR))
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
folder, NULL);
g_free (folder);
}
#else
{
const gchar folder[] = "/usr/share/color/icc";
if (g_file_test (folder, G_FILE_TEST_IS_DIR))
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
folder, NULL);
}
#endif
}
void
wp_create_filechooser (AppearanceData *data)
{
const char *start_dir, *pictures = NULL;
GtkFileFilter *filter;
data->wp_filesel = GTK_FILE_CHOOSER (
gtk_file_chooser_dialog_new (_("Add Wallpaper"),
GTK_WINDOW (appearance_capplet_get_widget (data, "appearance_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 (data->wp_filesel), GTK_RESPONSE_OK);
gtk_file_chooser_set_select_multiple (data->wp_filesel, TRUE);
gtk_file_chooser_set_use_preview_label (data->wp_filesel, FALSE);
start_dir = g_get_home_dir ();
if (g_file_test ("/usr/share/backgrounds", G_FILE_TEST_IS_DIR)) {
gtk_file_chooser_add_shortcut_folder (data->wp_filesel,
"/usr/share/backgrounds", NULL);
start_dir = "/usr/share/backgrounds";
}
pictures = g_get_user_special_dir (G_USER_DIRECTORY_PICTURES);
if (pictures != NULL && g_file_test (pictures, G_FILE_TEST_IS_DIR)) {
gtk_file_chooser_add_shortcut_folder (data->wp_filesel, pictures, NULL);
start_dir = pictures;
}
gtk_file_chooser_set_current_folder (data->wp_filesel, start_dir);
filter = gtk_file_filter_new ();
gtk_file_filter_add_pixbuf_formats (filter);
gtk_file_filter_set_name (filter, _("Images"));
gtk_file_chooser_add_filter (data->wp_filesel, 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 (data->wp_filesel, filter);
data->wp_image = gtk_image_new ();
gtk_file_chooser_set_preview_widget (data->wp_filesel, data->wp_image);
gtk_widget_set_size_request (data->wp_image, 128, -1);
gtk_widget_show (data->wp_image);
g_signal_connect (data->wp_filesel, "update-preview",
(GCallback) wp_update_preview, data);
}
static void
browse_button_cb (GtkWidget *widget, gpointer data)
{
GtkWindow *parent = GTK_WINDOW (data);
GtkFileFilter *filter;
GtkWidget *file_dialog;
file_dialog = gtk_file_chooser_dialog_new (_("Select User Image"),
parent,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_show_hidden (GTK_FILE_CHOOSER (file_dialog), FALSE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_dialog), TRUE);
gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (file_dialog), FALSE);
if (facedir && g_file_test (facedir, G_FILE_TEST_IS_DIR)) {
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (file_dialog),
facedir);
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (file_dialog),
facedir, NULL);
} else {
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (file_dialog),
DATADIR "/pixmaps");
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (file_dialog),
DATADIR "/pixmaps", NULL);
}
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Images"));
gtk_file_filter_add_pixbuf_formats (filter);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_dialog), 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_dialog), filter);
if (imagename != NULL) {
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (file_dialog), imagename);
}
add_preview_widget (file_dialog);
g_signal_connect (G_OBJECT (file_dialog), "response",
G_CALLBACK (install_response), NULL);
gtk_widget_show (file_dialog);
}
static void
add_new_filechooser_button (const gchar *mnemonic,
const gchar *chooser_title,
GtkFileChooserAction action,
GtkWidget *group_box,
GtkSizeGroup *label_group)
{
GtkWidget *hbox, *label, *chooser, *button;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (group_box), hbox);
label = gtk_label_new_with_mnemonic (mnemonic);
gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox), label);
chooser = gtk_file_chooser_button_new (g_strconcat(chooser_title,
" - testfilechooserbutton", NULL),
action);
gtk_widget_set_hexpand (chooser, TRUE);
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser);
g_signal_connect (chooser, "current-folder-changed",
G_CALLBACK (chooser_current_folder_changed_cb), NULL);
g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL);
g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL);
g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL);
gtk_box_pack_start (GTK_BOX (hbox), chooser);
button = gtk_button_new_with_label ("Tests");
g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser);
gtk_box_pack_start (GTK_BOX (hbox), button);
}
/* Caller must g_free() the returned filename. */
gchar *
ghid_dialog_file_select_save (gchar * title, gchar ** path, gchar * file,
gchar * shortcuts)
{
GtkWidget *dialog;
gchar *result = NULL, *folder, *seed;
GHidPort *out = &ghid_port;
dialog = gtk_file_chooser_dialog_new (title,
GTK_WINDOW (out->top_window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
TRUE);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
if (path && *path && **path)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), *path);
if (file && *file)
{
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog),
g_path_get_basename(file));
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
g_path_get_dirname (file));
}
if (shortcuts && *shortcuts)
{
folder = g_strdup (shortcuts);
seed = folder;
while ((folder = strtok (seed, ":")) != NULL)
{
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
folder, NULL);
seed = NULL;
}
g_free (folder);
}
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
result = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
folder =
gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
if (folder && path)
{
dup_string (path, folder);
g_free (folder);
}
}
gtk_widget_destroy (dialog);
return result;
}
void
sj_add_default_dirs (GtkFileChooser *dialog)
{
const char *dir;
dir = g_get_user_special_dir (G_USER_DIRECTORY_MUSIC);
if (dir) {
gtk_file_chooser_add_shortcut_folder (dialog, dir, NULL);
}
}
static void
totem_add_default_dirs (GtkFileChooser *dialog)
{
guint i;
for (i = 0; i < G_N_ELEMENTS (dir_types); i++) {
const char *dir;
dir = g_get_user_special_dir (dir_types[i]);
if (dir == NULL)
continue;
gtk_file_chooser_add_shortcut_folder (dialog, dir, NULL);
}
}
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;
}
static GtkWidget *
cdisplay_proof_file_chooser_dialog_new (void)
{
GtkWidget *dialog;
GtkFileFilter *filter;
dialog = gtk_file_chooser_dialog_new (_("Choose an ICC Color Profile"),
NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_CANCEL,
-1);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
#ifndef G_OS_WIN32
{
const gchar folder[] = "/usr/share/color/icc";
if (g_file_test (folder, G_FILE_TEST_IS_DIR))
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
folder, NULL);
}
#endif
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 (dialog), filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("ICC color profile (*.icc, *.icm)"));
gtk_file_filter_add_pattern (filter, "*.[Ii][Cc][Cc]");
gtk_file_filter_add_pattern (filter, "*.[Ii][Cc][Mm]");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter);
return dialog;
}
static void
add_pwds_parent_as_shortcut_clicked_cb (GtkWidget *button,
gpointer user_data)
{
GError *err = NULL;
if (!gtk_file_chooser_add_shortcut_folder (user_data, gtk_src_dir, &err))
{
g_message ("Couldn't add `%s' as shortcut folder: %s", gtk_src_dir,
err->message);
g_error_free (err);
}
else
{
g_message ("Added `%s' as shortcut folder.", gtk_src_dir);
}
}
JNIEXPORT jboolean JNICALL
Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1add_1shortcut_1folder
(
JNIEnv* env,
jclass cls,
jlong _self,
jstring _folder
)
{
gboolean result;
jboolean _result;
GtkFileChooser* self;
const char* folder;
GError* error = NULL;
// convert parameter self
self = (GtkFileChooser*) _self;
// convert parameter folder
folder = (const char*) bindings_java_getString(env, _folder);
if (folder == NULL) {
return JNI_FALSE; // Java Exception already thrown
}
// call function
result = gtk_file_chooser_add_shortcut_folder(self, folder, &error);
// cleanup parameter self
// cleanup parameter folder
bindings_java_releaseString(folder);
// check for error
if (error) {
bindings_java_throwGlibException(env, error);
return JNI_FALSE;
}
// translate return value to JNI type
_result = (jboolean) result;
// and finally
return _result;
}
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;
}
int
clip_GTK_FILECHOOSERADDSHORTCUTFOLDER(ClipMachine * ClipMachineMemory)
{
C_object *cchooser = _fetch_co_arg(ClipMachineMemory);
gchar *name = _clip_parc(ClipMachineMemory, 2);
GError *error;
CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object));
CHECKARG(2, CHARACTER_type_of_ClipVarType);
LOCALE_TO_UTF(name);
_clip_retl(ClipMachineMemory, gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(cchooser->object), name, &error));
FREE_TEXT(name);
return 0;
err:
return 1;
}
GtkWidget*
gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * ctor )
{
guint row;
guint col;
const char * str;
GtkWidget * w;
GtkWidget * d;
GtkWidget * t;
GtkWidget * l;
GtkWidget * source_chooser;
struct OpenData * data;
bool flag;
GSList * list;
GSList * walk;
/* make the dialog */
d = gtk_dialog_new_with_buttons( _( "Torrent Options" ), parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL );
gtk_dialog_set_default_response( GTK_DIALOG( d ),
GTK_RESPONSE_ACCEPT );
gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_CANCEL,
-1 );
if( tr_ctorGetDownloadDir( ctor, TR_FORCE, &str ) )
g_assert_not_reached( );
g_assert( str );
data = g_new0( struct OpenData, 1 );
data->core = core;
data->ctor = ctor;
data->filename = g_strdup( tr_ctorGetSourceFile( ctor ) );
data->downloadDir = g_strdup( str );
data->file_list = gtr_file_list_new( core, 0 );
str = _( "Mo_ve .torrent file to the trash" );
data->trash_check = gtk_check_button_new_with_mnemonic( str );
str = _( "_Start when added" );
data->run_check = gtk_check_button_new_with_mnemonic( str );
w = data->priority_combo = gtr_priority_combo_new( );
gtr_priority_combo_set_value( GTK_COMBO_BOX( w ), TR_PRI_NORMAL );
g_signal_connect( G_OBJECT( d ), "response",
G_CALLBACK( addResponseCB ), data );
t = gtk_table_new( 6, 2, FALSE );
gtk_container_set_border_width( GTK_CONTAINER( t ), GUI_PAD_BIG );
gtk_table_set_row_spacings( GTK_TABLE( t ), GUI_PAD );
gtk_table_set_col_spacings( GTK_TABLE( t ), GUI_PAD_BIG );
row = col = 0;
l = gtk_label_new_with_mnemonic( _( "_Torrent file:" ) );
gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 );
++col;
w = gtk_file_chooser_button_new( _( "Select Source File" ),
GTK_FILE_CHOOSER_ACTION_OPEN );
source_chooser = w;
gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w );
addTorrentFilters( GTK_FILE_CHOOSER( w ) );
g_signal_connect( w, "selection-changed",
G_CALLBACK( sourceChanged ), data );
++row;
col = 0;
l = gtk_label_new_with_mnemonic( _( "_Destination folder:" ) );
gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 );
++col;
w = gtk_file_chooser_button_new( _( "Select Destination Folder" ),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
if( !gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ),
data->downloadDir ) )
g_warning( "couldn't select '%s'", data->downloadDir );
list = get_recent_destinations( );
for( walk = list; walk; walk = walk->next )
gtk_file_chooser_add_shortcut_folder( GTK_FILE_CHOOSER( w ), walk->data, NULL );
g_slist_free( list );
gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w );
g_signal_connect( w, "selection-changed",
G_CALLBACK( downloadDirChanged ), data );
++row;
col = 0;
w = data->file_list;
gtk_widget_set_size_request ( w, 466u, 300u );
gtk_table_attach_defaults( GTK_TABLE( t ), w, col, col + 2, row, row + 1 );
++row;
col = 0;
w = gtk_label_new_with_mnemonic( _( "Torrent _priority:" ) );
gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.5f );
gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
++col;
gtk_table_attach( GTK_TABLE( t ), data->priority_combo, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
gtk_label_set_mnemonic_widget( GTK_LABEL( w ), data->priority_combo );
++row;
col = 0;
w = data->run_check;
if( tr_ctorGetPaused( ctor, TR_FORCE, &flag ) )
g_assert_not_reached( );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), !flag );
gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 );
++row;
col = 0;
w = data->trash_check;
if( tr_ctorGetDeleteSource( ctor, &flag ) )
g_assert_not_reached( );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), flag );
gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 );
/* trigger sourceChanged, either directly or indirectly,
* so that it creates the tor/gtor objects */
w = source_chooser;
if( data->filename )
gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( w ), data->filename );
else
sourceChanged( GTK_FILE_CHOOSER_BUTTON( w ), data );
gtr_dialog_set_content( GTK_DIALOG( d ), t );
w = gtk_dialog_get_widget_for_response( GTK_DIALOG( d ), GTK_RESPONSE_ACCEPT );
gtk_widget_grab_focus( w );
return d;
}
/* Caller must g_free() the returned filename.*/
gchar *
ghid_dialog_file_select_open (gchar * title, gchar ** path, gchar * shortcuts)
{
GtkWidget *dialog;
gchar *result = NULL, *folder, *seed;
GHidPort *out = &ghid_port;
GtkFileFilter *no_filter;
dialog = gtk_file_chooser_dialog_new (title,
GTK_WINDOW (out->top_window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
/* add a default filter for not filtering files */
no_filter = gtk_file_filter_new ();
gtk_file_filter_set_name (no_filter, "all");
gtk_file_filter_add_pattern (no_filter, "*.*");
gtk_file_filter_add_pattern (no_filter, "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), no_filter);
/* in case we have a dialog for loading a footprint file */
if (strcmp (title, _("Load element to buffer")) == 0)
{
/* add a filter for footprint files */
GtkFileFilter *fp_filter;
fp_filter = gtk_file_filter_new ();
gtk_file_filter_set_name (fp_filter, "fp");
gtk_file_filter_add_mime_type (fp_filter, "application/x-pcb-footprint");
gtk_file_filter_add_pattern (fp_filter, "*.fp");
gtk_file_filter_add_pattern (fp_filter, "*.FP");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), fp_filter);
}
/* in case we have a dialog for loading a layout file */
if ((strcmp (title, _("Load layout file")) == 0)
|| (strcmp (title, _("Load layout file to buffer")) == 0))
{
/* add a filter for layout files */
GtkFileFilter *pcb_filter;
pcb_filter = gtk_file_filter_new ();
gtk_file_filter_set_name (pcb_filter, "pcb");
gtk_file_filter_add_mime_type (pcb_filter, "application/x-pcb-layout");
gtk_file_filter_add_pattern (pcb_filter, "*.pcb");
gtk_file_filter_add_pattern (pcb_filter, "*.PCB");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), pcb_filter);
}
/* in case we have a dialog for loading a netlist file */
if (strcmp (title, _("Load netlist file")) == 0)
{
/* add a filter for netlist files */
GtkFileFilter *net_filter;
net_filter = gtk_file_filter_new ();
gtk_file_filter_set_name (net_filter, "netlist");
gtk_file_filter_add_mime_type (net_filter, "application/x-pcb-netlist");
gtk_file_filter_add_pattern (net_filter, "*.net");
gtk_file_filter_add_pattern (net_filter, "*.NET");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), net_filter);
}
if (path && *path)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), *path);
else
{
gchar *default_path;
default_path = g_get_current_dir();
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), default_path);
g_free(default_path);
}
if (shortcuts && *shortcuts)
{
folder = g_strdup (shortcuts);
seed = folder;
while ((folder = strtok (seed, ":")) != NULL)
{
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
folder, NULL);
seed = NULL;
}
g_free (folder);
}
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
result = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
folder =
gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
if (folder && path)
{
dup_string (path, folder);
g_free (folder);
}
}
gtk_widget_destroy (dialog);
return result;
}
void
gtkutil_file_req (const char *title, void *callback, void *userdata, char *filter, char *extensions,
int flags)
{
struct file_req *freq;
GtkWidget *dialog;
GtkFileFilter *filefilter;
extern char *get_xdir_fs (void);
char *token;
char *tokenbuffer;
if (flags & FRF_WRITE)
{
dialog = gtk_file_chooser_dialog_new (title, NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
if (!(flags & FRF_NOASKOVERWRITE))
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
}
else
dialog = gtk_file_chooser_dialog_new (title, NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
if (filter && filter[0] && (flags & FRF_FILTERISINITIAL))
{
if (flags & FRF_WRITE)
{
char temp[1024];
path_part (filter, temp, sizeof (temp));
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), temp);
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), file_part (filter));
}
else
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter);
}
else if (!(flags & FRF_RECENTLYUSED))
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), get_xdir ());
if (flags & FRF_MULTIPLE)
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);
if (flags & FRF_CHOOSEFOLDER)
gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
if ((flags & FRF_EXTENSIONS || flags & FRF_MIMETYPES) && extensions != NULL)
{
filefilter = gtk_file_filter_new ();
tokenbuffer = g_strdup (extensions);
token = strtok (tokenbuffer, ";");
while (token != NULL)
{
if (flags & FRF_EXTENSIONS)
gtk_file_filter_add_pattern (filefilter, token);
else
gtk_file_filter_add_mime_type (filefilter, token);
token = strtok (NULL, ";");
}
g_free (tokenbuffer);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filefilter);
}
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), get_xdir (), NULL);
freq = malloc (sizeof (struct file_req));
freq->dialog = dialog;
freq->flags = flags;
freq->callback = callback;
freq->userdata = userdata;
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (gtkutil_file_req_response), freq);
g_signal_connect (G_OBJECT (dialog), "destroy",
G_CALLBACK (gtkutil_file_req_destroy), (gpointer) freq);
gtk_widget_show (dialog);
}
PreferencesPageDCC *
preferences_page_dcc_new (gpointer prefs_dialog, GtkBuilder *xml)
{
PreferencesPageDCC *page = g_object_new (PREFERENCES_PAGE_DCC_TYPE, NULL);
PreferencesDialog *p = (PreferencesDialog *) prefs_dialog;
#define GW(name) GtkWidget *name = GTK_WIDGET (gtk_builder_get_object (xml, #name))
GW(download_dir_button);
GW(completed_dir_button);
GW(convert_spaces);
GW(save_nicknames_dcc);
GW(autoaccept_dcc_chat);
GW(autoaccept_dcc_file);
GW(get_dcc_ip_from_server);
GW(use_specified_dcc_ip);
GW(special_ip_address);
GW(individual_send_throttle);
GW(global_send_throttle);
GW(individual_receive_throttle);
GW(global_receive_throttle);
#undef GW
page->special_ip_address = special_ip_address;
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER (download_dir_button), get_default_download_dir(), NULL);
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (download_dir_button), prefs.dccdir);
if (strlen (prefs.dcc_completed_dir) == 0) {
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (completed_dir_button), prefs.dccdir);
} else {
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER (completed_dir_button), get_default_download_dir(), NULL);
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (completed_dir_button), prefs.dcc_completed_dir);
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (convert_spaces), prefs.dcc_send_fillspaces);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (save_nicknames_dcc), prefs.dccwithnick);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (autoaccept_dcc_chat), prefs.autodccchat);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (autoaccept_dcc_file), prefs.autodccsend);
if (prefs.ip_from_server) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (get_dcc_ip_from_server), TRUE);
gtk_widget_set_sensitive (special_ip_address, FALSE);
} else {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (use_specified_dcc_ip), TRUE);
gtk_entry_set_text (GTK_ENTRY (special_ip_address), prefs.dcc_ip_str);
gtk_widget_set_sensitive (special_ip_address, FALSE);
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (individual_send_throttle), (gdouble) prefs.dcc_max_send_cps);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (global_send_throttle), (gdouble) prefs.dcc_global_max_send_cps);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (individual_receive_throttle), (gdouble) prefs.dcc_max_get_cps);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (global_receive_throttle), (gdouble) prefs.dcc_global_max_get_cps);
g_signal_connect (G_OBJECT (download_dir_button), "selection-changed", G_CALLBACK (path_changed), prefs.dccdir);
g_signal_connect (G_OBJECT (completed_dir_button), "selection-changed", G_CALLBACK (path_changed), prefs.dcc_completed_dir);
g_signal_connect (G_OBJECT (convert_spaces), "toggled", G_CALLBACK (toggle_changed), &prefs.dcc_send_fillspaces);
g_signal_connect (G_OBJECT (save_nicknames_dcc), "toggled", G_CALLBACK (toggle_changed), &prefs.dccwithnick);
g_signal_connect (G_OBJECT (autoaccept_dcc_chat), "toggled", G_CALLBACK (toggle_changed), &prefs.autodccchat);
g_signal_connect (G_OBJECT (autoaccept_dcc_file), "toggled", G_CALLBACK (toggle_changed), &prefs.autodccsend);
g_signal_connect (G_OBJECT (get_dcc_ip_from_server), "toggled", G_CALLBACK (get_ip_from_server_changed), page);
g_signal_connect (G_OBJECT (special_ip_address), "changed", G_CALLBACK (special_ip_changed), NULL);
g_signal_connect (G_OBJECT (individual_send_throttle), "value-changed", G_CALLBACK (spin_changed), &prefs.dcc_max_send_cps);
g_signal_connect (G_OBJECT (global_send_throttle), "value-changed", G_CALLBACK (spin_changed), &prefs.dcc_global_max_send_cps);
g_signal_connect (G_OBJECT (individual_receive_throttle), "value-changed", G_CALLBACK (spin_changed), &prefs.dcc_max_get_cps);
g_signal_connect (G_OBJECT (global_receive_throttle), "value-changed", G_CALLBACK (spin_changed), &prefs.dcc_global_max_get_cps);
GtkIconTheme *theme = gtk_icon_theme_get_default ();
PREFERENCES_PAGE (page)->icon = gtk_icon_theme_load_icon (theme, "xchat-gnome-dcc", 16, 0, NULL);
GtkTreeIter iter;
gtk_list_store_append (p->page_store, &iter);
gtk_list_store_set (p->page_store, &iter, 0, PREFERENCES_PAGE (page)->icon, 1, _("File Transfers & DCC"), 2, 3, -1);
return page;
}
/*****************************************************************************
* run_session_load_dialog()
*
* Callback for running the 'Load Session' dialog from the main menu.
*****************************************************************************/
void
run_session_load_dialog(GtkWidget *UNUSED(widget), gpointer UNUSED(data))
{
SESSION *session = get_current_session();
PATCH *patch;
DIR_LIST *pdir = session_dir_list;
char *directory;
GSList *file_list;
GSList *cur;
GError *error;
unsigned int sess_num = session_io_start;
unsigned int part_num;
/* create dialog if needed */
if (session_load_dialog == NULL) {
create_session_load_dialog();
}
gtk_widget_show(session_load_dialog);
/* add all session directories to shortcuts */
while (pdir != NULL) {
if (!pdir->load_shortcut) {
error = NULL;
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_load_dialog),
pdir->name, &error);
if (error != NULL) {
PHASEX_ERROR("Error %d: %s\n", error->code, error->message);
g_error_free(error);
}
pdir->load_shortcut = 1;
}
pdir = pdir->next;
}
/* set filename and current directory */
if ((session->directory != NULL) && (* (session->directory) != '\0')) {
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(session_load_dialog), session->directory);
}
else if ((session->parent_dir != NULL) && (* (session->parent_dir) != '\0')) {
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_load_dialog),
session->parent_dir);
}
else {
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_load_dialog),
user_session_dir);
}
/* set position in patch bank to start loading patches */
session_io_start = visible_sess_num;
gtk_adjustment_set_value(GTK_ADJUSTMENT(session_io_start_adj), (session_io_start + 1));
/* run the dialog and load if necessary */
if (gtk_dialog_run(GTK_DIALOG(session_load_dialog)) == GTK_RESPONSE_ACCEPT) {
/* get list of selected files from chooser */
file_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(session_load_dialog));
if (file_list != NULL) {
session_io_start =
(unsigned int) gtk_adjustment_get_value(GTK_ADJUSTMENT(session_io_start_adj)) - 1;
/* read in each session and increment session bank slot number */
sess_num = session_io_start;
session_load_in_progress = 1;
cur = file_list;
while (cur != NULL) {
directory = (char *) cur->data;
if (load_session(directory, sess_num) == 0) {
if (sess_num == visible_sess_num) {
for (part_num = 0; part_num < MAX_PARTS; part_num++) {
visible_prog_num[part_num] = 0;
patch = set_active_patch(visible_sess_num, part_num, 0);
init_patch_state(patch);
if (part_num == visible_part_num) {
update_gui_patch(patch, 0);
}
}
}
sess_num++;
}
if (sess_num >= SESSION_BANK_SIZE) {
break;
}
cur = g_slist_next(cur);
}
session_load_in_progress = 0;
g_slist_free(file_list);
update_gui_patch_name();
update_gui_session_name();
save_session_bank();
}
}
/* save this widget for next time */
gtk_widget_hide(session_load_dialog);
}
/*!
\brief pops up a Filechooser dialog to select a file
\param data is a pointer to a MtxFileIO structure which contains important
bits like the path to start, the filter, default filename and so on
\see MtxFileIO
\returns the path to the file or NULL if cancelled
*/
gchar * choose_file(MtxFileIO *data)
{
GtkWidget *dialog = NULL;
GtkFileFilter *filter = NULL;
gchar * path = NULL;
gchar * defdir = NULL;
gchar *filename = NULL;
gchar *tmpbuf = NULL;
gchar **vector = NULL;
gint response = 0;
gboolean res = FALSE;
guint i = 0;
if (!GTK_IS_WINDOW(data->parent))
data->parent = NULL;
/*
printf("choose_file\n");
printf("filter %s\n",data->filter);
printf("filename %s\n",data->filename);
printf("default_path %s\n",data->default_path);
printf("title %s\n",data->title);
*/
if (!data->project)
data->project = DEFAULT_PROJECT;
if (!data->title)
data->title = g_strdup("Open File");
if ((data->action == GTK_FILE_CHOOSER_ACTION_OPEN) ||
(data->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER))
{
dialog = gtk_file_chooser_dialog_new(data->title,
GTK_WINDOW(data->parent),
data->action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
if ((data->on_top) && (GTK_IS_WIDGET(data->parent)))
gtk_window_set_transient_for(GTK_WINDOW(gtk_widget_get_toplevel(dialog)),GTK_WINDOW(data->parent));
if ((data->absolute_path) && (!data->default_path))
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),data->absolute_path);
else if (data->default_path)
{
path = g_build_filename(MTXSYSDATA,data->default_path,NULL);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),path);
g_free(path);
}
}
else if (data->action == GTK_FILE_CHOOSER_ACTION_SAVE)
{
dialog = gtk_file_chooser_dialog_new(data->title,
GTK_WINDOW(data->parent),
data->action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
if ((data->on_top) && (GTK_IS_WIDGET(data->parent)))
gtk_window_set_transient_for(GTK_WINDOW(gtk_widget_get_toplevel(dialog)),GTK_WINDOW(data->parent));
defdir = g_build_filename(HOME(),"mtx",data->project,data->default_path, NULL);
if (!g_file_test(defdir,G_FILE_TEST_IS_DIR))
g_mkdir(defdir,0755);
/* If filename passed check/adj path */
if (data->filename)
{
#ifdef __WIN32__ /* Disallows modifying distributed files */
if (g_strrstr(data->filename,"dist") != NULL)
#else
if (g_strrstr(data->filename,DATA_DIR) != NULL)
#endif
{
vector = g_strsplit(data->filename,PSEP,-1);
tmpbuf = g_strconcat(defdir,PSEP,vector[g_strv_length(vector)-1],NULL);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),defdir);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),vector[g_strv_length(vector)-1]);
g_strfreev(vector);
g_free(tmpbuf);
}
else
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),data->filename);
}
else
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),defdir);
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), data->default_filename );
}
g_free(defdir);
}
else
return NULL;
/* Add shortcut folders... */
if (data->shortcut_folders)
{
vector = g_strsplit(data->shortcut_folders,",",-1);
for (i=0;i<g_strv_length(vector);i++)
{
path = g_build_filename(MTXSYSDATA,vector[i],NULL);
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),path,NULL);
g_free(path);
path = g_build_filename(HOME(),"mtx",data->project,vector[i],NULL);
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),path,NULL);
g_free(path);
}
g_strfreev(vector);
}
/* If default path switch to that place */
if ((data->external_path) && (!(data->default_path)))
{
path = g_build_filename(HOME(),"mtx",data->project,data->external_path,NULL);
if (!g_file_test(path,G_FILE_TEST_IS_DIR))
g_mkdir(path,0755);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),path);
g_free(path);
}
/* If filters, assign them */
if (data->filter)
{
vector = g_strsplit(data->filter,",",-1);
if (g_strv_length(vector)%2 > 0)
goto afterfilter;
for (i=0;i<g_strv_length(vector);i+=2)
{
filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter),vector[i]);
gtk_file_filter_set_name(GTK_FILE_FILTER(filter),vector[i+1]);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog),filter);
}
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog),filter);
g_strfreev(vector);
}
afterfilter:
/* Turn on overwriteconfirmation */
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
g_signal_connect(G_OBJECT(dialog),"confirm-overwrite",
G_CALLBACK (confirm_overwrite_callback), NULL);
if (data->action == GTK_FILE_CHOOSER_ACTION_OPEN)
if (data->default_filename)
gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog),data->default_filename);
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_ACCEPT)
{
tmpbuf = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
if ((data->action == GTK_FILE_CHOOSER_ACTION_SAVE) && (data->default_extension))
{
if(!g_str_has_suffix (tmpbuf,data->default_extension))
filename = g_strjoin(".",tmpbuf,data->default_extension,NULL);
else
filename = g_strdup(tmpbuf);
}
else
filename = g_strdup(tmpbuf);
g_free(tmpbuf);
}
gtk_widget_destroy (dialog);
return (filename);
}
/*****************************************************************************
* create_session_save_dialog()
*****************************************************************************/
void
create_session_save_dialog(void)
{
GError *error = NULL;
GtkWidget *hbox;
GtkWidget *label;
int new_adj = (session_io_start_adj == NULL);
/* this should only need to happen once */
if (session_save_dialog == NULL) {
/* create dialog */
session_save_dialog = gtk_file_chooser_dialog_new("PHASEX - Save Session",
GTK_WINDOW(main_window),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE,
GTK_RESPONSE_ACCEPT,
NULL);
gtk_window_set_wmclass(GTK_WINDOW(session_save_dialog), "phasex", "phasex-save");
gtk_window_set_role(GTK_WINDOW(session_save_dialog), "session-save");
gtk_file_chooser_set_preview_widget_active
(GTK_FILE_CHOOSER(session_save_dialog), FALSE);
/* create spinbutton control of session number */
hbox = gtk_hbox_new(FALSE, 8);
label = gtk_label_new("Save into session #:");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 8);
if (new_adj) {
session_io_start_adj = gtk_adjustment_new(0, 1, PATCH_BANK_SIZE, 1, 8, 0);
}
session_save_start_spin = gtk_spin_button_new(GTK_ADJUSTMENT(session_io_start_adj), 0, 0);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(session_save_start_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(session_save_start_spin),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(session_save_start_spin), TRUE);
gtk_adjustment_set_value(GTK_ADJUSTMENT(session_io_start_adj), (session_io_start + 1));
gtk_box_pack_start(GTK_BOX(hbox), session_save_start_spin, FALSE, FALSE, 8);
if (new_adj) {
g_signal_connect(GTK_OBJECT(session_save_start_spin), "value_changed",
GTK_SIGNAL_FUNC(set_session_io_start),
(gpointer) session_io_start_adj);
}
gtk_widget_show_all(hbox);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(session_save_dialog), hbox);
/* realize the file chooser before telling it about files */
gtk_widget_realize(session_save_dialog);
#if GTK_CHECK_VERSION(2, 8, 0)
/* this can go away once manual overwrite checks are proven to work properly */
gtk_file_chooser_set_do_overwrite_confirmation
(GTK_FILE_CHOOSER(session_save_dialog), TRUE);
#endif
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(session_save_dialog), TRUE);
#endif
/* add user session dir as shortcut folder (user cannot write to sys) */
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_save_dialog),
user_session_dir, &error);
if (error != NULL) {
PHASEX_ERROR("Error %d: %s\n", error->code, error->message);
g_error_free(error);
}
/* start in user session dir (usually ~/.phasex/user-sessions) */
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_save_dialog),
user_session_dir);
}
}
void
gtkutil_file_req (const char *title, void *callback, void *userdata, char *filter, char *extensions,
int flags)
{
struct file_req *freq;
GtkWidget *dialog;
GtkFileFilter *filefilter;
extern char *get_xdir_fs (void);
char *token;
char *tokenbuffer;
#if 0 /* native file dialogs */
#ifdef WIN32
if (!(flags & FRF_WRITE))
{
freq = malloc (sizeof (struct file_req));
freq->th = thread_new ();
freq->flags = 0;
freq->multiple = (flags & FRF_MULTIPLE);
freq->callback = callback;
freq->userdata = userdata;
freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0);
if (!filter)
{
freq->filter = "All files\0*.*\0"
"Executables\0*.exe\0"
"ZIP files\0*.zip\0\0";
}
else
{
freq->filter = filter;
}
thread_start (freq->th, win32_thread, freq);
fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq);
return;
}
else {
freq = malloc (sizeof (struct file_req));
freq->th = thread_new ();
freq->flags = 0;
freq->multiple = (flags & FRF_MULTIPLE);
freq->callback = callback;
freq->userdata = userdata;
freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0);
if (!filter)
{
freq->filter = "All files\0*.*\0\0";
}
else
{
freq->filter = filter;
}
thread_start (freq->th, win32_thread2, freq);
fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq);
return;
}
#endif
#endif
if (flags & FRF_WRITE)
{
dialog = gtk_file_chooser_dialog_new (title, NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
if (filter && filter[0]) /* filter becomes initial name when saving */
{
char temp[1024];
path_part (filter, temp, sizeof (temp));
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), temp);
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), file_part (filter));
}
if (!(flags & FRF_NOASKOVERWRITE))
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
}
else
dialog = gtk_file_chooser_dialog_new (title, NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
if (flags & FRF_MULTIPLE)
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);
if (last_dir[0])
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), last_dir);
if (flags & FRF_ADDFOLDER)
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
get_xdir (), NULL);
if (flags & FRF_CHOOSEFOLDER)
{
gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter);
}
else
{
if (filter && (flags & FRF_FILTERISINITIAL))
{
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter);
}
/* With DCC, we can't rely on filter as initial folder since filter already contains
* the filename upon DCC RECV. Thus we have no better option than to check for the message
* which will be the title of the window. For DCC it always contains the "offering" word.
* This method is really ugly but it works so we'll stick with it for now.
*/
else if (strstr (title, "offering") != NULL)
{
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), prefs.hex_dcc_dir);
}
/* by default, open the config folder */
else
{
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), get_xdir ());
}
}
if (flags & FRF_EXTENSIONS && extensions != NULL)
{
filefilter = gtk_file_filter_new ();
tokenbuffer = g_strdup (extensions);
token = strtok (tokenbuffer, ";");
while (token != NULL)
{
gtk_file_filter_add_pattern (filefilter, token);
token = strtok (NULL, ";");
}
g_free (tokenbuffer);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filefilter);
}
freq = malloc (sizeof (struct file_req));
freq->dialog = dialog;
freq->flags = flags;
freq->callback = callback;
freq->userdata = userdata;
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (gtkutil_file_req_response), freq);
g_signal_connect (G_OBJECT (dialog), "destroy",
G_CALLBACK (gtkutil_file_req_destroy), (gpointer) freq);
gtk_widget_show (dialog);
}
static void
avatar_chooser_clicked_cb (GtkWidget *button,
EmpathyAvatarChooser *chooser)
{
GtkFileChooser *chooser_dialog;
GtkWidget *image;
gchar *saved_dir = NULL;
const gchar *default_dir = DEFAULT_DIR;
const gchar *pics_dir;
GtkFileFilter *filter;
EmpathyAvatarChooserPriv *priv = GET_PRIV (chooser);
if (priv->chooser_dialog) {
gtk_window_present (GTK_WINDOW (priv->chooser_dialog));
return;
}
priv->chooser_dialog = GTK_FILE_CHOOSER (
gtk_file_chooser_dialog_new (_("Select Your Avatar Image"),
empathy_get_toplevel_window (GTK_WIDGET (chooser)),
GTK_FILE_CHOOSER_ACTION_OPEN,
_("No Image"),
GTK_RESPONSE_NO,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN,
GTK_RESPONSE_OK,
NULL));
chooser_dialog = priv->chooser_dialog;
gtk_window_set_destroy_with_parent (GTK_WINDOW (chooser_dialog), TRUE);
/* Get special dirs */
empathy_conf_get_string (empathy_conf_get (),
EMPATHY_PREFS_UI_AVATAR_DIRECTORY,
&saved_dir);
if (saved_dir && !g_file_test (saved_dir, G_FILE_TEST_IS_DIR)) {
g_free (saved_dir);
saved_dir = NULL;
}
if (!g_file_test (default_dir, G_FILE_TEST_IS_DIR)) {
default_dir = NULL;
}
pics_dir = g_get_user_special_dir (G_USER_DIRECTORY_PICTURES);
if (pics_dir && !g_file_test (pics_dir, G_FILE_TEST_IS_DIR)) {
pics_dir = NULL;
}
/* Set current dir to the last one or to DEFAULT_DIR or to home */
if (saved_dir) {
gtk_file_chooser_set_current_folder (chooser_dialog, saved_dir);
}
else if (pics_dir) {
gtk_file_chooser_set_current_folder (chooser_dialog, pics_dir);
}
else if (default_dir) {
gtk_file_chooser_set_current_folder (chooser_dialog, default_dir);
} else {
gtk_file_chooser_set_current_folder (chooser_dialog, g_get_home_dir ());
}
/* Add shortcuts to special dirs */
if (saved_dir) {
gtk_file_chooser_add_shortcut_folder (chooser_dialog, saved_dir, NULL);
}
else if (pics_dir) {
gtk_file_chooser_add_shortcut_folder (chooser_dialog, pics_dir, NULL);
}
if (default_dir) {
gtk_file_chooser_add_shortcut_folder (chooser_dialog, default_dir, NULL);
}
/* Setup preview image */
image = gtk_image_new ();
gtk_file_chooser_set_preview_widget (chooser_dialog, image);
gtk_widget_set_size_request (image, AVATAR_SIZE_SAVE, AVATAR_SIZE_SAVE);
gtk_widget_show (image);
gtk_file_chooser_set_use_preview_label (chooser_dialog, FALSE);
g_signal_connect (chooser_dialog, "update-preview",
G_CALLBACK (avatar_chooser_update_preview_cb),
chooser);
/* Setup filers */
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Images"));
gtk_file_filter_add_pixbuf_formats (filter);
gtk_file_chooser_add_filter (chooser_dialog, 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 (chooser_dialog, filter);
/* Setup response */
gtk_dialog_set_default_response (GTK_DIALOG (chooser_dialog), GTK_RESPONSE_OK);
g_signal_connect (chooser_dialog, "response",
G_CALLBACK (avatar_chooser_response_cb),
chooser);
gtk_widget_show (GTK_WIDGET (chooser_dialog));
g_free (saved_dir);
}
int
main (int argc,
char *argv[])
{
GtkWidget *win, *vbox, *frame, *alignment, *group_box;
GtkWidget *hbox, *label, *chooser, *button;
GtkSizeGroup *label_group;
GOptionContext *context;
gchar *cwd;
context = g_option_context_new ("- test GtkFileChooserButton widget");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
gtk_init (&argc, &argv);
/* to test rtl layout, use "--right-to-left" */
if (rtl)
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
cwd = g_get_current_dir();
gtk_src_dir = g_path_get_dirname (cwd);
g_free (cwd);
win = gtk_dialog_new_with_buttons ("TestFileChooserButton", NULL, 0,
"_Quit", GTK_RESPONSE_CLOSE, NULL);
g_signal_connect (win, "response", G_CALLBACK (gtk_main_quit), NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
g_object_set (vbox, "margin", 6, NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (win))), vbox);
frame = gtk_frame_new ("<b>GtkFileChooserButton</b>");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_label_set_use_markup (GTK_LABEL (gtk_frame_get_label_widget (GTK_FRAME (frame))), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 0, 12, 0);
gtk_container_add (GTK_CONTAINER (frame), alignment);
label_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
group_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (alignment), group_box);
/* OPEN */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (group_box), hbox, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic ("_Open:");
gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
chooser = gtk_file_chooser_button_new ("Select A File - testfilechooserbutton",
GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser);
g_signal_connect (chooser, "current-folder-changed",
G_CALLBACK (chooser_current_folder_changed_cb), NULL);
g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL);
g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL);
g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL);
gtk_box_pack_start (GTK_BOX (hbox), chooser, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Properties");
g_signal_connect (button, "clicked", G_CALLBACK (properties_button_clicked_cb), chooser);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Tests");
g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
/* SELECT_FOLDER */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (group_box), hbox, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic ("Select _Folder:");
gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
chooser = gtk_file_chooser_button_new ("Select A Folder - testfilechooserbutton",
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser);
g_signal_connect (chooser, "current-folder-changed",
G_CALLBACK (chooser_current_folder_changed_cb), NULL);
g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL);
g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL);
g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL);
gtk_box_pack_start (GTK_BOX (hbox), chooser, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Properties");
g_signal_connect (button, "clicked", G_CALLBACK (properties_button_clicked_cb), chooser);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Tests");
g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
g_object_unref (label_group);
gtk_widget_show_all (win);
gtk_window_present (GTK_WINDOW (win));
gtk_main ();
return 0;
}
/*****************************************************************************
* run_session_save_as_dialog()
*****************************************************************************/
void
run_session_save_as_dialog(GtkWidget *UNUSED(widget), gpointer data)
{
SESSION *session = get_current_session();
char *directory = (char *) data;
char *session_dir;
DIR_LIST *pdir = session_dir_list;
GError *error;
/* create dialog if needed */
if (session_save_dialog == NULL) {
create_session_save_dialog();
}
/* add all session dirs as shortcut folders */
while (pdir != NULL) {
if ((!pdir->save_shortcut)) {
error = NULL;
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_save_dialog),
pdir->name, &error);
if (error != NULL) {
PHASEX_ERROR("Error %d: %s\n", error->code, error->message);
g_error_free(error);
}
pdir->save_shortcut = 1;
}
pdir = pdir->next;
}
/* set filename and current directory */
if ((directory == NULL) || (*directory == '\0')) {
directory = session->directory;
}
/* if we have a directory, and it's not the sessiondump, set and select it */
if ((directory != NULL) && (strcmp(directory, user_session_dump_dir) != 0)) {
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(session_save_dialog), directory);
}
/* if there is no filename, try to set the current directory */
else if ((session->parent_dir != NULL) && (* (session->parent_dir) != '\0')) {
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_save_dialog),
session->parent_dir);
}
else {
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_save_dialog),
user_session_dir);
}
/* set position in session bank to save session */
/* session_io_start should already be set properly at this point. */
gtk_spin_button_set_value(GTK_SPIN_BUTTON(session_save_start_spin), (session_io_start + 1));
/* run the dialog and save if necessary */
if (gtk_dialog_run(GTK_DIALOG(session_save_dialog)) == GTK_RESPONSE_ACCEPT) {
session_dir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(session_save_dialog));
session_io_start =
(unsigned int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(session_save_start_spin)) - 1;
/* hide dialog and save session */
gtk_widget_hide(session_save_dialog);
switch (setting_bank_mem_mode) {
case BANK_MEM_AUTOSAVE:
/* save session without overwrite protection */
if (save_session(session_dir, session_io_start) == 0) {
update_gui_session_name();
save_session_bank();
}
break;
case BANK_MEM_WARN:
case BANK_MEM_PROTECT:
/* save session with overwrite protection */
if (!check_session_overwrite(session_dir)) {
if (save_session(session_dir, session_io_start) == 0) {
update_gui_session_name();
save_session_bank();
}
}
break;
}
g_free(session_dir);
}
else {
/* save this widget for next time */
gtk_widget_hide(session_save_dialog);
}
}
/*!
\brief pops up a Filechooser dialog to select a file
\param data is a pointer to a MtxFileIO structure which contains important
bits like the path to start, the filter, default filename and so on
\see MtxFileIO
\returns the path to the file or NULL if cancelled
*/
gchar * choose_file(MtxFileIO *data)
{
GtkWidget *dialog = NULL;
GtkFileFilter *filter = NULL;
GSList *filters = NULL;
gchar *path = NULL;
gchar *defdir = NULL;
gchar *filename = NULL;
gchar *tmpbuf = NULL;
gchar **vector = NULL;
const gchar *project = NULL;
gint response = 0;
gboolean res = FALSE;
guint i = 0;
ENTER();
if (!GTK_IS_WINDOW(data->parent))
data->parent = NULL;
/*
printf("choose_file\n");
printf("parent %p\n",(void *)data->parent);
printf("on_top %s\n",data->on_top? "TRUE":"FALSE");
printf("filter %s\n",data->filter);
printf("filename %s\n",data->filename);
printf("default_filename %s\n",data->default_filename);
printf("default_extension %s\n",data->default_extension);
printf("absolute_path %s\n",data->absolute_path);
printf("default_path %s\n",data->default_path);
printf("external_path %s\n",data->external_path);
printf("shortcut_folders %s\n",data->shortcut_folders);
printf("project %s\n",data->project);
printf("title %s\n",data->title);
*/
if (data->project)
project = data->project;
else
project = DEFAULT_PROJECT;
if (!data->title)
data->title = g_strdup("Open File");
if ((data->action == GTK_FILE_CHOOSER_ACTION_OPEN) ||
(data->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER))
{
/*printf("ACTION_OPEN before gtk_file_chooser_dialog_new\n");*/
dialog = gtk_file_chooser_dialog_new(data->title,
/*GTK_WINDOW(data->parent), */
0,
data->action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
/*printf("after gtk_file_chooser_dialog_new\n");*/
if ((data->on_top) && (GTK_IS_WIDGET(data->parent)))
gtk_window_set_transient_for(GTK_WINDOW(gtk_widget_get_toplevel(dialog)),GTK_WINDOW(data->parent));
if ((data->absolute_path) && (!data->default_path))
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),data->absolute_path);
else if (data->default_path)
{
/*printf("should be using system path + %s\n",data->default_path);*/
path = g_build_filename(MTXSYSDATA,data->default_path,NULL);
if (!g_file_test(path,G_FILE_TEST_IS_DIR))
{
g_free(path);
path = g_build_filename(HOME(),"mtx",data->project,data->default_path, NULL);
/*printf("System path is not found, falling back to user path %s\n",path);*/
}
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),path);
g_free(path);
}
}
else if (data->action == GTK_FILE_CHOOSER_ACTION_SAVE)
{
/*printf("ACTION_SAVE calling gtk_file_chooser_dialog_new\n");*/
dialog = gtk_file_chooser_dialog_new(data->title,
/*GTK_WINDOW(data->parent), */
0,
data->action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
/*printf("after gtk_file_chooser_dialog_new\n");*/
/* if ((data->on_top) && (GTK_IS_WIDGET(data->parent)))
gtk_window_set_transient_for(GTK_WINDOW(gtk_widget_get_toplevel(dialog)),GTK_WINDOW(data->parent));
*/
if (data->default_path)
{
defdir = g_build_filename(HOME(),"mtx",data->project,data->default_path, NULL);
if (!g_file_test(defdir,G_FILE_TEST_IS_DIR))
g_mkdir(defdir,0755);
}
else
defdir = g_build_filename(HOME(),"mtx",data->project, NULL);
/* If filename passed check/adj path */
if (data->filename)
{
if (g_strrstr(data->filename,DATA_DIR) != NULL)
{
vector = g_strsplit(data->filename,PSEP,-1);
tmpbuf = g_strconcat(defdir,PSEP,vector[g_strv_length(vector)-1],NULL);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),defdir);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),vector[g_strv_length(vector)-1]);
g_strfreev(vector);
g_free(tmpbuf);
}
else
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),data->filename);
}
else
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),defdir);
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), data->default_filename );
}
g_free(defdir);
}
else
{
EXIT();
return NULL;
}
/* Add shortcut folders... */
if (data->shortcut_folders)
{
vector = g_strsplit(data->shortcut_folders,",",-1);
for (i=0;i<g_strv_length(vector);i++)
{
path = g_build_filename(MTXSYSDATA,vector[i],NULL);
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),path,NULL);
g_free(path);
path = g_build_filename(HOME(),"mtx",data->project,vector[i],NULL);
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),path,NULL);
g_free(path);
}
g_strfreev(vector);
}
/* If default path switch to that place */
if ((data->external_path) && (!(data->default_path)))
{
/*printf("external path with no default path\n");*/
path = g_build_filename(HOME(),"mtx",data->project,data->external_path,NULL);
if (!g_file_test(path,G_FILE_TEST_IS_DIR))
g_mkdir(path,0755);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),path);
g_free(path);
}
/* If filters, assign them
CAUSES SEGFAULTS???
*/
/*
if (data->filter)
{
printf("data->filter is set to \"%s\"\n",data->filter);
vector = g_strsplit(data->filter,",",-1);
if (g_strv_length(vector)%2 > 0)
goto afterfilter;
for (i=0;i<g_strv_length(vector);i+=2)
{
filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter),vector[i]);
printf("Filter glob is set to \"%s\"\n",vector[i]);
gtk_file_filter_set_name(GTK_FILE_FILTER(filter),vector[i+1]);
printf("Filter name is set to \"%s\"\n",vector[i+1]);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog),filter);
}
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog),filter);
g_strfreev(vector);
}
*/
afterfilter:
/* Turn on overwriteconfirmation */
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
g_signal_connect(G_OBJECT(dialog),"confirm-overwrite",
G_CALLBACK (confirm_overwrite_callback), NULL);
if (data->action == GTK_FILE_CHOOSER_ACTION_OPEN)
{
if (data->default_filename)
{
/*printf("data->default_filename is set to \"%s\"\n",data->default_filename);*/
gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog),data->default_filename);
}
}
/*printf("initiating dialog to run\n");*/
response = gtk_dialog_run (GTK_DIALOG (dialog));
/*printf("it returned \n");*/
if (response == GTK_RESPONSE_ACCEPT)
{
tmpbuf = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
if ((data->action == GTK_FILE_CHOOSER_ACTION_SAVE) && (data->default_extension))
{
if(!g_str_has_suffix (tmpbuf,data->default_extension))
filename = g_strjoin(".",tmpbuf,data->default_extension,NULL);
else
filename = g_strdup(tmpbuf);
}
else
filename = g_strdup(tmpbuf);
g_free(tmpbuf);
}
filters = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(dialog));
if (filters)
{
g_slist_foreach(filters, remove_filter ,dialog);
g_slist_free(filters);
}
gtk_widget_destroy (dialog);
EXIT();
return (filename);
}
GtkFileChooser *
ephy_create_file_chooser (const char *title,
GtkWidget *parent,
GtkFileChooserAction action,
EphyFileFilterDefault default_filter)
{
GtkFileChooser *dialog;
GtkFileFilter *filter[EPHY_FILE_FILTER_LAST];
g_autofree char *downloads_dir = NULL;
GtkWidget *preview = gtk_image_new ();
g_assert (GTK_IS_WINDOW (parent));
g_assert (default_filter >= 0 && default_filter <= EPHY_FILE_FILTER_LAST);
dialog = GTK_FILE_CHOOSER (gtk_file_chooser_native_new (title,
GTK_WINDOW (parent),
action,
NULL,
_("_Cancel")));
gtk_native_dialog_set_modal (GTK_NATIVE_DIALOG (dialog), TRUE);
downloads_dir = ephy_file_get_downloads_dir ();
gtk_file_chooser_add_shortcut_folder (dialog, downloads_dir, NULL);
if (action == GTK_FILE_CHOOSER_ACTION_OPEN ||
action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER) {
gtk_file_chooser_native_set_accept_label (GTK_FILE_CHOOSER_NATIVE (dialog), _("_Open"));
} else if (action == GTK_FILE_CHOOSER_ACTION_SAVE) {
gtk_file_chooser_native_set_accept_label (GTK_FILE_CHOOSER_NATIVE (dialog), _("_Save"));
}
gtk_file_chooser_set_preview_widget (dialog, preview);
gtk_file_chooser_set_use_preview_label (dialog, FALSE);
g_signal_connect (dialog, "update-preview",
G_CALLBACK (update_preview_cb),
preview);
if (default_filter != EPHY_FILE_FILTER_NONE) {
filter[EPHY_FILE_FILTER_ALL_SUPPORTED] =
ephy_file_chooser_add_mime_filter
(dialog,
_("All supported types"),
"text/html",
"application/xhtml+xml",
"text/xml",
"message/rfc822", /* MHTML */
"multipart/related", /* MHTML */
"application/x-mimearchive", /* MHTML */
"image/png",
"image/jpeg",
"image/gif",
"image/webp",
NULL);
filter[EPHY_FILE_FILTER_WEBPAGES] =
ephy_file_chooser_add_mime_filter
(dialog, _("Web pages"),
"text/html",
"application/xhtml+xml",
"text/xml",
"message/rfc822", /* MHTML */
"multipart/related", /* MHTML */
"application/x-mimearchive", /* MHTML */
NULL);
filter[EPHY_FILE_FILTER_IMAGES] =
ephy_file_chooser_add_mime_filter
(dialog, _("Images"),
"image/png",
"image/jpeg",
"image/gif",
"image/webp",
NULL);
filter[EPHY_FILE_FILTER_ALL] =
ephy_file_chooser_add_pattern_filter
(dialog, _("All files"), "*", NULL);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog),
filter[default_filter]);
}
return dialog;
}
/* Caller must g_slist_free() the returned list .*/
GSList *
ghid_dialog_file_select_multiple(gchar * title, gchar ** path, gchar * shortcuts)
{
GtkWidget *dialog;
GSList *result = NULL;
gchar *folder, *seed;
GHidPort *out = &ghid_port;
GtkFileFilter *no_filter;
dialog = gtk_file_chooser_dialog_new (title,
GTK_WINDOW (out->top_window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER (dialog), TRUE);
/* add a default filter for not filtering files */
no_filter = gtk_file_filter_new ();
gtk_file_filter_set_name (no_filter, "all");
gtk_file_filter_add_pattern (no_filter, "*.*");
gtk_file_filter_add_pattern (no_filter, "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), no_filter);
/* in case we have a dialog for loading schematic files */
if (strcmp (title, _("Load schematics")) == 0)
{
/* add a filter for schematic files */
GtkFileFilter *sch_filter;
sch_filter = gtk_file_filter_new ();
gtk_file_filter_set_name (sch_filter, "sch");
gtk_file_filter_add_mime_type (sch_filter, "application/x-geda-schematic");
gtk_file_filter_add_pattern (sch_filter, "*.sch");
gtk_file_filter_add_pattern (sch_filter, "*.SCH");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), sch_filter);
}
if (path && *path)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), *path);
else
{
gchar *default_path;
default_path = g_get_current_dir();
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), default_path);
g_free(default_path);
}
if (shortcuts && *shortcuts)
{
folder = g_strdup (shortcuts);
seed = folder;
while ((folder = strtok (seed, ":")) != NULL)
{
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
folder, NULL);
seed = NULL;
}
g_free (folder);
}
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
result = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (dialog));
folder =
gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
if (folder && path)
{
dup_string (path, folder);
g_free (folder);
}
}
gtk_widget_destroy (dialog);
return result;
}
/* Caller must g_free() the returned filename. */
gchar *
ghid_fileselect (const char *title, const char *descr,
char *default_file, char *default_ext,
const char *history_tag, int flags)
{
GtkWidget *dialog;
gchar *result = NULL;
GHidPort *out = &ghid_port;
gchar *path = NULL, *base = NULL;
int history_pool = -1;
int i;
if (history_tag && *history_tag)
{
/*
* I used a simple linear search here because the number of
* entries in the array is likely to be quite small (5, maybe 10 at
* the absolute most) and this function is used when pulling up
* a file dialog box instead of something called over and over
* again as part of moving elements or autorouting. So, keep it
* simple....
*/
history_pool = 0;
while (history_pool < n_recent_dirs &&
strcmp (recent_dirs[history_pool].id, history_tag) != 0)
{
history_pool++;
}
/*
* If we counted all the way to n_recent_dirs, that means we
* didn't find our entry
*/
if (history_pool >= n_recent_dirs)
{
n_recent_dirs++;
recent_dirs = (ghid_file_history *)realloc (recent_dirs,
n_recent_dirs * sizeof (ghid_file_history));
if (recent_dirs == NULL)
{
fprintf (stderr, "%s(): realloc failed\n", __FUNCTION__);
exit (1);
}
recent_dirs[history_pool].id = strdup (history_tag);
/* Initialize the entries in our history list to all be NULL */
for (i = 0; i < NHIST; i++)
{
recent_dirs[history_pool].history[i] = NULL;
}
}
}
if (default_file && *default_file)
{
path = g_path_get_dirname (default_file);
base = g_path_get_basename (default_file);
}
dialog = gtk_file_chooser_dialog_new (title,
GTK_WINDOW (out->top_window),
(flags & HID_FILESELECT_READ) ?
GTK_FILE_CHOOSER_ACTION_OPEN :
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
if (path && *path )
{
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), path);
g_free (path);
}
else
{
gchar *default_path;
default_path = g_get_current_dir();
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), default_path);
g_free(default_path);
}
if (base && *base)
{
/* default file is only supposed to be for writing, not reading */
if (!(flags & HID_FILESELECT_READ))
{
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), base);
}
g_free (base);
}
for (i = 0; i < NHIST && recent_dirs[history_pool].history[i] != NULL ; i++)
{
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
recent_dirs[history_pool].history[i],
NULL);
}
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
result = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
if (result != NULL)
path = g_path_get_dirname (result);
else
path = NULL;
/* update the history list */
if (path != NULL)
{
char *tmps, *tmps2;
int k = 0;
/*
* Put this at the top of the list and bump everything else
* down but skip any old entry of this directory
*
*/
while ( k < NHIST &&
recent_dirs[history_pool].history[k] != NULL &&
strcmp ( recent_dirs[history_pool].history[k], path) == 0)
{
k++;
}
tmps = recent_dirs[history_pool].history[k];
recent_dirs[history_pool].history[0] = path;
for (i = 1 ; i < NHIST ; i++)
{
/* store our current entry, but skip duplicates */
while (i + k < NHIST &&
recent_dirs[history_pool].history[i + k] != NULL &&
strcmp ( recent_dirs[history_pool].history[i + k], path) == 0)
{
k++;
}
if (i + k < NHIST)
tmps2 = recent_dirs[history_pool].history[i + k];
else
tmps2 = NULL;
/* move down the one we stored last time */
recent_dirs[history_pool].history[i] = tmps;
/* and remember the displace entry */
tmps = tmps2;
}
/*
* the last one has fallen off the end of the history list
* so we need to free() it.
*/
if (tmps)
{
free (tmps);
}
}
#ifdef DEBUG
printf ("\n\n-----\n\n");
for (i = 0 ; i < NHIST ; i++)
{
printf ("After update recent_dirs[%d].history[%d] = \"%s\"\n",
history_pool, i, recent_dirs[history_pool].history[i] != NULL ?
recent_dirs[history_pool].history[i] : "NULL");
}
#endif
}
gtk_widget_destroy (dialog);
return result;
}
void
gtkutil_file_req (const char *title, void *callback, void *userdata, char *filter, char *extensions,
int flags)
{
struct file_req *freq;
GtkWidget *dialog;
GtkFileFilter *filefilter;
extern char *get_xdir_fs (void);
char *token;
char *tokenbuffer;
#if 0 /* native file dialogs */
#ifdef WIN32
if (!(flags & FRF_WRITE))
{
freq = malloc (sizeof (struct file_req));
freq->th = thread_new ();
freq->flags = 0;
freq->multiple = (flags & FRF_MULTIPLE);
freq->callback = callback;
freq->userdata = userdata;
freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0);
if (!filter)
{
freq->filter = "All files\0*.*\0"
"Executables\0*.exe\0"
"ZIP files\0*.zip\0\0";
}
else
{
freq->filter = filter;
}
thread_start (freq->th, win32_thread, freq);
fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq);
return;
}
else {
freq = malloc (sizeof (struct file_req));
freq->th = thread_new ();
freq->flags = 0;
freq->multiple = (flags & FRF_MULTIPLE);
freq->callback = callback;
freq->userdata = userdata;
freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0);
if (!filter)
{
freq->filter = "All files\0*.*\0\0";
}
else
{
freq->filter = filter;
}
thread_start (freq->th, win32_thread2, freq);
fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq);
return;
}
#endif
#endif
if (flags & FRF_WRITE)
{
dialog = gtk_file_chooser_dialog_new (title, NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
if (filter && filter[0]) /* filter becomes initial name when saving */
{
char temp[1024];
path_part (filter, temp, sizeof (temp));
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), temp);
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), file_part (filter));
}
if (!(flags & FRF_NOASKOVERWRITE))
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
}
else
dialog = gtk_file_chooser_dialog_new (title, NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
if (flags & FRF_MULTIPLE)
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);
if (last_dir[0])
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), last_dir);
if (flags & FRF_ADDFOLDER)
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
get_xdir_fs (), NULL);
if (flags & FRF_CHOOSEFOLDER)
{
gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter);
}
else
{
if (filter && (flags & FRF_FILTERISINITIAL))
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter);
}
if (flags & FRF_EXTENSIONS && extensions != NULL)
{
filefilter = gtk_file_filter_new ();
tokenbuffer = g_strdup (extensions);
token = strtok (tokenbuffer, ";");
while (token != NULL)
{
gtk_file_filter_add_pattern (filefilter, token);
token = strtok (NULL, ";");
}
g_free (tokenbuffer);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filefilter);
}
freq = malloc (sizeof (struct file_req));
freq->dialog = dialog;
freq->flags = flags;
freq->callback = callback;
freq->userdata = userdata;
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (gtkutil_file_req_response), freq);
g_signal_connect (G_OBJECT (dialog), "destroy",
G_CALLBACK (gtkutil_file_req_destroy), (gpointer) freq);
gtk_widget_show (dialog);
}
GtkWidget *
gimp_file_dialog_new (Gimp *gimp,
GtkFileChooserAction action,
const gchar *title,
const gchar *role,
const gchar *stock_id,
const gchar *help_id)
{
GimpFileDialog *dialog;
GSList *file_procs;
const gchar *automatic;
const gchar *automatic_help_id;
const gchar *pictures;
gboolean local_only;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (title != NULL, NULL);
g_return_val_if_fail (role != NULL, NULL);
g_return_val_if_fail (stock_id != NULL, NULL);
g_return_val_if_fail (help_id != NULL, NULL);
switch (action)
{
case GTK_FILE_CHOOSER_ACTION_OPEN:
file_procs = gimp->plug_in_manager->load_procs;
automatic = _("Automatically Detected");
automatic_help_id = GIMP_HELP_FILE_OPEN_BY_EXTENSION;
/* FIXME */
local_only = (gimp_pdb_lookup_procedure (gimp->pdb,
"file-uri-load") == NULL);
break;
case GTK_FILE_CHOOSER_ACTION_SAVE:
file_procs = gimp->plug_in_manager->save_procs;
automatic = _("By Extension");
automatic_help_id = GIMP_HELP_FILE_SAVE_BY_EXTENSION;
/* FIXME */
local_only = (gimp_pdb_lookup_procedure (gimp->pdb,
"file-uri-save") == NULL);
break;
default:
g_return_val_if_reached (NULL);
return NULL;
}
dialog = g_object_new (GIMP_TYPE_FILE_DIALOG,
"title", title,
"role", role,
"action", action,
"local-only", local_only,
"do-overwrite-confirmation", TRUE,
NULL);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
stock_id, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_help_connect (GTK_WIDGET (dialog),
gimp_file_dialog_help_func, help_id, dialog);
if (GIMP_GUI_CONFIG (gimp->config)->show_help_button && help_id)
{
GtkWidget *action_area = GTK_DIALOG (dialog)->action_area;
GtkWidget *button = gtk_button_new_from_stock (GTK_STOCK_HELP);
gtk_box_pack_end (GTK_BOX (action_area), button, FALSE, TRUE, 0);
gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (action_area),
button, TRUE);
gtk_widget_show (button);
g_object_set_data_full (G_OBJECT (dialog), "gimp-dialog-help-id",
g_strdup (help_id),
(GDestroyNotify) g_free);
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_file_dialog_help_clicked),
dialog);
g_object_set_data (G_OBJECT (dialog), "gimp-dialog-help-button", button);
}
pictures = gimp_user_directory (GIMP_USER_DIRECTORY_PICTURES);
if (pictures)
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
pictures, NULL);
gimp_file_dialog_add_preview (dialog, gimp);
gimp_file_dialog_add_filters (dialog, gimp, file_procs);
gimp_file_dialog_add_proc_selection (dialog, gimp, file_procs, automatic,
automatic_help_id);
dialog->progress = gimp_progress_box_new ();
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->vbox), dialog->progress,
FALSE, FALSE, 0);
return GTK_WIDGET (dialog);
}
