wxString wxFileDialog::GetDirectory() const
{
if (!gtk_check_version(2,4,0))
{
wxGtkString str(gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(m_widget)));
return wxConvFileName->cMB2WX(str);
}
return wxGenericFileDialog::GetDirectory();
}
wxString wxFileDialog::GetDirectory() const
{
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
return wxConvFileName->cMB2WX(
gtk_file_chooser_get_current_folder( GTK_FILE_CHOOSER(m_widget) ) );
else
#endif
return wxGenericFileDialog::GetDirectory();
}
void wxFileDialog::OnFakeOk(wxCommandEvent& WXUNUSED(event))
{
// Update the current directory from here, accessing it later may not work
// due to the strange way GtkFileChooser works.
wxGtkString
str(gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(m_widget)));
m_dir = wxString::FromUTF8(str);
EndDialog(wxID_OK);
}
void
mud_connections_icon_fileset_cb(GtkFileChooserButton *chooser,
MudConnections *conn)
{
const gchar *file;
gchar *current_folder =
gtk_file_chooser_get_current_folder(
GTK_FILE_CHOOSER(conn->priv->icon_dialog_chooser));
GDir *dir = g_dir_open(current_folder ,0, NULL);
GPatternSpec *xpm_pattern = g_pattern_spec_new("*.xpm");
GPatternSpec *svg_pattern = g_pattern_spec_new("*.svg");
GPatternSpec *bmp_pattern = g_pattern_spec_new("*.bmp");
GPatternSpec *png_pattern = g_pattern_spec_new("*.png");
gtk_list_store_clear(
GTK_LIST_STORE(conn->priv->icon_dialog_view_model));
while( (file = g_dir_read_name(dir) ) != NULL)
if( g_pattern_match_string(xpm_pattern, file) ||
g_pattern_match_string(svg_pattern, file) ||
g_pattern_match_string(bmp_pattern, file) ||
g_pattern_match_string(png_pattern, file))
{
gchar *full_path = g_strconcat(current_folder,
G_DIR_SEPARATOR_S,
file, NULL);
GdkPixbuf *icon = gdk_pixbuf_new_from_file_at_size(
full_path, 48, 48, NULL);
GtkTreeIter iter;
if(icon)
{
gtk_list_store_append(
GTK_LIST_STORE(conn->priv->icon_dialog_view_model),
&iter);
gtk_list_store_set(
GTK_LIST_STORE(conn->priv->icon_dialog_view_model),
&iter,
MODEL_COLUMN_STRING, file,
MODEL_COLUMN_PIXBUF, icon,
-1);
g_object_unref(icon);
}
g_free(full_path);
}
g_free(current_folder);
g_dir_close(dir);
g_pattern_spec_free(xpm_pattern);
g_pattern_spec_free(svg_pattern);
g_pattern_spec_free(bmp_pattern);
g_pattern_spec_free(png_pattern);
}
END_HANDLER
BUTTON_CLICKED(buttonaddtheme)
{
char *filename, *directory;
size_t len;
GtkWidget *fc = gtk_file_chooser_dialog_new(
messages_get("gtkAddThemeTitle"),
GTK_WINDOW(wndPreferences),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
len = SLEN("themes") + strlen(res_dir_location) + 1;
char themesfolder[len];
snprintf(themesfolder, len, "%sthemes", res_dir_location);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc),
themesfolder);
gint res = gtk_dialog_run(GTK_DIALOG(fc));
if (res == GTK_RESPONSE_ACCEPT) {
filename = gtk_file_chooser_get_current_folder(
GTK_FILE_CHOOSER(fc));
if (strcmp(filename, themesfolder) != 0) {
directory = strrchr(filename, '/');
*directory = '\0';
if (strcmp(filename, themesfolder) != 0) {
warn_user(messages_get(
"gtkThemeFolderInstructions"),
0);
gtk_widget_destroy(GTK_WIDGET(fc));
if (filename != NULL)
g_free(filename);
return FALSE;
} else {
directory++;
}
} else {
if (filename != NULL)
g_free(filename);
filename = gtk_file_chooser_get_filename(
GTK_FILE_CHOOSER(fc));
if (strcmp(filename, themesfolder) == 0) {
warn_user(messages_get("gtkThemeFolderSub"),
0);
gtk_widget_destroy(GTK_WIDGET(fc));
g_free(filename);
return FALSE;
}
directory = strrchr(filename, '/') + 1;
}
gtk_widget_destroy(GTK_WIDGET(fc));
nsgtk_theme_add(directory);
if (filename != NULL)
g_free(filename);
}
}
static void OnBiosPath_Changed(GtkWidget *wdg, gpointer data) {
gchar *foldername;
foldername = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (wdg));
strcpy(Config.BiosDir, foldername);
UpdatePluginsBIOS();
UpdatePluginsBIOS_UpdateGUI(data);
g_free(foldername);
}
/**
* Callback called when game directory setting changes.
*
* When editing game's properties, if the user change the
* game directory prefix, this function is called.
*/
void
on_game_mgr_game_dir_changed (GtkFileChooser *chooser,
gpointer user_data)
{
GtkWidget *btn_unpack = lookup_widget("game_mgr_btn_unpack");
game_mgr_update_race_list(gtk_file_chooser_get_current_folder(chooser));
/* Disable 'Unpack' Button */
gtk_widget_set_sensitive(btn_unpack, FALSE);
}
static void on_load_from_image (GtkWidget *widget, Explorer* self) {
GtkWidget *dialog, *image;
GError *error = NULL;
gchar *filename = NULL;
#if (GTK_CHECK_VERSION(2, 4, 0))
dialog = gtk_file_chooser_dialog_new ("Open Image Parameters",
GTK_WINDOW (glade_xml_get_widget (self->xml, "explorer_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 (dialog), GTK_RESPONSE_OK);
image = gtk_image_new ();
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog), image);
g_signal_connect (G_OBJECT (dialog), "update-preview", G_CALLBACK (update_image_preview), image);
if (file_location)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), file_location);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) {
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
histogram_imager_load_image_file (HISTOGRAM_IMAGER (self->map), filename, &error);
if (file_location)
g_free (file_location);
file_location = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
}
#else
dialog = gtk_file_selection_new ("Open Image Parameters");
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) {
filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog));
histogram_imager_load_image_file (HISTOGRAM_IMAGER (self->map), filename, &error);
}
#endif
gtk_widget_destroy (dialog);
if (error) {
GtkWidget *dialog, *label;
gchar *text;
dialog = glade_xml_get_widget (self->xml, "error dialog");
label = glade_xml_get_widget (self->xml, "error label");
text = g_strdup_printf ("<span weight=\"bold\" size=\"larger\">Could not load \"%s\"</span>\n\n%s", filename, error->message);
gtk_label_set_markup (GTK_LABEL (label), text);
g_free (text);
g_error_free (error);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (dialog);
}
g_free (filename);
}
void GtkToolkitFileChooser::FilterChanged()
{
GtkFileFilter* current_filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(m_dialog));
if (m_action == GTK_FILE_CHOOSER_ACTION_SAVE && current_filter)
{
int filter_index = GetSelectedFilter();
gchar * current_full_filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(m_dialog));
if (current_full_filename)
{
char* current_filename = basename((char *)current_full_filename);
GString *file_extension; // or use gchar
file_extension = static_cast<GString*>(g_slist_nth_data(m_extensions, filter_index));
if (file_extension)
{
char *extension = (char *)file_extension->str;
int extpos = 0;
for (size_t i=0; i< strlen(extension); i++)
if (extension[i] == '.')
extpos = i;
if (extpos > 0 && strlen(extension) > 2 && strstr(extension, "*.") && !strstr(extension, "*.*")) // Check this one
{
GString *current_filename_g = g_string_new(current_filename);
if (current_filename_g)
{
char *ptr = (char *)current_filename;
int len = strlen(ptr);
int pos = len;
for (int i=0; i<len; i++)
if (ptr[i] == '.')
pos = i;
g_string_erase(current_filename_g, (gssize)pos, (gssize)(len-pos));
g_string_append(current_filename_g, (gchar*)extension+extpos);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(m_dialog), current_filename_g->str);
gchar * current_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(m_dialog));
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(m_dialog), current_folder);
g_free(current_folder);
g_string_free(current_filename_g, TRUE);
}
}
}
g_free(current_full_filename); // Check this one
}
}
}
END_HANDLER
static gboolean on_fileChooserDownloads_changed(GtkWidget *widget, gpointer data)
{
gchar *dir;
LOG(("Signal emitted on '%s'", "fileChooserDownloads"));
dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER((widget)));
nsoption_set_charp(downloads_directory, strdup(dir));
g_free(dir);
return FALSE;
}
char* FileDialog(int type,GtkWidget* parent_window)
{
GtkWidget* dialog=NULL;
char* filename=NULL;
char* tmp=NULL;
char* path=NULL;
switch(type)
{
case OPEN_DIALOG:
dialog=gtk_file_chooser_dialog_new(_("Open File"),GTK_WINDOW(parent_window),GTK_FILE_CHOOSER_ACTION_OPEN,GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,GTK_STOCK_OPEN,GTK_RESPONSE_ACCEPT,NULL);
break;
case SAVE_DIALOG:
dialog=gtk_file_chooser_dialog_new(_("Save File"),GTK_WINDOW(parent_window),GTK_FILE_CHOOSER_ACTION_SAVE,GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,GTK_STOCK_SAVE,GTK_RESPONSE_ACCEPT,NULL);
break;
}
gtk_widget_show(dialog);
if(gtk_dialog_run(GTK_DIALOG(dialog))==GTK_RESPONSE_ACCEPT)
{
filename=gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
}
if(filename)
{
// Handle with different encoding filename
tmp=filename;
filename=g_locale_from_utf8(filename,-1,NULL,NULL,NULL);
free(tmp);
}
path=gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog));
// Handle with different encoding path
tmp=path;
path=g_locale_from_utf8(path,-1,NULL,NULL,NULL);
free(tmp);
gtk_widget_destroy(dialog);
chdir(path);
free(path);
return filename;
}
static void on_save (GtkWidget *widget, Explorer* self) {
GtkWidget *dialog;
GError *error = NULL;
gchar *filename = NULL;
#if (GTK_CHECK_VERSION(2, 4, 0))
dialog = gtk_file_chooser_dialog_new ("Save Image",
GTK_WINDOW (glade_xml_get_widget (self->xml, "explorer_window")),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
if (file_location != NULL)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), file_location);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) {
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
histogram_imager_save_image_file (HISTOGRAM_IMAGER (self->map), filename, &error);
if (file_location)
g_free (file_location);
file_location = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
}
#else
dialog = gtk_file_selection_new ("Save Image");
gtk_file_selection_set_filename (GTK_FILE_SELECTION (dialog), "rendering.png");
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) {
filename = g_strdup (gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog)));
histogram_imager_save_image_file (HISTOGRAM_IMAGER (self->map), filename, &error);
}
#endif
gtk_widget_destroy (dialog);
if (error) {
GtkWidget *dialog, *label;
gchar *text;
dialog = glade_xml_get_widget (self->xml, "error dialog");
label = glade_xml_get_widget (self->xml, "error label");
text = g_strdup_printf ("<span weight=\"bold\" size=\"larger\">Could not save \"%s\"</span>\n\n%s", filename, error->message);
gtk_label_set_markup (GTK_LABEL (label), text);
g_free (text);
g_error_free (error);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (dialog);
}
if (filename)
g_free (filename);
}
int gui_open_parameter_file ()
{
GtkWidget *dialog;
gchar *glade_pixmap_file = g_build_filename (PHOEBE_GLADE_PIXMAP_DIR, "ico.png", NULL);
int status = -1;
char *filename;
dialog = gtk_file_chooser_dialog_new (
"Open PHOEBE parameter file",
GTK_WINDOW (gui_widget_lookup ("phoebe_window")->gtk),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
if (PHOEBE_DIRFLAG)
gtk_file_chooser_set_current_folder ((GtkFileChooser*) dialog, PHOEBE_DIRNAME);
else {
gchar *dir;
phoebe_config_entry_get ("PHOEBE_DATA_DIR", &dir);
gtk_file_chooser_set_current_folder ((GtkFileChooser*) dialog, dir);
}
gtk_window_set_default_size (GTK_WINDOW (dialog), 600, 450);
gtk_window_set_icon (GTK_WINDOW (dialog), gdk_pixbuf_new_from_file (glade_pixmap_file, NULL));
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
status = phoebe_open_parameter_file (filename);
PHOEBE_FILEFLAG = TRUE;
PHOEBE_FILENAME = strdup (filename);
PHOEBE_DIRFLAG = TRUE;
PHOEBE_DIRNAME = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
if (status == SUCCESS) {
gui_update_angle_values ();
gui_status("%s successfully opened.", filename);
}
else
gui_status("Opening %s failed with status %d.", filename, status);
g_free (filename);
}
else
gui_status ("Open PHOEBE parameter file canceled.");
gtk_widget_destroy (dialog);
return status;
}
int MCA_file_with_types(MCExecPoint& ep, const char *p_title, const char *p_prompt, char * const p_types[], uint4 p_type_count, const char *p_initial, unsigned int p_options)
{
if (!MCModeMakeLocalWindows())
{
bool t_plural = (p_options & MCA_OPTION_PLURAL) != 0;
char *t_resolved_path = MCS_resolvepath(p_initial);
char **t_rtypes;
if (types_to_remote_types(p_types, p_type_count, t_rtypes))
{
MCRemoteFileDialog(ep, p_title, p_prompt, t_rtypes, p_type_count * 2, NULL, t_resolved_path, false, t_plural);
MCCStringArrayFree(t_rtypes, p_type_count * 2);
}
delete t_resolved_path;
return 1;
}
//////////
GtkWidget *dialog ;
// Create the file dialog with the correct prompt
dialog = create_open_dialog ( p_title == NULL ? p_prompt : p_title, GTK_FILE_CHOOSER_ACTION_OPEN );
// If we have any filters, add them.
if ( p_type_count > 0 )
add_dialog_filters ( dialog, p_types , p_type_count );
if ( p_options & MCA_OPTION_PLURAL )
gtk_file_chooser_set_select_multiple ( GTK_FILE_CHOOSER ( dialog ) ,true );
// If we have an initial file/folder then set it.
set_initial_file ( dialog, p_initial, G_last_opened_path ) ;
// Run the dialog ... this will be replaced with our own loop which will call the REV event handler too.
run_dialog ( dialog, ep) ;
MCresult -> clear();
MCresult -> copysvalue(get_current_filter_name ( dialog ) );
if (G_last_opened_path != nil)
g_free(G_last_opened_path);
G_last_opened_path = gtk_file_chooser_get_current_folder ( GTK_FILE_CHOOSER ( dialog ) ) ;
// All done, close the dialog.
close_dialog ( dialog ) ;
return(1);
}
//------------------------------------------------------------------------------
void on_settings_data_path_button_current_folder_changed (GtkFileChooser *filechooser,
gpointer user_data)
{
gchar *data_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(settings_data_path_button)) ;
gtk_entry_set_editable (settings_data_path_entry, TRUE) ;
gtk_entry_set_text (settings_data_path_entry, data_folder) ;
int pos=-1 ;
gtk_editable_insert_text ((GtkEditable *)settings_data_path_entry,"/",1, &pos) ;
gtk_entry_set_editable (settings_data_path_entry, FALSE) ;
g_free(data_folder) ;
} ;
static void
print_selected_path_clicked_cb (GtkWidget *button,
gpointer user_data)
{
gchar *folder, *filename;
folder = gtk_file_chooser_get_current_folder (user_data);
filename = gtk_file_chooser_get_filename (user_data);
g_message ("Currently Selected:\n\tFolder: `%s'\n\tFilename: `%s'\nDone.\n",
folder, filename);
g_free (folder);
g_free (filename);
}
GTKFileDialog::GTKFileDialog(GtkWindow *Window, const char *Title, GtkFileChooserAction Action, const std::vector<const char *> &FileTypes,
const std::vector<const char *> &FileTypeNames, const char *Button1_Type, int Button1_Result, const char *Button2_Type, int Button2_Result) :
GTKDialog(gtk_file_chooser_dialog_new(Title, Window, Action, Button1_Type, Button1_Result, Button2_Type, Button2_Result, NULL))
{
FileDialog = GTK_FILE_CHOOSER(Dialog);
gtk_file_chooser_set_do_overwrite_confirmation(FileDialog, TRUE);
AddFilters(FileTypes, FileTypeNames);
if (strncmp(Button1_Type, GTK_STOCK_SAVE, 8) == 0 || strncmp(Button2_Type, GTK_STOCK_SAVE, 8) == 0)
AddFilterChooser(FileTypes, FileTypeNames);
if (CWD == NULL)
CWD = gtk_file_chooser_get_current_folder(FileDialog);
gtk_file_chooser_set_current_folder(FileDialog, CWD);
}
void gtkui_file_open() {
// Open a file using a GTK+ dialog
GtkWidget *dialog = gtk_file_chooser_dialog_new(
"Select a ROM",
GTK_WINDOW(gtkwindow),
GTK_FILE_CHOOSER_ACTION_OPEN,
"Cancel", GTK_RESPONSE_CANCEL,
"Open", GTK_RESPONSE_ACCEPT,
NULL);
if(conf.misc_last_folder != NULL)
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), conf.misc_last_folder);
GtkFileFilter *filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, "NES ROMs and Archives");
gtk_file_filter_add_pattern(filter, "*.nes");
gtk_file_filter_add_pattern(filter, "*.fds");
gtk_file_filter_add_pattern(filter, "*.unf");
gtk_file_filter_add_pattern(filter, "*.unif");
gtk_file_filter_add_pattern(filter, "*.nsf");
gtk_file_filter_add_pattern(filter, "*.zip");
gtk_file_filter_add_pattern(filter, "*.7z");
gtk_file_filter_add_pattern(filter, "*.txz");
gtk_file_filter_add_pattern(filter, "*.tar.xz");
gtk_file_filter_add_pattern(filter, "*.xz");
gtk_file_filter_add_pattern(filter, "*.tgz");
gtk_file_filter_add_pattern(filter, "*.tar.gz");
gtk_file_filter_add_pattern(filter, "*.gz");
gtk_file_filter_add_pattern(filter, "*.tbz");
gtk_file_filter_add_pattern(filter, "*.tar.bz2");
gtk_file_filter_add_pattern(filter, "*.bz2");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
char *filename;
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if(conf.misc_last_folder != NULL)
free(conf.misc_last_folder);
conf.misc_last_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog));
gtk_widget_destroy(dialog);
nst_load(filename);
g_free(filename);
}
else { gtk_widget_destroy(dialog); }
}
int gui_save_parameter_file()
{
GtkWidget *dialog;
gchar *glade_pixmap_file = g_build_filename (PHOEBE_GLADE_PIXMAP_DIR, "ico.png", NULL);
int status = 0;
dialog = gtk_file_chooser_dialog_new ("Save PHOEBE parameter file",
GTK_WINDOW(gui_widget_lookup("phoebe_window")->gtk),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
gtk_window_set_default_size (GTK_WINDOW (dialog), 600, 450);
if(PHOEBE_DIRFLAG)
gtk_file_chooser_set_current_folder((GtkFileChooser*)dialog, PHOEBE_DIRNAME);
else{
gchar *dir;
phoebe_config_entry_get("PHOEBE_DATA_DIR", &dir);
gtk_file_chooser_set_current_folder((GtkFileChooser*)dialog, dir);
}
/* gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); */
gtk_window_set_icon (GTK_WINDOW(dialog), gdk_pixbuf_new_from_file(glade_pixmap_file, NULL));
gchar *filename = gui_get_filename_with_overwrite_confirmation (dialog, "Save PHOEBE parameter file");
if (filename) {
gui_export_angles_to_radians ();
status = phoebe_save_parameter_file (filename);
PHOEBE_FILEFLAG = TRUE;
PHOEBE_FILENAME = strdup(filename);
PHOEBE_DIRFLAG = TRUE;
PHOEBE_DIRNAME = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
if (status == SUCCESS)
gui_status("%s successfully saved.", filename);
else
gui_status("Saving %s failed with status %d.", filename, status);
g_free (filename);
}
gtk_widget_destroy (dialog);
return status;
}
static void OnBiosPath_Changed(GtkWidget *wdg, gpointer data) {
gchar *foldername;
foldername = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (wdg));
GSList * l = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER (wdg));
//printf(("%s and %s\n"), foldername, l->data);
if (l) foldername = l->data;
strcpy(Config.BiosDir, foldername);
UpdatePluginsBIOS();
UpdatePluginsBIOS_UpdateGUI(data);
g_free(foldername);
}
static void OnPluginPath_Changed(GtkWidget *wdg, gpointer data) {
gchar *path;
path = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (wdg));
GSList * l = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER (wdg));
//printf(("%s and %s\n"), path, l->data);
if (l) path = l->data;
strcpy(Config.PluginsDir, path);
UpdatePluginsBIOS();
UpdatePluginsBIOS_UpdateGUI(data);
g_free(path);
}
JNIEXPORT jstring JNICALL
Java_gnu_java_awt_peer_gtk_GtkFileDialogPeer_nativeGetDirectory
(JNIEnv *env, jobject obj)
{
void *ptr;
const char *str;
gdk_threads_enter ();
ptr = NSA_GET_PTR (env, obj);
str = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER(ptr));
gdk_threads_leave ();
return (*env)->NewStringUTF(env, str);
}
int
clip_GTK_FILECHOOSERGETCURRENTFOLDER(ClipMachine * ClipMachineMemory)
{
C_object *cchooser = _fetch_co_arg(ClipMachineMemory);
gchar *name;
CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object));
name = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(cchooser->object));
LOCALE_FROM_UTF(name);
_clip_retc(ClipMachineMemory, name);
FREE_TEXT(name);
return 0;
err:
return 1;
}
static void
remember_current_folder(GtkFileChooser *chooser)
{
char *folder;
folder = gtk_file_chooser_get_current_folder(chooser);
if (folder != NULL) {
if (strlen(folder) >= MAX_FILENAME_LENGTH) {
/* Non-critical error */
log_warn("current folder name too long for buffer");
} else {
log_info("current folder = %s", folder);
strncpy(previous_folder, folder, MAX_FILENAME_LENGTH);
}
g_free(folder);
}
}
void CNewFilesDlg::EditDirPath(void)
{
const gchar *dirname = gtk_entry_get_text(GTK_ENTRY(m_DirEdit));
GtkWidget *pPathDlg = gtk_file_chooser_dialog_new("Select path",
GTK_WINDOW(m_pDlg), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CLOSE,
GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_standard_tooltips(GTK_FILE_CHOOSER(pPathDlg));
if (dirname && g_file_test(dirname, G_FILE_TEST_IS_DIR))
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(pPathDlg), dirname);
if (gtk_dialog_run(GTK_DIALOG(pPathDlg)) == GTK_RESPONSE_ACCEPT) {
gchar *path = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(pPathDlg));
CConfig::SetStr("MakeCatDlg", "Folder", path);
gtk_entry_set_text(GTK_ENTRY(m_DirEdit), path);
g_free(path);
UpdateControls();
}
gtk_widget_destroy(pPathDlg);
}
// static
void LLFilePicker::chooser_responder(GtkWidget *widget, gint response, gpointer user_data)
{
LLFilePicker* picker = (LLFilePicker*)user_data;
lldebugs << "GTK DIALOG RESPONSE " << response << llendl;
if (response == GTK_RESPONSE_ACCEPT)
{
GSList *file_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(widget));
g_slist_foreach(file_list, (GFunc)add_to_selectedfiles, user_data);
g_slist_foreach(file_list, (GFunc)g_free, NULL);
g_slist_free (file_list);
}
// set the default path for this usage context.
picker->mContextToPathMap[picker->mCurContextName] =
gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(widget));
gtk_widget_destroy(widget);
gtk_main_quit();
}
void NedMidiImportDialog::OnClose(GtkDialog *dialog, gint result, gpointer data) {
char *s;
NedMidiImportDialog *midi_import_dialog = (NedMidiImportDialog *) data;
/*
printf("current folder = %s, filename = %s\n", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(midi_import_dialog->m_file_chooser)),
gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(midi_import_dialog->m_file_chooser)));
*/
switch (result) {
case GTK_RESPONSE_ACCEPT:
midi_import_dialog->m_state = TRUE;
if (*(midi_import_dialog->m_last_folder) != NULL) {
free(*(midi_import_dialog->m_last_folder));
*(midi_import_dialog->m_last_folder) = NULL;
}
if (*(midi_import_dialog->m_filename) != NULL) {
free(*(midi_import_dialog->m_filename));
*(midi_import_dialog->m_filename) = NULL;
}
s = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(midi_import_dialog->m_file_chooser));
if (strlen(s) > 0) {
*(midi_import_dialog->m_last_folder) = strdup(s);
}
s = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(midi_import_dialog->m_file_chooser));
if (strlen(s) > 0) {
*(midi_import_dialog->m_filename) = strdup(s);
}
break;
default:
midi_import_dialog->m_state = FALSE;
break;
}
midi_import_dialog->m_with_triplets = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(midi_import_dialog->m_with_triplet_button));
midi_import_dialog->m_tempo_change_density = (int) gtk_range_get_value(GTK_RANGE(midi_import_dialog->m_tempo_change_density_scale));
midi_import_dialog->m_volume_change_density = (int) gtk_range_get_value(GTK_RANGE(midi_import_dialog->m_volume_change_density_scale));
midi_import_dialog->m_force_piano = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(midi_import_dialog->m_force_piano_button));
midi_import_dialog->m_sort_instruments = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(midi_import_dialog->m_sort_instruments_button));
midi_import_dialog->m_dont_split = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(midi_import_dialog->m_dont_split_button));
gtk_widget_destroy (GTK_WIDGET(dialog));
}
static void
on_fr_apply_clicked (GtkWidget *widget, gpointer data)
{
GtkWidget *entry;
GtkWidget *s_checkbox;
const gchar *host;
const gchar *port;
const gchar *password;
const gchar *dir;
gchar *rcfile;
entry = glade_xml_get_widget (xml,"fr_hostname");
host = gtk_entry_get_text (GTK_ENTRY(entry));
cfg_add_key (&cf, "mpd_hostname", (char *)host);
entry = glade_xml_get_widget (xml,"fr_port");
port = gtk_entry_get_text (GTK_ENTRY(entry));
cfg_add_key (&cf, "mpd_port", (char *)port);
entry = glade_xml_get_widget (xml,"fr_password");
password = gtk_entry_get_text (GTK_ENTRY(entry));
cfg_add_key (&cf, "mpd_password", (char *)password);
entry = glade_xml_get_widget (xml, "fst_music_dir");
dir = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER(entry));
cfg_add_key (&cf, "music_directory", (char *)dir);
s_checkbox = glade_xml_get_widget (xml, "fr_systray_toggle");
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(s_checkbox)))
cfg_add_key (&cf, "enable_systray", "true");
else
cfg_add_key (&cf, "enable_systray", "false");
rcfile = cfg_get_path_to_config_file (CONFIG_FILE);
cfg_write_config_file (&cf, rcfile);
g_free (rcfile);
return;
}
static void filebrowser_add_files (GtkFileChooser * browser, GSList * files,
gboolean play)
{
GSList * node;
GList * list = NULL;
for (node = files; node != NULL; node = node->next)
list = g_list_prepend (list, node->data);
list = g_list_reverse (list);
if (play)
aud_drct_pl_open_list (list);
else
aud_drct_pl_add_list (list, -1);
g_list_free (list);
gchar * path = gtk_file_chooser_get_current_folder (browser);
aud_set_string ("audgui", "filesel_path", path);
g_free (path);
}
/* Get the race number and assign it to the race name field */
void
on_game_mgr_properties_race_list_row_activated (GtkWidget *widget,
gpointer user_data)
{
GtkTreeView *race_l = NULL;
GtkTreeSelection *sel = NULL;
GtkTreeModel *model = NULL;
GtkTreeIter iter;
gint *race = NULL;
gchar *dir = NULL;
race_l = (GtkTreeView *) lookup_widget("game_mgr_properties_race_list");
model = gtk_tree_view_get_model(race_l);
sel = gtk_tree_view_get_selection(race_l);
/* get the iterator at the selection */
gtk_tree_selection_get_selected(sel, NULL, &iter);
/* get the "hidden" data from the second column */
race = g_malloc(sizeof(gint));
gtk_tree_model_get(model, &iter, 1, race, -1);
/* Bind its number (the really important data) */
g_object_set_data(G_OBJECT(race_l),
"race_number", race);
/* Check if it's neccesary to activate the 'unpack' button */
dir = gtk_file_chooser_get_current_folder ((GtkFileChooser *)
lookup_widget("game_mgr_game_dir"));
if(vp_can_unpack(dir, *race)) {
GtkWidget *btn_unpack =
lookup_widget("game_mgr_btn_unpack");
gtk_widget_set_sensitive(btn_unpack, TRUE);
} else {
GtkWidget *btn_unpack =
lookup_widget("game_mgr_btn_unpack");
gtk_widget_set_sensitive(btn_unpack, FALSE);
}
}
