/** \brief Update TLE from local files.
* \param widget The menu item (unused).
* \param data User data (unused).
*
* This function is called when the user selects
* Edit -> Update TLE -> From local files
* in the menubar.
*
* First the function creates the GUI status indicator infrastructure
* with the possibility to select a directory, then it calls the
* tle_update_from_files with the corresponding parameters.
*
* Finally, the programs signals the module manager to reload the
* satellites in each module.
*
* FIXME: fork as a thread?
*/
static void menubar_tle_local_cb(GtkWidget * widget, gpointer data)
{
gchar *dir; /* selected directory */
GtkWidget *dir_chooser; /* directory chooser button */
GtkWidget *dialog; /* dialog window */
GtkWidget *label; /* misc labels */
GtkWidget *progress; /* progress indicator */
GtkWidget *label1, *label2; /* activitity and stats labels */
GtkWidget *box;
gint response; /* dialog response */
gboolean doupdate = FALSE;
(void)widget; /* avoid unused parameter compiler warning */
(void)data; /* avoid unused parameter compiler warning */
/* get last used directory */
dir = sat_cfg_get_str(SAT_CFG_STR_TLE_FILE_DIR);
/* if there is no last used dir fall back to $HOME */
if (dir == NULL)
{
dir = g_strdup(g_get_home_dir());
}
/* create file chooser */
dir_chooser = gtk_file_chooser_button_new(_("Select directory"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dir_chooser), dir);
g_free(dir);
/* create label */
label = gtk_label_new(_("Select TLE directory:"));
/* pack label and chooser into a hbox */
box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(box), dir_chooser, TRUE, TRUE, 5);
gtk_widget_show_all(box);
/* create the dalog */
dialog = gtk_dialog_new_with_buttons(_("Update TLE from files"),
GTK_WINDOW(app),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), box, TRUE, TRUE,
30);
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response)
{
case GTK_RESPONSE_ACCEPT:
/* set flag to indicate that we should do an update */
doupdate = TRUE;
break;
default:
doupdate = FALSE;
break;
}
/* get directory before we destroy the dialog */
dir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dir_chooser));
/* nuke the dialog */
gtk_widget_destroy(dialog);
if (doupdate)
{
sat_log_log(SAT_LOG_LEVEL_INFO, _("%s: Running TLE update from %s"), __FUNCTION__, dir);
/* store last used TLE dir */
sat_cfg_set_str(SAT_CFG_STR_TLE_FILE_DIR, dir);
/* create new dialog with progress indicator */
dialog = gtk_dialog_new_with_buttons(_("TLE Update"),
GTK_WINDOW(app),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL);
//gtk_window_set_default_size (GTK_WINDOW (dialog), 400,250);
gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT, FALSE);
/* create a vbox */
box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(box), 20);
/* add static label */
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5);
gtk_label_set_markup(GTK_LABEL(label), _("<b>Updating TLE files from files</b>"));
gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
/* activity label */
label1 = gtk_label_new("...");
gtk_misc_set_alignment(GTK_MISC(label1), 0.5, 0.5);
gtk_box_pack_start(GTK_BOX(box), label1, FALSE, FALSE, 0);
/* add progress bar */
progress = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(box), progress, FALSE, FALSE, 10);
/* statistics */
label2 = gtk_label_new(_("Satellites updated:\t 0\n"
"Satellites skipped:\t 0\n" "Missing Satellites:\t 0\n"));
gtk_box_pack_start(GTK_BOX(box), label2, TRUE, TRUE, 0);
/* finalise dialog */
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), box);
g_signal_connect_swapped(dialog, "response", G_CALLBACK(gtk_widget_destroy), dialog);
gtk_widget_show_all(dialog);
/* Force the drawing queue to be processed otherwise the dialog
may not appear before we enter the TLE updating func
- see Gtk+ FAQ http://www.gtk.org/faq/#AEN602
*/
while (g_main_context_iteration(NULL, FALSE));
/* update TLE */
tle_update_from_files(dir, NULL, FALSE, progress, label1, label2);
/* set progress bar to 100% */
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress), 1.0);
gtk_label_set_text(GTK_LABEL(label1), _("Finished"));
/* enable close button */
gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT, TRUE);
}
if (dir)
g_free(dir);
/* reload satellites */
mod_mgr_reload_sats();
}
bool wxFileDialog::Create(wxWindow *parent, const wxString& message,
const wxString& defaultDir,
const wxString& defaultFileName,
const wxString& wildCard,
long style, const wxPoint& pos,
const wxSize& sz,
const wxString& name)
{
parent = GetParentForModalDialog(parent, style);
if (!wxFileDialogBase::Create(parent, message, defaultDir, defaultFileName,
wildCard, style, pos, sz, name))
{
return false;
}
if (!PreCreation(parent, pos, wxDefaultSize) ||
!CreateBase(parent, wxID_ANY, pos, wxDefaultSize, style,
wxDefaultValidator, wxT("filedialog")))
{
wxFAIL_MSG( wxT("wxFileDialog creation failed") );
return false;
}
GtkFileChooserAction gtk_action;
GtkWindow* gtk_parent = NULL;
if (parent)
gtk_parent = GTK_WINDOW( gtk_widget_get_toplevel(parent->m_widget) );
const gchar* ok_btn_stock;
if ( style & wxFD_SAVE )
{
gtk_action = GTK_FILE_CHOOSER_ACTION_SAVE;
ok_btn_stock = GTK_STOCK_SAVE;
}
else
{
gtk_action = GTK_FILE_CHOOSER_ACTION_OPEN;
ok_btn_stock = GTK_STOCK_OPEN;
}
m_widget = gtk_file_chooser_dialog_new(
wxGTK_CONV(m_message),
gtk_parent,
gtk_action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
ok_btn_stock, GTK_RESPONSE_ACCEPT,
NULL);
g_object_ref(m_widget);
GtkFileChooser* file_chooser = GTK_FILE_CHOOSER(m_widget);
m_fc.SetWidget(file_chooser);
gtk_dialog_set_default_response(GTK_DIALOG(m_widget), GTK_RESPONSE_ACCEPT);
if ( style & wxFD_MULTIPLE )
gtk_file_chooser_set_select_multiple(file_chooser, true);
// gtk_widget_hide_on_delete is used here to avoid that Gtk automatically
// destroys the dialog when the user press ESC on the dialog: in that case
// a second call to ShowModal() would result in a bunch of Gtk-CRITICAL
// errors...
g_signal_connect(m_widget,
"delete_event",
G_CALLBACK (gtk_widget_hide_on_delete),
this);
// local-only property could be set to false to allow non-local files to be
// loaded. In that case get/set_uri(s) should be used instead of
// get/set_filename(s) everywhere and the GtkFileChooserDialog should
// probably also be created with a backend, e.g. "gnome-vfs", "default", ...
// (gtk_file_chooser_dialog_new_with_backend). Currently local-only is kept
// as the default - true:
// gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(m_widget), true);
g_signal_connect (m_widget, "response",
G_CALLBACK (gtk_filedialog_response_callback), this);
// deal with extensions/filters
SetWildcard(wildCard);
wxString defaultFileNameWithExt = defaultFileName;
if ( !wildCard.empty() && !defaultFileName.empty() &&
!wxFileName(defaultFileName).HasExt() )
{
// append the default extension to the initial file name: GTK won't do
// it for us by default (unlike e.g. MSW)
const wxString defaultExt = m_fc.GetCurrentWildCard().AfterFirst('.');
if ( defaultExt.find_first_of("?*") == wxString::npos )
defaultFileNameWithExt += "." + defaultExt;
}
// if defaultDir is specified it should contain the directory and
// defaultFileName should contain the default name of the file, however if
// directory is not given, defaultFileName contains both
wxFileName fn;
if ( defaultDir.empty() )
fn.Assign(defaultFileNameWithExt);
else if ( !defaultFileNameWithExt.empty() )
fn.Assign(defaultDir, defaultFileNameWithExt);
else
fn.AssignDir(defaultDir);
// set the initial file name and/or directory
fn.MakeAbsolute(); // GTK+ needs absolute path
const wxString dir = fn.GetPath();
if ( !dir.empty() )
{
gtk_file_chooser_set_current_folder(file_chooser, wxGTK_CONV_FN(dir));
}
const wxString fname = fn.GetFullName();
if ( style & wxFD_SAVE )
{
if ( !fname.empty() )
{
gtk_file_chooser_set_current_name(file_chooser, wxGTK_CONV_FN(fname));
}
#if GTK_CHECK_VERSION(2,7,3)
if ((style & wxFD_OVERWRITE_PROMPT)
#ifndef __WXGTK3__
&& gtk_check_version(2,7,3) == NULL
#endif
)
{
gtk_file_chooser_set_do_overwrite_confirmation(file_chooser, true);
}
#endif
}
else // wxFD_OPEN
{
if ( !fname.empty() )
{
gtk_file_chooser_set_filename(file_chooser,
wxGTK_CONV_FN(fn.GetFullPath()));
}
}
if ( style & wxFD_PREVIEW )
{
GtkWidget *previewImage = gtk_image_new();
gtk_file_chooser_set_preview_widget(file_chooser, previewImage);
g_signal_connect(m_widget, "update-preview",
G_CALLBACK(gtk_filedialog_update_preview_callback),
previewImage);
}
return true;
}
static void
gimp_file_entry_browse_clicked (GtkWidget *widget,
GimpFileEntry *entry)
{
GtkFileChooser *chooser;
gchar *utf8;
gchar *filename;
utf8 = gtk_editable_get_chars (GTK_EDITABLE (entry->entry), 0, -1);
filename = g_filename_from_utf8 (utf8, -1, NULL, NULL, NULL);
g_free (utf8);
if (! entry->file_dialog)
{
const gchar *title = entry->title;
if (! title)
{
if (entry->dir_only)
title = _("Select Folder");
else
title = _("Select File");
}
entry->file_dialog =
gtk_file_chooser_dialog_new (title, NULL,
entry->dir_only ?
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER :
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (entry->file_dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
chooser = GTK_FILE_CHOOSER (entry->file_dialog);
gtk_window_set_position (GTK_WINDOW (chooser), GTK_WIN_POS_MOUSE);
gtk_window_set_role (GTK_WINDOW (chooser),
"gimp-file-entry-file-dialog");
g_signal_connect (chooser, "response",
G_CALLBACK (gimp_file_entry_chooser_response),
entry);
g_signal_connect (chooser, "delete-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect_swapped (entry, "unmap",
G_CALLBACK (gtk_widget_hide),
chooser);
}
else
{
chooser = GTK_FILE_CHOOSER (entry->file_dialog);
}
gtk_file_chooser_set_filename (chooser, filename);
g_free (filename);
gtk_window_set_screen (GTK_WINDOW (chooser), gtk_widget_get_screen (widget));
gtk_window_present (GTK_WINDOW (chooser));
}
NS_IMETHODIMP
nsFilePicker::Show(PRInt16 *aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
nsXPIDLCString title;
title.Adopt(ToNewUTF8String(mTitle));
GtkWindow *parent_widget = get_gtk_window_for_nsiwidget(mParentWidget);
GtkFileChooserAction action = GetGtkFileChooserAction(mMode);
const gchar *accept_button = (action == GTK_FILE_CHOOSER_ACTION_SAVE)
? GTK_STOCK_SAVE : GTK_STOCK_OPEN;
#if (MOZ_PLATFORM_MAEMO == 5)
GtkWidget *file_chooser =
hildon_file_chooser_dialog_new_with_properties(parent_widget,
"action", action,
"open-button-text", accept_button,
NULL);
gtk_window_set_title(GTK_WINDOW(file_chooser), title);
#else
GtkWidget *file_chooser =
gtk_file_chooser_dialog_new(title, parent_widget, action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
accept_button, GTK_RESPONSE_ACCEPT,
NULL);
gtk_dialog_set_alternative_button_order(GTK_DIALOG(file_chooser),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_CANCEL,
-1);
if (mAllowURLs) {
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(file_chooser), FALSE);
}
#endif
if (action == GTK_FILE_CHOOSER_ACTION_OPEN || action == GTK_FILE_CHOOSER_ACTION_SAVE) {
GtkWidget *img_preview = gtk_image_new();
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(file_chooser), img_preview);
g_signal_connect(file_chooser, "update-preview", G_CALLBACK(UpdateFilePreviewWidget), img_preview);
}
if (parent_widget && parent_widget->group) {
gtk_window_group_add_window(parent_widget->group, GTK_WINDOW(file_chooser));
}
NS_ConvertUTF16toUTF8 defaultName(mDefault);
switch (mMode) {
case nsIFilePicker::modeOpenMultiple:
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser), TRUE);
break;
case nsIFilePicker::modeSave:
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(file_chooser),
defaultName.get());
break;
}
nsCOMPtr<nsIFile> defaultPath;
if (mDisplayDirectory) {
mDisplayDirectory->Clone(getter_AddRefs(defaultPath));
} else if (mPrevDisplayDirectory) {
mPrevDisplayDirectory->Clone(getter_AddRefs(defaultPath));
}
if (defaultPath) {
if (!defaultName.IsEmpty() && mMode != nsIFilePicker::modeSave) {
// Try to select the intended file. Even if it doesn't exist, GTK still switches
// directories.
defaultPath->AppendNative(defaultName);
nsCAutoString path;
defaultPath->GetNativePath(path);
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file_chooser), path.get());
} else {
nsCAutoString directory;
defaultPath->GetNativePath(directory);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser),
directory.get());
}
}
gtk_dialog_set_default_response(GTK_DIALOG(file_chooser), GTK_RESPONSE_ACCEPT);
PRInt32 count = mFilters.Length();
for (PRInt32 i = 0; i < count; ++i) {
// This is fun... the GTK file picker does not accept a list of filters
// so we need to split out each string, and add it manually.
char **patterns = g_strsplit(mFilters[i].get(), ";", -1);
if (!patterns) {
return NS_ERROR_OUT_OF_MEMORY;
}
GtkFileFilter *filter = gtk_file_filter_new();
for (int j = 0; patterns[j] != NULL; ++j) {
nsCAutoString caseInsensitiveFilter = MakeCaseInsensitiveShellGlob(g_strstrip(patterns[j]));
gtk_file_filter_add_pattern(filter, caseInsensitiveFilter.get());
}
g_strfreev(patterns);
if (!mFilterNames[i].IsEmpty()) {
// If we have a name for our filter, let's use that.
const char *filter_name = mFilterNames[i].get();
gtk_file_filter_set_name(filter, filter_name);
} else {
// If we don't have a name, let's just use the filter pattern.
const char *filter_pattern = mFilters[i].get();
gtk_file_filter_set_name(filter, filter_pattern);
}
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser), filter);
// Set the initially selected filter
if (mSelectedType == i) {
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(file_chooser), filter);
}
}
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(file_chooser), PR_TRUE);
gint response = RunDialog(GTK_DIALOG(file_chooser));
switch (response) {
case GTK_RESPONSE_OK:
case GTK_RESPONSE_ACCEPT:
ReadValuesFromFileChooser(file_chooser);
*aReturn = nsIFilePicker::returnOK;
if (mMode == nsIFilePicker::modeSave) {
nsCOMPtr<nsILocalFile> file;
GetFile(getter_AddRefs(file));
if (file) {
PRBool exists = PR_FALSE;
file->Exists(&exists);
if (exists)
*aReturn = nsIFilePicker::returnReplace;
}
}
break;
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_CLOSE:
case GTK_RESPONSE_DELETE_EVENT:
*aReturn = nsIFilePicker::returnCancel;
break;
default:
NS_WARNING("Unexpected response");
*aReturn = nsIFilePicker::returnCancel;
break;
}
gtk_widget_destroy(file_chooser);
return NS_OK;
}
bool wxGtkFileCtrl::Create( wxWindow *parent,
wxWindowID id,
const wxString& defaultDirectory,
const wxString& defaultFileName,
const wxString& wildCard,
long style,
const wxPoint& pos,
const wxSize& size,
const wxString& name )
{
if ( !PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ) )
{
wxFAIL_MSG( wxT( "wxGtkFileCtrl creation failed" ) );
return false;
}
GtkFileChooserAction gtkAction = GTK_FILE_CHOOSER_ACTION_OPEN;
if ( style & wxFC_SAVE )
gtkAction = GTK_FILE_CHOOSER_ACTION_SAVE;
m_widget = gtk_alignment_new ( 0, 0, 1, 1 );
g_object_ref(m_widget);
m_fcWidget = GTK_FILE_CHOOSER( gtk_file_chooser_widget_new(gtkAction) );
gtk_widget_show ( GTK_WIDGET( m_fcWidget ) );
gtk_container_add ( GTK_CONTAINER ( m_widget ), GTK_WIDGET( m_fcWidget ) );
m_focusWidget = GTK_WIDGET( m_fcWidget );
g_signal_connect ( m_fcWidget, "file-activated",
G_CALLBACK ( gtkfilechooserwidget_file_activated_callback ),
this );
g_signal_connect ( m_fcWidget, "current-folder-changed",
G_CALLBACK ( gtkfilechooserwidget_folder_changed_callback ),
this );
g_signal_connect ( m_fcWidget, "selection-changed",
G_CALLBACK ( gtkfilechooserwidget_selection_changed_callback ),
this );
g_signal_connect ( m_fcWidget, "notify",
G_CALLBACK ( gtkfilechooserwidget_notify_callback ),
this );
m_fc.SetWidget( m_fcWidget );
if ( style & wxFC_MULTIPLE )
gtk_file_chooser_set_select_multiple( m_fcWidget, true );
SetWildcard( wildCard );
// if defaultDir is specified it should contain the directory and
// defaultFileName should contain the default name of the file, however if
// directory is not given, defaultFileName contains both
wxFileName fn;
if ( defaultDirectory.empty() )
fn.Assign( defaultFileName );
else if ( !defaultFileName.empty() )
fn.Assign( defaultDirectory, defaultFileName );
else
fn.AssignDir( defaultDirectory );
// set the initial file name and/or directory
const wxString dir = fn.GetPath();
if ( !dir.empty() )
{
gtk_file_chooser_set_current_folder( m_fcWidget,
dir.fn_str() );
}
const wxString fname = fn.GetFullName();
if ( style & wxFC_SAVE )
{
if ( !fname.empty() )
{
gtk_file_chooser_set_current_name( m_fcWidget,
fname.fn_str() );
}
}
else // wxFC_OPEN
{
if ( !fname.empty() )
{
gtk_file_chooser_set_filename( m_fcWidget,
fn.GetFullPath().fn_str() );
}
}
m_parent->DoAddChild( this );
PostCreation( size );
return TRUE;
}
EAPMethodPEAP *
eap_method_peap_new (WirelessSecurity *ws_parent,
NMConnection *connection,
gboolean is_editor,
gboolean secrets_only)
{
EAPMethod *parent;
EAPMethodPEAP *method;
GtkWidget *widget, *widget_ca_not_required_checkbox;
GtkFileFilter *filter;
NMSetting8021x *s_8021x = NULL;
const char *filename;
parent = eap_method_init (sizeof (EAPMethodPEAP),
validate,
add_to_size_group,
fill_connection,
update_secrets,
destroy,
"/org/gnome/control-center/network/eap-method-peap.ui",
"eap_peap_notebook",
"eap_peap_anon_identity_entry",
FALSE);
if (!parent)
return NULL;
parent->password_flags_name = NM_SETTING_802_1X_PASSWORD;
method = (EAPMethodPEAP *) parent;
method->sec_parent = ws_parent;
method->is_editor = is_editor;
if (connection)
s_8021x = nm_connection_get_setting_802_1x (connection);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_ca_cert_not_required_checkbox"));
g_assert (widget);
g_signal_connect (G_OBJECT (widget), "toggled",
(GCallback) ca_cert_not_required_toggled,
parent);
g_signal_connect (G_OBJECT (widget), "toggled",
(GCallback) wireless_security_changed_cb,
ws_parent);
widget_ca_not_required_checkbox = widget;
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_ca_cert_button"));
g_assert (widget);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (widget), TRUE);
gtk_file_chooser_button_set_title (GTK_FILE_CHOOSER_BUTTON (widget),
_("Choose a Certificate Authority certificate"));
g_signal_connect (G_OBJECT (widget), "selection-changed",
(GCallback) wireless_security_changed_cb,
ws_parent);
filter = eap_method_default_file_chooser_filter_new (FALSE);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (widget), filter);
if (connection && s_8021x) {
filename = NULL;
if (nm_setting_802_1x_get_ca_cert_scheme (s_8021x) == NM_SETTING_802_1X_CK_SCHEME_PATH) {
filename = nm_setting_802_1x_get_ca_cert_path (s_8021x);
if (filename)
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (widget), filename);
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget_ca_not_required_checkbox),
!filename && eap_method_ca_cert_ignore_get (parent, connection));
}
widget = inner_auth_combo_init (method, connection, s_8021x, secrets_only);
inner_auth_combo_changed_cb (widget, (gpointer) method);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_version_combo"));
g_assert (widget);
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
if (s_8021x) {
const char *peapver;
peapver = nm_setting_802_1x_get_phase1_peapver (s_8021x);
if (peapver) {
/* Index 0 is "Automatic" */
if (!strcmp (peapver, "0"))
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 1);
else if (!strcmp (peapver, "1"))
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 2);
}
}
g_signal_connect (G_OBJECT (widget), "changed",
(GCallback) wireless_security_changed_cb,
ws_parent);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_anon_identity_entry"));
if (s_8021x && nm_setting_802_1x_get_anonymous_identity (s_8021x))
gtk_entry_set_text (GTK_ENTRY (widget), nm_setting_802_1x_get_anonymous_identity (s_8021x));
g_signal_connect (G_OBJECT (widget), "changed",
(GCallback) wireless_security_changed_cb,
ws_parent);
if (secrets_only) {
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_anon_identity_label"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_anon_identity_entry"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_ca_cert_label"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_ca_cert_button"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_ca_cert_not_required_checkbox"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_inner_auth_label"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_inner_auth_combo"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_version_label"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_version_combo"));
gtk_widget_hide (widget);
}
return method;
}
static void
xfburn_burn_image_dialog_init (XfburnBurnImageDialog * obj)
{
GtkBox *box = GTK_BOX (GTK_DIALOG (obj)->vbox);
XfburnBurnImageDialogPrivate *priv = XFBURN_BURN_IMAGE_DIALOG_GET_PRIVATE (obj);
GdkPixbuf *icon = NULL;
GtkFileFilter *filter;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *button;
XfburnDevice *device;
gtk_window_set_title (GTK_WINDOW (obj), _("Burn image"));
gtk_window_set_destroy_with_parent (GTK_WINDOW (obj), TRUE);
icon = gtk_widget_render_icon (GTK_WIDGET (obj), XFBURN_STOCK_BURN_CD, GTK_ICON_SIZE_DIALOG, NULL);
gtk_window_set_icon (GTK_WINDOW (obj), icon);
g_object_unref (icon);
/* file */
priv->chooser_image = gtk_file_chooser_button_new (_("Image to burn"), GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_widget_show (priv->chooser_image);
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(priv->chooser_image), filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("ISO images"));
gtk_file_filter_add_pattern (filter, "*.[iI][sS][oO]");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (priv->chooser_image), filter);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (priv->chooser_image), filter);
if(xfburn_main_has_initial_dir ()) {
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (priv->chooser_image), xfburn_main_get_initial_dir ());
}
if (last_file) {
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (priv->chooser_image), last_file);
}
frame = xfce_gtk_frame_box_new_with_content (_("Image to burn"), priv->chooser_image);
gtk_widget_show (frame);
gtk_box_pack_start (box, frame, FALSE, FALSE, BORDER);
/* red label for image */
priv->image_label = gtk_label_new ("");
gtk_widget_show (priv->image_label);
gtk_box_pack_start (GTK_BOX (box), priv->image_label, FALSE, FALSE, 0);
update_image_label (GTK_FILE_CHOOSER (priv->chooser_image), obj);
g_signal_connect (G_OBJECT (priv->chooser_image), "selection-changed", G_CALLBACK (update_image_label), obj);
/* devices list */
priv->device_box = xfburn_device_box_new (SHOW_CD_WRITERS | SHOW_CDRW_WRITERS | SHOW_DVD_WRITERS | SHOW_MODE_SELECTION | SHOW_SPEED_SELECTION);
gtk_widget_show (priv->device_box);
frame = xfce_gtk_frame_box_new_with_content (_("Burning device"), priv->device_box);
gtk_widget_show (frame);
gtk_box_pack_start (box, frame, FALSE, FALSE, BORDER);
/* options */
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
frame = xfce_gtk_frame_box_new_with_content (_("Options"), vbox);
gtk_widget_show (frame);
gtk_box_pack_start (box, frame, FALSE, FALSE, BORDER);
priv->check_eject = gtk_check_button_new_with_mnemonic (_("E_ject disk"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_eject), TRUE);
gtk_widget_show (priv->check_eject);
gtk_box_pack_start (GTK_BOX (vbox), priv->check_eject, FALSE, FALSE, BORDER);
priv->check_dummy = gtk_check_button_new_with_mnemonic (_("_Dummy write"));
gtk_widget_show (priv->check_dummy);
gtk_box_pack_start (GTK_BOX (vbox), priv->check_dummy, FALSE, FALSE, BORDER);
priv->check_burnfree = gtk_check_button_new_with_mnemonic (_("Burn_Free"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_burnfree), TRUE);
gtk_widget_show (priv->check_burnfree);
gtk_box_pack_start (GTK_BOX (vbox), priv->check_burnfree, FALSE, FALSE, BORDER);
priv->check_stream_recording = gtk_check_button_new_with_mnemonic (_("Stream _Recording"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_stream_recording), TRUE);
gtk_widget_show (priv->check_stream_recording);
gtk_box_pack_start (GTK_BOX (vbox), priv->check_stream_recording, FALSE, FALSE, BORDER);
priv->check_quit = gtk_check_button_new_with_mnemonic (_("_Quit after success"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_quit), xfburn_settings_get_boolean("quit_after_success", FALSE));
gtk_widget_show (priv->check_quit);
gtk_box_pack_start (GTK_BOX (vbox), priv->check_quit, FALSE, FALSE, BORDER);
/* action buttons */
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_widget_show (button);
gtk_dialog_add_action_widget (GTK_DIALOG (obj), button, GTK_RESPONSE_CANCEL);
priv->burn_button = xfburn_gtk_button_new_mixed (XFBURN_STOCK_BURN_CD, _("_Burn image"));
gtk_widget_show (priv->burn_button);
g_signal_connect (G_OBJECT (priv->burn_button), "clicked", G_CALLBACK (cb_clicked_ok), obj);
gtk_container_add (GTK_CONTAINER( GTK_DIALOG(obj)->action_area), priv->burn_button);
//gtk_dialog_add_action_widget (GTK_DIALOG (obj), button, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (priv->burn_button, GTK_CAN_DEFAULT);
gtk_widget_grab_focus (priv->burn_button);
gtk_widget_grab_default (priv->burn_button);
priv->devlist = xfburn_device_list_new ();
priv->handler_volchange = g_signal_connect (G_OBJECT (priv->devlist), "volume-change-end", G_CALLBACK (cb_volume_change_end), obj);
g_signal_connect (G_OBJECT (obj), "response", G_CALLBACK (cb_dialog_response), obj);
device = xfburn_device_list_get_current_device (priv->devlist);
if (device)
cb_volume_change_end (priv->devlist, TRUE, device, obj);
}
FileInfo *get_fileinfo_from_selector(FileInfo *fi, gint requested_mode)
{
FileInfo *selected_fi;
GtkWidget *selector;
gchar *basename, *str;
gint res, len;
/* init values */
mode = requested_mode;
selected_fi = g_malloc(sizeof(FileInfo));
selected_fi->filename =
fi->filename ? g_strdup(fi->filename) : NULL;
selected_fi->charset =
fi->charset ? g_strdup(fi->charset) : NULL;
selected_fi->charset_flag = fi->charset_flag;
selected_fi->lineend = fi->lineend;
selector = create_file_selector(selected_fi);
gtk_window_set_transient_for(GTK_WINDOW(selector),
GTK_WINDOW(pub->mw->window));
do {
res = gtk_dialog_run(GTK_DIALOG(selector));
if (res == GTK_RESPONSE_OK) {
if (selected_fi->filename)
g_free(selected_fi->filename);
#if ENABLE_CHOOSER
selected_fi->filename =
gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(selector));
#else
selected_fi->filename = g_strdup(
gtk_file_selection_get_filename(GTK_FILE_SELECTION(selector)));
#endif
if (g_file_test(selected_fi->filename, G_FILE_TEST_IS_DIR)) {
len = strlen(selected_fi->filename);
if (len < 1 || selected_fi->filename[len - 1] != G_DIR_SEPARATOR)
str = g_strconcat(selected_fi->filename, G_DIR_SEPARATOR_S, NULL);
else
str = g_strdup(selected_fi->filename);
#if ENABLE_CHOOSER
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(selector), str);
#else
gtk_file_selection_set_filename(GTK_FILE_SELECTION(selector), str);
#endif
g_free(str);
continue;
}
if ((mode == SAVE) && g_file_test(selected_fi->filename, G_FILE_TEST_EXISTS)) {
basename = g_path_get_basename(selected_fi->filename);
str = g_strdup_printf(_("'%s' already exists. Overwrite?"), basename);
g_free(basename);
res = run_dialog_message_question(selector, str);
g_free(str);
switch (res) {
case GTK_RESPONSE_NO:
continue;
case GTK_RESPONSE_YES:
res = GTK_RESPONSE_OK;
}
}
}
gtk_widget_hide(selector);
} while (GTK_WIDGET_VISIBLE(selector));
if (res != GTK_RESPONSE_OK) {
if (selected_fi->charset)
g_free(selected_fi->charset);
selected_fi = NULL;
g_free(selected_fi);
}
gtk_widget_destroy(selector);
return selected_fi;
}
GtkWidget*
gtr_torrent_options_dialog_new (GtkWindow * parent, TrCore * core, tr_ctor * ctor)
{
const char * str;
GtkWidget * w;
GtkWidget * d;
GtkGrid * grid;
int row;
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);
gtk_window_set_default_size(GTK_WINDOW(d),
gtr_pref_int_get (TR_KEY_details_window_width),
gtr_pref_int_get (TR_KEY_details_window_height));
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);
row = 0;
grid = GTK_GRID (gtk_grid_new ());
gtk_container_set_border_width (GTK_CONTAINER (grid), GUI_PAD_BIG);
gtk_grid_set_row_spacing (grid, GUI_PAD);
gtk_grid_set_column_spacing (grid, GUI_PAD_BIG);
/* "torrent file" row */
l = gtk_label_new_with_mnemonic (_("_Torrent file:"));
gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 1, 1);
w = gtk_file_chooser_button_new (_("Select Source File"),
GTK_FILE_CHOOSER_ACTION_OPEN);
source_chooser = w;
gtk_widget_set_hexpand (w, TRUE);
gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
addTorrentFilters (GTK_FILE_CHOOSER (w));
g_signal_connect (w, "selection-changed",
G_CALLBACK (sourceChanged), data);
/* "destination folder" row */
row++;
l = gtk_label_new_with_mnemonic (_("_Destination folder:"));
gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 1, 1);
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_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
g_signal_connect (w, "selection-changed",
G_CALLBACK (downloadDirChanged), data);
row++;
l = data->freespace_label = gtr_freespace_label_new (core, data->downloadDir);
gtk_widget_set_margin_bottom (l, GUI_PAD_BIG);
gtk_misc_set_alignment (GTK_MISC (l), 1.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 2, 1);
/* file list row */
row++;
w = data->file_list;
gtk_widget_set_vexpand (w, TRUE);
gtk_widget_set_size_request (w, 466u, 300u);
gtk_grid_attach (grid, w, 0, row, 2, 1);
/* torrent priority row */
row++;
l = gtk_label_new_with_mnemonic (_("Torrent _priority:"));
gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 1, 1);
w = data->priority_combo;
gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
/* torrent priority row */
row++;
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_grid_attach (grid, w, 0, row, 2, 1);
/* "trash .torrent file" row */
row++;
w = data->trash_check;
if (!tr_ctorGetDeleteSource (ctor, &flag))
g_assert_not_reached ();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), flag);
gtk_grid_attach (grid, w, 0, row, 2, 1);
/* 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), GTK_WIDGET (grid));
w = gtk_dialog_get_widget_for_response (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT);
gtk_widget_grab_focus (w);
return d;
}
/* http://bugzilla.gnome.org/show_bug.cgi?id=347883 */
static gboolean
test_confirm_overwrite_for_path (const char *path, gboolean append_extension)
{
gboolean passed;
struct confirm_overwrite_closure closure;
char *filename;
passed = TRUE;
closure.extension = NULL;
closure.confirm_overwrite_signal_emitted = 0;
closure.chooser = gtk_file_chooser_dialog_new ("hello", NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
closure.accept_button = gtk_dialog_add_button (GTK_DIALOG (closure.chooser),
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT);
gtk_dialog_set_default_response (GTK_DIALOG (closure.chooser), GTK_RESPONSE_ACCEPT);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (closure.chooser), TRUE);
g_signal_connect (closure.chooser, "confirm-overwrite",
G_CALLBACK (confirm_overwrite_cb), &closure);
if (append_extension)
{
char *extension;
filename = g_path_get_dirname (path);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (closure.chooser), filename);
g_free (filename);
filename = g_path_get_basename (path);
extension = strchr (filename, '.');
if (extension)
{
closure.extension = g_strdup (extension);
*extension = '\0';
}
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (closure.chooser), filename);
g_free (filename);
g_signal_connect (closure.chooser, "response",
G_CALLBACK (overwrite_response_cb), &closure);
}
else
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (closure.chooser), path);
}
gdk_threads_add_timeout_full (G_MAXINT, SLEEP_DURATION, confirm_overwrite_timeout_cb, &closure, NULL);
gtk_dialog_run (GTK_DIALOG (closure.chooser));
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (closure.chooser));
passed = passed && filename && (strcmp (filename, path) == 0);
g_free (filename);
gtk_widget_destroy (closure.chooser);
passed = passed && (1 == closure.confirm_overwrite_signal_emitted);
log_test (passed, "Confirm overwrite for %s", path);
return passed;
}
static void * search_get_widget (void)
{
GtkWidget * vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
entry = gtk_entry_new ();
gtk_entry_set_icon_from_icon_name ((GtkEntry *) entry, GTK_ENTRY_ICON_PRIMARY, "edit-find");
gtk_entry_set_placeholder_text ((GtkEntry *) entry, _("Search library"));
g_signal_connect (entry, "destroy", (GCallback) gtk_widget_destroyed, & entry);
gtk_box_pack_start ((GtkBox *) vbox, entry, FALSE, FALSE, 0);
help_label = gtk_label_new (_("To import your music library into "
"Audacious, choose a folder and then click the \"refresh\" icon."));
gtk_widget_set_size_request (help_label, 194, -1);
gtk_label_set_line_wrap ((GtkLabel *) help_label, TRUE);
g_signal_connect (help_label, "destroy", (GCallback) gtk_widget_destroyed, & help_label);
gtk_widget_set_no_show_all (help_label, TRUE);
gtk_box_pack_start ((GtkBox *) vbox, help_label, TRUE, FALSE, 0);
wait_label = gtk_label_new (_("Please wait ..."));
g_signal_connect (wait_label, "destroy", (GCallback) gtk_widget_destroyed, & wait_label);
gtk_widget_set_no_show_all (wait_label, TRUE);
gtk_box_pack_start ((GtkBox *) vbox, wait_label, TRUE, FALSE, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
g_signal_connect (scrolled, "destroy", (GCallback) gtk_widget_destroyed, & scrolled);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scrolled, GTK_SHADOW_IN);
gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scrolled,
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_widget_set_no_show_all (scrolled, TRUE);
gtk_box_pack_start ((GtkBox *) vbox, scrolled, TRUE, TRUE, 0);
results_list = audgui_list_new (& list_callbacks, NULL, items ? index_count (items) : 0);
g_signal_connect (results_list, "destroy", (GCallback) gtk_widget_destroyed, & results_list);
gtk_tree_view_set_headers_visible ((GtkTreeView *) results_list, FALSE);
audgui_list_add_column (results_list, NULL, 0, G_TYPE_STRING, -1);
gtk_container_add ((GtkContainer *) scrolled, results_list);
GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_end ((GtkBox *) vbox, hbox, FALSE, FALSE, 0);
GtkWidget * chooser = gtk_file_chooser_button_new (_("Choose Folder"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_box_pack_start ((GtkBox *) hbox, chooser, TRUE, TRUE, 0);
char * path = get_path ();
gtk_file_chooser_set_filename ((GtkFileChooser *) chooser, path);
str_unref (path);
GtkWidget * button = gtk_button_new ();
gtk_container_add ((GtkContainer *) button, gtk_image_new_from_icon_name
("view-refresh", GTK_ICON_SIZE_BUTTON));
gtk_button_set_relief ((GtkButton *) button, GTK_RELIEF_NONE);
gtk_box_pack_start ((GtkBox *) hbox, button, FALSE, FALSE, 0);
g_signal_connect (entry, "changed", (GCallback) entry_cb, NULL);
g_signal_connect (entry, "activate", (GCallback) action_play, NULL);
g_signal_connect (button, "clicked", (GCallback) refresh_cb, chooser);
gtk_widget_show_all (vbox);
gtk_widget_show (results_list);
show_hide_widgets ();
return vbox;
}
/**
Select a file
Target is the string allocated by caller that will receive the resule, maxlen byte
Source is a optionnal last file to replace the selector at the last dir used
@Title@ is the title of the dialog window
Returns : 0 if error, 1 on success
*/
uint8_t FileSel_SelectRead(const char *title,char *target,uint32_t max, const char *source)
{
GtkWidget *dialog;
uint8_t ret=0;
gchar *selected_filename;
gchar last;
char *dupe=NULL,*tmpname=NULL;
DIR *dir=NULL;
dialog = gtk_file_chooser_dialog_new ("Open File",
NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_window_set_title (GTK_WINDOW (dialog),title);
initFileSelector();
setFilter(dialog);
gtk_register_dialog(dialog);
// gtk_transient(dialog);
if(source)
{
dupe=PathCanonize(source);
PathStripName(dupe);
if( (dir=opendir(dupe)) )
{
closedir(dir);
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),(gchar *)source);
}
delete [] dupe;
}
else //use pref
{
if( prefs->get(LASTDIR_READ,&tmpname))
{
dupe=PathCanonize(tmpname);
PathStripName(dupe);
if( (dir=opendir(dupe)) )
{
closedir(dir);
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),(gchar *)dupe);
}
delete [] dupe;
}
}
if(gtk_dialog_run(GTK_DIALOG(dialog))==GTK_RESPONSE_ACCEPT)
{
selected_filename= (gchar *) gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if(strlen(selected_filename))
{
last=selected_filename[strlen(selected_filename) - 1];
if (last == '/' || last =='\\' )
{
GUI_Error_HIG("Cannot open directory as a file", NULL);
return 0;
}
else
{
// Check we can read it ..
FILE *fd;
fd=fopen(selected_filename,"rb");
if(fd)
{
fclose(fd);
strncpy(target,(char *)selected_filename,max);
// Finally we accept it :)
ret=1;
}
}
}
}
gtk_unregister_dialog(dialog);
gtk_widget_destroy(dialog);
return ret;
}
