void
tls_pw_init_auth_widget (GtkBuilder *builder,
GtkSizeGroup *group,
NMSettingVPN *s_vpn,
ChangedCallback changed_cb,
gpointer user_data)
{
GtkWidget *widget;
const char *value;
GtkFileFilter *filter;
g_return_if_fail (builder != NULL);
g_return_if_fail (group != NULL);
g_return_if_fail (changed_cb != NULL);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ca_cert_chooser"));
gtk_size_group_add_widget (group, widget);
filter = tls_file_chooser_filter_new ();
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (widget), filter);
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", G_CALLBACK (changed_cb), user_data);
if (s_vpn) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_OPENCONNECT_KEY_CACERT);
if (value && strlen (value))
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (widget), value);
}
widget = GTK_WIDGET (gtk_builder_get_object (builder, "cert_user_cert_chooser"));
gtk_size_group_add_widget (group, widget);
filter = tls_file_chooser_filter_new ();
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (widget), filter);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (widget), TRUE);
gtk_file_chooser_button_set_title (GTK_FILE_CHOOSER_BUTTON (widget),
_("Choose your personal certificate..."));
g_signal_connect (G_OBJECT (widget), "selection-changed", G_CALLBACK (changed_cb), user_data);
if (s_vpn) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_OPENCONNECT_KEY_USERCERT);
if (value && strlen (value))
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (widget), value);
}
widget = GTK_WIDGET (gtk_builder_get_object (builder, "cert_private_key_chooser"));
gtk_size_group_add_widget (group, widget);
filter = tls_file_chooser_filter_new ();
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (widget), filter);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (widget), TRUE);
gtk_file_chooser_button_set_title (GTK_FILE_CHOOSER_BUTTON (widget),
_("Choose your private key..."));
g_signal_connect (G_OBJECT (widget), "selection-changed", G_CALLBACK (changed_cb), user_data);
if (s_vpn) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_OPENCONNECT_KEY_PRIVKEY);
if (value && strlen (value))
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (widget), value);
}
}
static void
dlg_photo_importer (GthBrowser *browser,
GFile *source,
DlgImporterSourceType selector_type)
{
DialogData *data;
GtkCellRenderer *renderer;
GthFileDataSort *sort_type;
GList *tests, *scan;
char *general_filter;
int i, active_filter;
int i_general;
if (gth_browser_get_dialog (browser, "photo_importer") != NULL) {
gtk_window_present (GTK_WINDOW (gth_browser_get_dialog (browser, "photo_importer")));
return;
}
data = g_new0 (DialogData, 1);
data->browser = browser;
data->builder = gtk_builder_new_from_resource ("/org/gnome/gThumb/photo_importer/data/ui/photo-importer.ui");
data->settings = g_settings_new (GTHUMB_PHOTO_IMPORTER_SCHEMA);
data->selector_type = selector_type;
data->source = _g_object_ref (source);
data->cancellable = g_cancellable_new ();
data->vfs_source = g_object_new (GTH_TYPE_FILE_SOURCE_VFS, NULL);
gth_file_source_monitor_entry_points (GTH_FILE_SOURCE (data->vfs_source));
/* Get the widgets. */
data->dialog = _gtk_builder_get_widget (data->builder, "photo_importer_dialog");
_gtk_window_resize_to_fit_screen_height (data->dialog, 580);
gth_browser_set_dialog (browser, "photo_importer", data->dialog);
g_object_set_data (G_OBJECT (data->dialog), "dialog_data", data);
if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) {
gtk_window_set_title (GTK_WINDOW (data->dialog), _("Import from Removable Device"));
data->device_list_store = gtk_list_store_new (SOURCE_LIST_COLUMNS, G_TYPE_OBJECT, G_TYPE_ICON, G_TYPE_STRING);
data->device_chooser = gtk_combo_box_new_with_model (GTK_TREE_MODEL (data->device_list_store));
gtk_widget_show (data->device_chooser);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("source_box")), data->device_chooser, TRUE, TRUE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("source_label")), data->device_chooser);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->device_chooser), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->device_chooser),
renderer,
"gicon", SOURCE_LIST_COLUMN_ICON,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->device_chooser), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->device_chooser),
renderer,
"text", SOURCE_LIST_COLUMN_NAME,
NULL);
g_object_unref (data->device_list_store);
}
else {
if (data->source == NULL) {
if (GTH_IS_FILE_SOURCE_VFS (gth_browser_get_location_source (browser)))
data->source = _g_object_ref (gth_browser_get_location (browser));
if (data->source == NULL)
data->source = g_file_new_for_uri (get_home_uri ());
}
gtk_window_set_title (GTK_WINDOW (data->dialog), _("Import from Folder"));
data->folder_chooser = gtk_file_chooser_button_new (_("Choose a folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("source_label")), data->folder_chooser);
gtk_file_chooser_set_file (GTK_FILE_CHOOSER (data->folder_chooser), data->source, NULL);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (data->folder_chooser), FALSE);
gtk_widget_show (data->folder_chooser);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("source_box")), data->folder_chooser, TRUE, TRUE, 0);
}
data->file_list = gth_file_list_new (gth_grid_view_new (), GTH_FILE_LIST_MODE_NORMAL, FALSE);
sort_type = gth_main_get_sort_type ("file::mtime");
gth_file_list_set_sort_func (GTH_FILE_LIST (data->file_list), sort_type->cmp_func, FALSE);
gth_file_list_enable_thumbs (GTH_FILE_LIST (data->file_list), TRUE);
gth_file_list_set_ignore_hidden (GTH_FILE_LIST (data->file_list), TRUE);
gth_file_list_set_thumb_size (GTH_FILE_LIST (data->file_list), 128);
gth_file_list_set_caption (GTH_FILE_LIST (data->file_list), "standard::display-name,gth::file::display-size");
gtk_widget_show (data->file_list);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("filelist_box")), data->file_list, TRUE, TRUE, 0);
tests = gth_main_get_registered_objects_id (GTH_TYPE_TEST);
general_filter = "file::type::is_media"; /* default value */
active_filter = 0;
data->filter_combobox = gtk_combo_box_text_new ();
for (i = 0, i_general = -1, scan = tests; scan; scan = scan->next, i++) {
const char *registered_test_id = scan->data;
GthTest *test;
if (strncmp (registered_test_id, "file::type::", 12) != 0)
continue;
i_general += 1;
test = gth_main_get_registered_object (GTH_TYPE_TEST, registered_test_id);
if (strcmp (registered_test_id, general_filter) == 0) {
active_filter = i_general;
gth_file_list_set_filter (GTH_FILE_LIST (data->file_list), test);
}
data->general_tests = g_list_prepend (data->general_tests, g_strdup (gth_test_get_id (test)));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (data->filter_combobox),
gth_test_get_display_name (test));
g_object_unref (test);
}
data->general_tests = g_list_reverse (data->general_tests);
gtk_combo_box_set_active (GTK_COMBO_BOX (data->filter_combobox), active_filter);
gtk_widget_show (data->filter_combobox);
gtk_container_add (GTK_CONTAINER (GET_WIDGET ("filter_box")), data->filter_combobox);
gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("filter_label")), data->filter_combobox);
gtk_label_set_use_underline (GTK_LABEL (GET_WIDGET ("filter_label")), TRUE);
_g_string_list_free (tests);
data->tags_entry = gth_tags_entry_new (GTH_TAGS_ENTRY_MODE_POPUP);
gtk_widget_show (data->tags_entry);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("tags_entry_box")), data->tags_entry, TRUE, TRUE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("tags_label")), data->tags_entry);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("delete_checkbutton")),
g_settings_get_boolean (data->settings, PREF_PHOTO_IMPORTER_DELETE_FROM_DEVICE));
data->preferences_dialog = gth_import_preferences_dialog_new ();
gtk_window_set_transient_for (GTK_WINDOW (data->preferences_dialog), GTK_WINDOW (data->dialog));
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("destination_button_box")),
gth_import_destination_button_new (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog)),
TRUE,
TRUE,
0);
gtk_widget_show_all (GET_WIDGET ("destination_button_box"));
/* Set the signals handlers. */
g_signal_connect (G_OBJECT (data->dialog),
"delete-event",
G_CALLBACK (dialog_delete_event_cb),
data);
g_signal_connect (GET_WIDGET ("ok_button"),
"clicked",
G_CALLBACK (ok_clicked_cb),
data);
g_signal_connect (GET_WIDGET ("cancel_button"),
"clicked",
G_CALLBACK (close_dialog),
data);
if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE)
g_signal_connect (data->device_chooser,
"changed",
G_CALLBACK (device_chooser_changed_cb),
data);
else
g_signal_connect (data->folder_chooser,
"selection-changed",
G_CALLBACK (folder_chooser_file_set_cb),
data);
g_signal_connect (data->filter_combobox,
"changed",
G_CALLBACK (filter_combobox_changed_cb),
data);
g_signal_connect (gth_file_view_get_model (GTH_FILE_VIEW (gth_file_list_get_view (GTH_FILE_LIST (data->file_list)))),
"visibility_changed",
G_CALLBACK (file_store_changed_cb),
data);
g_signal_connect (gth_file_list_get_view (GTH_FILE_LIST (data->file_list)),
"file-selection-changed",
G_CALLBACK (file_view_selection_changed_cb),
data);
data->entry_points_changed_id = g_signal_connect (gth_main_get_default_monitor (),
"entry-points-changed",
G_CALLBACK (entry_points_changed_cb),
data);
g_signal_connect_after (GET_WIDGET ("event_entry"),
"changed",
G_CALLBACK (event_entry_changed_cb),
data);
/* Run dialog. */
gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (browser));
gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE);
gtk_widget_show (data->dialog);
gth_import_preferences_dialog_set_event (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog),
gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("event_entry"))));
if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE)
update_device_source_list (data);
else
load_file_list (data);
}
static gboolean
init_plugin_ui (VpncEditor *self,
NMConnection *connection,
gboolean new_connection,
GError **error)
{
VpncEditorPrivate *priv = VPNC_EDITOR_GET_PRIVATE (self);
NMSettingConnection *s_con = NULL;
NMSettingVpn *s_vpn = NULL;
GtkWidget *widget;
GtkListStore *store;
GtkTreeIter iter;
const char *value = NULL;
int active = -1;
const char *natt_mode = NULL;
const char *ike_dh_group = NULL;
const char *vendor = NULL;
const char *pfs_group = NULL;
gboolean enabled = FALSE;
GtkFileFilter *filter;
if (connection) {
s_con = nm_connection_get_setting_connection (connection);
s_vpn = nm_connection_get_setting_vpn (connection);
}
priv->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "gateway_entry"));
g_return_val_if_fail (widget != NULL, FALSE);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (widget));
if (s_vpn) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_GATEWAY);
if (value && strlen (value))
gtk_entry_set_text (GTK_ENTRY (widget), value);
}
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (stuff_changed_cb), self);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "group_entry"));
g_return_val_if_fail (widget != NULL, FALSE);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (widget));
if (s_vpn) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_ID);
if (value && strlen (value))
gtk_entry_set_text (GTK_ENTRY (widget), value);
}
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (stuff_changed_cb), self);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "encryption_combo"));
g_return_val_if_fail (widget != NULL, FALSE);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (widget));
store = gtk_list_store_new (1, G_TYPE_STRING);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("Secure (default)"), -1);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("Weak (use with caution)"), -1);
if (s_vpn && (active < 0)) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_SINGLE_DES);
if (value && !strcmp (value, "yes"))
active = 1;
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("None (completely insecure)"), -1);
if (s_vpn && (active < 0)) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_NO_ENCRYPTION);
if (value && !strcmp (value, "yes"))
active = 2;
}
gtk_combo_box_set_model (GTK_COMBO_BOX (widget), GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), active < 0 ? 0 : active);
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (stuff_changed_cb), self);
/* Fill the VPN passwords *before* initializing the PW type combos, since
* knowing if there are passwords when initializing the combos is helpful.
*/
setup_password_widget (self,
"user_password_entry",
s_vpn,
NM_VPNC_KEY_XAUTH_PASSWORD,
new_connection);
setup_password_widget (self,
"group_password_entry",
s_vpn,
NM_VPNC_KEY_SECRET,
new_connection);
init_password_icon (self,
s_vpn,
NM_VPNC_KEY_XAUTH_PASSWORD,
NM_VPNC_KEY_XAUTH_PASSWORD_TYPE,
"user_password_entry");
init_password_icon (self,
s_vpn,
NM_VPNC_KEY_SECRET,
NM_VPNC_KEY_SECRET_TYPE,
"group_password_entry");
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "user_entry"));
g_return_val_if_fail (widget != NULL, FALSE);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (widget));
if (s_vpn) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_XAUTH_USER);
if (value && strlen (value))
gtk_entry_set_text (GTK_ENTRY (widget), value);
}
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (stuff_changed_cb), self);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "domain_entry"));
g_return_val_if_fail (widget != NULL, FALSE);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (widget));
if (s_vpn) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_DOMAIN);
if (value && strlen (value))
gtk_entry_set_text (GTK_ENTRY (widget), value);
}
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (stuff_changed_cb), self);
/* Vendor combo */
active = -1;
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
if (s_vpn)
vendor = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_VENDOR);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("Cisco (default)"), 1, NM_VPNC_VENDOR_CISCO, -1);
if ((active < 0) && vendor) {
if (!strcmp (vendor, NM_VPNC_VENDOR_CISCO))
active = 0;
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("Netscreen"), 1, NM_VPNC_VENDOR_NETSCREEN, -1);
if ((active < 0) && vendor) {
if (!strcmp (vendor, NM_VPNC_VENDOR_NETSCREEN))
active = 1;
}
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "vendor_combo"));
g_return_val_if_fail (widget != NULL, FALSE);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (widget));
gtk_combo_box_set_model (GTK_COMBO_BOX (widget), GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), active < 0 ? 0 : active);
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (stuff_changed_cb), self);
/* Application version */
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "application_version_entry"));
g_return_val_if_fail (widget != NULL, FALSE);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (widget));
if (s_vpn) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_APP_VERSION);
if (value && strlen (value))
gtk_entry_set_text (GTK_ENTRY (widget), value);
}
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (stuff_changed_cb), self);
/* Interface name */
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "interface_name_entry"));
g_return_val_if_fail (widget != NULL, FALSE);
if (s_con) {
value = nm_setting_connection_get_interface_name (s_con);
if (value && strlen (value))
gtk_entry_set_text (GTK_ENTRY (widget), value);
}
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (stuff_changed_cb), self);
active = -1;
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
if (s_vpn)
natt_mode = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_NAT_TRAVERSAL_MODE);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("NAT-T when available (default)"), 1, NM_VPNC_NATT_MODE_NATT, -1);
if ((active < 0) && natt_mode) {
if (!strcmp (natt_mode, NM_VPNC_NATT_MODE_NATT))
active = 0;
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("NAT-T always"), 1, NM_VPNC_NATT_MODE_NATT_ALWAYS, -1);
if ((active < 0) && natt_mode) {
if (!strcmp (natt_mode, NM_VPNC_NATT_MODE_NATT_ALWAYS))
active = 1;
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("Cisco UDP"), 1, NM_VPNC_NATT_MODE_CISCO, -1);
if ((active < 0) && natt_mode) {
if (!strcmp (natt_mode, NM_VPNC_NATT_MODE_CISCO))
active = 2;
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("Disabled"), 1, NM_VPNC_NATT_MODE_NONE, -1);
if ((active < 0) && natt_mode) {
if (!strcmp (natt_mode, NM_VPNC_NATT_MODE_NONE))
active = 3;
}
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "natt_combo"));
g_return_val_if_fail (widget != NULL, FALSE);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (widget));
gtk_combo_box_set_model (GTK_COMBO_BOX (widget), GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), active < 0 ? 0 : active);
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (stuff_changed_cb), self);
active = -1;
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
if (s_vpn)
ike_dh_group = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_DHGROUP);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("DH Group 1"), 1, NM_VPNC_DHGROUP_DH1, -1);
if ((active < 0) && ike_dh_group) {
if (!strcmp (ike_dh_group, NM_VPNC_DHGROUP_DH1))
active = 0;
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("DH Group 2 (default)"), 1, NM_VPNC_DHGROUP_DH2, -1);
if ((active < 0) && ike_dh_group) {
if (!strcmp (ike_dh_group, NM_VPNC_DHGROUP_DH2))
active = 1;
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("DH Group 5"), 1, NM_VPNC_DHGROUP_DH5, -1);
if ((active < 0) && ike_dh_group) {
if (!strcmp (ike_dh_group, NM_VPNC_DHGROUP_DH5))
active = 2;
}
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "dhgroup_combo"));
g_return_val_if_fail (widget != NULL, FALSE);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (widget));
gtk_combo_box_set_model (GTK_COMBO_BOX (widget), GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), active < 0 ? 1 : active);
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (stuff_changed_cb), self);
/* Local Port */
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "local_port_spinbutton"));
g_return_val_if_fail (widget != NULL, FALSE);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (widget));
if (s_vpn) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_LOCAL_PORT);
if (value) {
long int tmp;
errno = 0;
tmp = strtol (value, NULL, 10);
if (errno != 0 || tmp < 0 || tmp > 65535)
tmp = 0;
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "local_port_spinbutton"));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), (gdouble) tmp);
}
}
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (spinbutton_changed_cb), self);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "disable_dpd_checkbutton"));
g_return_val_if_fail (widget != NULL, FALSE);
if (s_vpn) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_DPD_IDLE_TIMEOUT);
if (value) {
long int tmp;
errno = 0;
tmp = strtol (value, NULL, 10);
if (tmp >= 0 && tmp <= G_MAXUINT32 && errno == 0)
priv->orig_dpd_timeout = (guint32) tmp;
if (priv->orig_dpd_timeout == 0)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
}
}
g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (stuff_changed_cb), self);
/* Perfect Forward Secrecy combo */
active = -1;
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
if (s_vpn)
pfs_group = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_PERFECT_FORWARD);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("Server (default)"), 1, NM_VPNC_PFS_SERVER, -1);
if ((active < 0) && pfs_group) {
if (!strcmp (pfs_group, NM_VPNC_PFS_SERVER))
active = 0;
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("None"), 1, NM_VPNC_PFS_NOPFS, -1);
if ((active < 0) && pfs_group) {
if (!strcmp (pfs_group, NM_VPNC_PFS_NOPFS))
active = 1;
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("DH Group 1"), 1, NM_VPNC_PFS_DH1, -1);
if ((active < 0) && pfs_group) {
if (!strcmp (pfs_group, NM_VPNC_PFS_DH1))
active = 2;
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("DH Group 2"), 1, NM_VPNC_PFS_DH2, -1);
if ((active < 0) && pfs_group) {
if (!strcmp (pfs_group, NM_VPNC_PFS_DH2))
active = 3;
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("DH Group 5"), 1, NM_VPNC_PFS_DH5, -1);
if ((active < 0) && pfs_group) {
if (!strcmp (pfs_group, NM_VPNC_PFS_DH5))
active = 4;
}
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "pfsecrecy_combo"));
g_return_val_if_fail (widget != NULL, FALSE);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (widget));
gtk_combo_box_set_model (GTK_COMBO_BOX (widget), GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), active < 0 ? 0 : active);
g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (stuff_changed_cb), self);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "show_passwords_checkbutton"));
g_return_val_if_fail (widget != NULL, FALSE);
g_signal_connect (G_OBJECT (widget), "toggled",
(GCallback) show_toggled_cb,
self);
/* hybrid auth */
enabled = FALSE;
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "hybrid_checkbutton"));
g_return_val_if_fail (widget != NULL, FALSE);
if (s_vpn) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_AUTHMODE);
if (value && !strcmp("hybrid", value)) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
enabled = TRUE;
}
}
g_signal_connect (G_OBJECT (widget), "toggled", G_CALLBACK (hybrid_toggled_cb), self);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "ca_file_chooser"));
g_return_val_if_fail (widget != NULL, FALSE);
gtk_size_group_add_widget (priv->group, widget);
gtk_widget_set_sensitive (widget, enabled);
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 (CA) certificate…"));
filter = gtk_file_filter_new ();
gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_FILENAME, cert_filter, NULL, NULL);
gtk_file_filter_set_name (filter, _("PEM certificates (*.pem, *.crt, *.cer)"));
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (widget), filter);
if (s_vpn) {
value = nm_setting_vpn_get_data_item (s_vpn, NM_VPNC_KEY_CA_FILE);
if (value && strlen (value))
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (widget), value);
}
g_signal_connect (G_OBJECT (widget), "file-set", G_CALLBACK (stuff_changed_cb), self);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "cafile_label"));
g_return_val_if_fail (widget != NULL, FALSE);
gtk_widget_set_sensitive (widget, enabled);
/* advanced dialog */
priv->advanced_dialog = GTK_WIDGET (gtk_builder_get_object (priv->builder, "vpnc-advanced-dialog"));
g_return_val_if_fail (priv->advanced_dialog != NULL, FALSE);
g_signal_connect (G_OBJECT (priv->advanced_dialog), "delete-event",
G_CALLBACK (gtk_widget_hide_on_delete), self);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "advanced_button"));
g_return_val_if_fail (widget != NULL, FALSE);
g_signal_connect (G_OBJECT (widget), "clicked",
(GCallback) toggle_advanced_dialog_cb,
self);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "apply_button"));
g_return_val_if_fail (widget != NULL, FALSE);
g_signal_connect (G_OBJECT (widget), "clicked",
(GCallback) toggle_advanced_dialog_cb,
self);
return TRUE;
}
void XAP_UnixDialog_FileOpenSaveAs::runModal(XAP_Frame * pFrame)
{
const XAP_StringSet * pSS = m_pApp->getStringSet();
std::string szTitle;
std::string szFileTypeLabel;
switch (m_id)
{
case XAP_DIALOG_ID_INSERT_PICTURE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_IP_Title, szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel, szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_FILE_OPEN:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_OpenTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_FILE_IMPORT:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ImportTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_INSERTMATHML:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_InsertMath,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileInsertMath,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_INSERTOBJECT:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_InsertObject,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileInsertObject,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_INSERT_FILE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_InsertTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_FILE_SAVEAS:
case XAP_DIALOG_ID_FILE_SAVE_IMAGE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_SaveAsTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileSaveTypeLabel,szFileTypeLabel);
m_bSave = true;
break;
}
case XAP_DIALOG_ID_FILE_EXPORT:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ExportTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileSaveTypeLabel,szFileTypeLabel);
m_bSave = true;
break;
}
case XAP_DIALOG_ID_PRINTTOFILE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_PrintToFileTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FilePrintTypeLabel,szFileTypeLabel);
m_bSave = true;
break;
}
case XAP_DIALOG_ID_RECORDTOFILE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_RecordToFileTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_RecordToFileLabel,szFileTypeLabel);
m_bSave = true;
break;
}
case XAP_DIALOG_ID_REPLAYFROMFILE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ReplayFromFileTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ReplayFromFileLabel,szFileTypeLabel);
m_bSave = false;
break;
}
default:
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
m_bSave = false;
break;
}
// NOTE: we use our string mechanism to localize the dialog's
// NOTE: title and the error/confirmation message boxes. we
// NOTE: let GTK take care of the localization of the actual
// NOTE: buttons and labels on the FileSelection dialog.
// Get the GtkWindow of the parent frame
XAP_UnixFrameImpl * pUnixFrameImpl = static_cast<XAP_UnixFrameImpl *>(pFrame->getFrameImpl());
GtkWidget * parent = pUnixFrameImpl->getTopLevelWindow();
if(parent && (GTK_WIDGET_TOPLEVEL(parent) != TRUE))
{
parent = gtk_widget_get_toplevel (parent);
}
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
m_FC = GTK_FILE_CHOOSER( hildon_file_chooser_dialog_new(GTK_WINDOW(parent),
(!m_bSave ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE))
);
#else
m_FC = GTK_FILE_CHOOSER( gtk_file_chooser_dialog_new (szTitle.c_str(),
GTK_WINDOW(parent),
(!m_bSave ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
(m_bSave ? GTK_STOCK_SAVE : GTK_STOCK_OPEN), GTK_RESPONSE_ACCEPT,
(gchar*)NULL)
);
#endif
gtk_file_chooser_set_local_only(m_FC, FALSE);
abiSetupModalDialog(GTK_DIALOG(m_FC), pFrame, this, GTK_RESPONSE_ACCEPT);
GtkWidget * filetypes_pulldown = NULL;
std::string s;
/*
Add a drop-down list of known types to facilitate a file-types selection.
We store an indexer in the user data for each menu item in the popup, so
we can read the type we need to return.
*/
if (m_id == XAP_DIALOG_ID_INSERT_PICTURE)
{
GtkWidget * preview = createDrawingArea ();
gtk_widget_show (preview);
m_preview = preview;
gtk_widget_set_size_request (preview, PREVIEW_WIDTH, PREVIEW_HEIGHT);
// place the preview area inside a container to get a nice border
GtkWidget * preview_hbox = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER(preview_hbox), 4);
gtk_box_pack_start(GTK_BOX(preview_hbox), preview, TRUE, TRUE, 0);
// attach the preview area to the dialog
gtk_file_chooser_set_preview_widget (m_FC, preview_hbox);
gtk_file_chooser_set_preview_widget_active (m_FC, true);
// connect some signals
g_signal_connect (m_FC, "update_preview",
G_CALLBACK (file_selection_changed), static_cast<gpointer>(this));
g_signal_connect (preview, "expose_event",
G_CALLBACK (s_preview_exposed), static_cast<gpointer>(this));
}
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
filetypes_pulldown = gtk_combo_box_new();
gtk_widget_show(filetypes_pulldown);
GtkWidget * pulldown_hbox = filetypes_pulldown;
#else
// hbox for our pulldown menu (GTK does its pulldown this way */
GtkWidget * pulldown_hbox = gtk_hbox_new(FALSE, 15);
gtk_widget_show(pulldown_hbox);
// pulldown label
GtkWidget * filetypes_label = gtk_label_new_with_mnemonic(convertMnemonics(szFileTypeLabel).c_str());
gtk_label_set_justify(GTK_LABEL(filetypes_label), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment(GTK_MISC(filetypes_label), 1.0, 0.5);
gtk_widget_show(filetypes_label);
gtk_box_pack_start(GTK_BOX(pulldown_hbox), filetypes_label, TRUE, TRUE, 0);
// pulldown menu
filetypes_pulldown = gtk_combo_box_new();
gtk_widget_show(filetypes_pulldown);
gtk_box_pack_end(GTK_BOX(pulldown_hbox), filetypes_pulldown, TRUE, TRUE, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(filetypes_label), filetypes_pulldown);
#endif
//
// add the filters to the dropdown list
//
GtkComboBox* combo = GTK_COMBO_BOX(filetypes_pulldown);
XAP_makeGtkComboBoxText(combo, G_TYPE_INT);
// Auto-detect is always an option, but a special one, so we use
// a pre-defined constant for the type, and don't use the user-supplied
// types yet.
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileTypeAutoDetect,s);
XAP_appendComboBoxTextAndInt(combo, s.c_str(), XAP_DIALOG_FILEOPENSAVEAS_FILE_TYPE_AUTO);
UT_sint32 activeItemIndex = -1;
// add list items
{
UT_ASSERT(g_strv_length((gchar **) m_szSuffixes) == g_strv_length((gchar **) m_szDescriptions));
// measure one list, they should all be the same length
UT_uint32 end = g_strv_length((gchar **) m_szDescriptions);
for (UT_uint32 i = 0; i < end; i++)
{
// If this type is default, save its index (i) for later use
if (m_nTypeList[i] == m_nDefaultFileType)
activeItemIndex = i;
XAP_appendComboBoxTextAndInt(combo, m_szDescriptions[i], m_nTypeList[i]);
//
// Attach a callback when it is activated to change the file suffix
//
// g_signal_connect(G_OBJECT(thismenuitem), "activate",
// G_CALLBACK(s_filetypechanged),
// reinterpret_cast<gpointer>(this));
}
}
m_wFileTypes_PullDown = filetypes_pulldown;
// dialog; open dialog always does auto-detect
// TODO: should this also apply to the open dialog?
if (m_id == XAP_DIALOG_ID_FILE_SAVEAS || m_id == XAP_DIALOG_ID_FILE_SAVE_IMAGE)
{
gtk_combo_box_set_active(combo, activeItemIndex + 1);
}
else
{
gtk_combo_box_set_active(combo, 0);
}
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
hildon_file_chooser_dialog_add_extra ((HildonFileChooserDialog*)m_FC,
pulldown_hbox);
#else
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER(m_FC), pulldown_hbox);
#endif
// connect the signals for OK and CANCEL and the requisite clean-close signals
g_signal_connect(G_OBJECT(m_FC),
"delete-event",
G_CALLBACK(s_delete_clicked),
this);
g_signal_connect(G_OBJECT(m_FC),
"key_press_event",
G_CALLBACK(fsel_key_event), &m_answer);
g_signal_connect (G_OBJECT (m_FC),
"response",
G_CALLBACK(dialog_response), &m_answer);
g_signal_connect (G_OBJECT (m_FC),
"file-activated",
G_CALLBACK(s_file_activated), &m_answer);
g_signal_connect(G_OBJECT(filetypes_pulldown), "changed",
G_CALLBACK(s_filetypechanged),
reinterpret_cast<gpointer>(this));
// use the persistence info and/or the suggested filename
// to properly seed the dialog.
gchar * szPersistDirectory = NULL; // we must g_free this
if (!m_szInitialPathname || !*m_szInitialPathname)
{
// the caller did not supply initial pathname
// (or supplied an empty one). see if we have
// some persistent info.
UT_ASSERT(!m_bSuggestName);
if (m_szPersistPathname)
{
// we have a pathname from a previous use,
// extract the directory portion and start
// the dialog there (but without a filename).
szPersistDirectory = UT_go_dirname_from_uri(m_szPersistPathname, FALSE);
gtk_file_chooser_set_current_folder_uri(m_FC, szPersistDirectory);
}
else
{
// no initial pathname given and we don't have
// a pathname from a previous use, so just let
// it come up in the current working directory.
}
}
else
{
// we have an initial pathname (the name of the document
// in the frame that we were invoked on). if the caller
// wanted us to suggest a filename, use the initial
// pathname as is. if not, use the directory portion of
// it.
if (m_bSuggestName)
{
xxx_UT_DEBUGMSG(("Iniitial filename is %s \n",m_szInitialPathname));
#if 0
if (!g_path_is_absolute (m_szInitialPathname)) { // DAL: todo: is this correct?
gchar *dir = g_get_current_dir ();
gchar *file = m_szInitialPathname;
gchar *filename = g_build_filename (dir, file, (gchar *)NULL);
m_szInitialPathname = UT_go_filename_to_uri(filename);
g_free(filename);
g_free (dir);
g_free (file);
}
#endif
if(m_id == XAP_DIALOG_ID_FILE_SAVEAS)
{
std::string szInitialSuffix = UT_pathSuffix(m_szInitialPathname);
std::string szSaveTypeSuffix = IE_Exp::preferredSuffixForFileType(m_nDefaultFileType).utf8_str();
if(!szInitialSuffix.empty() && !szSaveTypeSuffix.empty()
&& (szSaveTypeSuffix != szInitialSuffix))
{
std::string sFileName = m_szInitialPathname;
std::string::size_type i = sFileName.find_last_of('.');
if(i != std::string::npos)
{
// erase to the end()
sFileName.erase(i);
sFileName += szSaveTypeSuffix;
FREEP(m_szInitialPathname);
m_szInitialPathname = g_strdup(sFileName.c_str());
}
}
}
if (UT_go_path_is_uri(m_szInitialPathname) || UT_go_path_is_path(m_szInitialPathname))
{
gtk_file_chooser_set_uri(m_FC, m_szInitialPathname);
}
}
else
{
if (UT_go_path_is_uri(m_szInitialPathname) || UT_go_path_is_path(m_szInitialPathname))
{
szPersistDirectory = UT_go_dirname_from_uri(m_szInitialPathname, FALSE);
gtk_file_chooser_set_current_folder_uri(m_FC, szPersistDirectory);
}
else
{
// we are dealing with a plain filename, not an URI or path, so
// just let it come up in the current working directory.
}
}
}
// center the dialog
xxx_UT_DEBUGMSG(("before center IS WIDGET_TOP_LEVL %d \n",(GTK_WIDGET_TOPLEVEL(parent))));
xxx_UT_DEBUGMSG(("before center IS WIDGET WINDOW %d \n",(GTK_IS_WINDOW(parent))));
centerDialog(parent, GTK_WIDGET(m_FC));
xxx_UT_DEBUGMSG(("After center IS WIDGET WINDOW %d \n",(GTK_IS_WINDOW(parent))));
gtk_widget_show(GTK_WIDGET(m_FC));
gtk_grab_add(GTK_WIDGET(m_FC));
bool bResult = _run_gtk_main(pFrame,filetypes_pulldown);
if (bResult)
{
UT_ASSERT(m_szFinalPathnameCandidate);
// store final path name and file type
m_szFinalPathname = g_strdup(m_szFinalPathnameCandidate);
FREEP(m_szFinalPathnameCandidate);
// what a long ugly line of code
m_nFileType = XAP_comboBoxGetActiveInt(GTK_COMBO_BOX(filetypes_pulldown));
}
if (m_FC != NULL) {
gtk_grab_remove (GTK_WIDGET(m_FC));
gtk_widget_destroy (GTK_WIDGET(m_FC));
m_FC = NULL;
FREEP(szPersistDirectory);
}
return;
}
static gboolean
verify_start (SeahorseToolMode *mode, const gchar *uri, gpgme_data_t uridata,
SeahorsePGPOperation *pop, GError **err)
{
gpgme_data_t plain;
gpgme_error_t gerr;
gchar *original, *unesc_uri;
/* File to decrypt to */
original = seahorse_util_remove_suffix (uri, NULL);
/* The original file doesn't exist, prompt for it */
if (!seahorse_util_uri_exists (original)) {
GtkWidget *dialog;
gchar *t;
unesc_uri = g_uri_unescape_string (seahorse_util_uri_get_last (uri), NULL);
t = g_strdup_printf (_("Choose Original File for '%s'"),
unesc_uri);
dialog = gtk_file_chooser_dialog_new (t,
NULL, GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
g_free (unesc_uri);
g_free (t);
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog), original);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), FALSE);
g_free (original);
original = NULL;
seahorse_tool_progress_block (TRUE);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
original = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog));
seahorse_tool_progress_block (FALSE);
gtk_widget_destroy (dialog);
}
if (!original)
return FALSE;
g_object_set_data_full (G_OBJECT (pop), "original-file", original, g_free);
/* Open necessary files, release with operation */
plain = seahorse_vfs_data_create (original, SEAHORSE_VFS_READ, err);
if (!plain)
return FALSE;
g_object_set_data_full (G_OBJECT (pop), "plain-data", plain,
(GDestroyNotify)gpgme_data_release);
/* Start actual verify */
gerr = gpgme_op_verify_start (pop->gctx, uridata, plain, NULL);
if (gerr != 0) {
seahorse_util_gpgme_to_error (gerr, err);
return FALSE;
}
return TRUE;
}
gboolean
seahorse_gpgme_photo_add (SeahorseGpgmeKey *pkey,
GtkWindow *parent,
const gchar *path)
{
gchar *filename = NULL;
gchar *tempfile = NULL;
GError *error = NULL;
gpgme_error_t gerr;
GtkWidget *chooser;
gboolean res = TRUE;
g_return_val_if_fail (SEAHORSE_IS_GPGME_KEY (pkey), FALSE);
if (NULL == path) {
chooser = gtk_file_chooser_dialog_new (_("Choose Photo to Add to Key"), parent,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_ACCEPT);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (chooser), TRUE);
add_image_files (chooser);
if (gtk_dialog_run (GTK_DIALOG (chooser)) == GTK_RESPONSE_ACCEPT)
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser));
gtk_widget_destroy (chooser);
if (!filename)
return FALSE;
} else {
filename = g_strdup (path);
}
if (!prepare_photo_id (parent, filename, &tempfile, &error)) {
seahorse_util_handle_error (&error, NULL, _("Couldn’t prepare photo"));
return FALSE;
}
gerr = seahorse_gpgme_key_op_photo_add (pkey, tempfile ? tempfile : filename);
if (!GPG_IS_OK (gerr)) {
/* A special error value set by seahorse_key_op_photoid_add to
denote an invalid format file */
if (gerr == GPG_E (GPG_ERR_USER_1))
seahorse_util_show_error (NULL, _("Couldn’t add photo"),
_("The file could not be loaded. It may be in an invalid format"));
else
seahorse_gpgme_handle_error (gerr, _("Couldn’t add photo"));
res = FALSE;
}
g_free (filename);
if (tempfile) {
unlink (tempfile);
g_free (tempfile);
}
return res;
}
/* create the "add" dialog. */
void
add_folder_cb (GtkWidget *widget,
void *callback_data)
{
GtkWidget *file_sel;
DialogData *data;
GtkWidget *main_box;
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *align;
data = g_new0 (DialogData, 1);
data->settings = g_settings_new (EXRED_SCHEMA_ADD);
data->window = callback_data;
data->dialog = file_sel =
gtk_file_chooser_dialog_new (_("Add a Folder"),
GTK_WINDOW (data->window),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
FR_STOCK_ADD_FOLDER, GTK_RESPONSE_OK,
GTK_STOCK_HELP, GTK_RESPONSE_HELP,
NULL);
gtk_window_set_default_size (GTK_WINDOW (data->dialog), 530, 510);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (file_sel), FALSE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_sel), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG (file_sel), GTK_RESPONSE_OK);
data->add_if_newer_checkbutton = gtk_check_button_new_with_mnemonic (_("Add only if _newer"));
data->include_subfold_checkbutton = gtk_check_button_new_with_mnemonic (_("_Include subfolders"));
data->exclude_symlinks = gtk_check_button_new_with_mnemonic (_("Exclude folders that are symbolic lin_ks"));
data->include_files_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (data->include_files_entry, _("example: *.o; *.bak"));
data->include_files_label = gtk_label_new_with_mnemonic (_("Include _files:"));
gtk_misc_set_alignment (GTK_MISC (data->include_files_label), 0.0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (data->include_files_label), data->include_files_entry);
data->exclude_files_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (data->exclude_files_entry, _("example: *.o; *.bak"));
data->exclude_files_label = gtk_label_new_with_mnemonic (_("E_xclude files:"));
gtk_misc_set_alignment (GTK_MISC (data->exclude_files_label), 0.0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (data->exclude_files_label), data->exclude_files_entry);
data->exclude_folders_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (data->exclude_folders_entry, _("example: *.o; *.bak"));
data->exclude_folders_label = gtk_label_new_with_mnemonic (_("_Exclude folders:"));
gtk_misc_set_alignment (GTK_MISC (data->exclude_folders_label), 0.0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (data->exclude_folders_label), data->exclude_folders_entry);
data->load_button = gtk_button_new_with_mnemonic (_("_Load Options"));
data->save_button = gtk_button_new_with_mnemonic (_("Sa_ve Options"));
data->clear_button = gtk_button_new_with_mnemonic (_("_Reset Options"));
main_box = gtk_hbox_new (FALSE, 20);
gtk_container_set_border_width (GTK_CONTAINER (main_box), 0);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (file_sel), main_box);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
gtk_box_pack_start (GTK_BOX (main_box), vbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->include_subfold_checkbutton,
TRUE, TRUE, 0);
align = gtk_alignment_new (0, 0, 0, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, 12, 0);
gtk_container_add (GTK_CONTAINER (align), data->exclude_symlinks);
gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->add_if_newer_checkbutton,
TRUE, TRUE, 0);
table = gtk_table_new (2, 4, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_box_pack_start (GTK_BOX (vbox), table,
TRUE, TRUE, 0);
gtk_table_attach (GTK_TABLE (table),
data->include_files_label,
0, 1,
0, 1,
GTK_FILL, 0,
0, 0);
gtk_table_attach (GTK_TABLE (table),
data->include_files_entry,
1, 4,
0, 1,
GTK_FILL|GTK_EXPAND, 0,
0, 0);
gtk_table_attach (GTK_TABLE (table),
data->exclude_files_label,
0, 1,
1, 2,
GTK_FILL, 0,
0, 0);
gtk_table_attach (GTK_TABLE (table),
data->exclude_files_entry,
1, 2,
1, 2,
GTK_FILL|GTK_EXPAND, 0,
0, 0);
gtk_table_attach (GTK_TABLE (table),
data->exclude_folders_label,
2, 3,
1, 2,
GTK_FILL, 0,
0, 0);
gtk_table_attach (GTK_TABLE (table),
data->exclude_folders_entry,
3, 4,
1, 2,
GTK_FILL|GTK_EXPAND, 0,
0, 0);
/**/
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
gtk_box_pack_start (GTK_BOX (main_box), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->load_button,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->save_button,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->clear_button,
FALSE, FALSE, 0);
gtk_widget_show_all (main_box);
/* set data */
dlg_add_folder_load_last_options (data);
/* signals */
g_signal_connect (G_OBJECT (file_sel),
"destroy",
G_CALLBACK (open_file_destroy_cb),
data);
g_signal_connect (G_OBJECT (file_sel),
"response",
G_CALLBACK (file_sel_response_cb),
data);
g_signal_connect (G_OBJECT (data->include_subfold_checkbutton),
"toggled",
G_CALLBACK (include_subfold_toggled_cb),
data);
g_signal_connect (G_OBJECT (data->load_button),
"clicked",
G_CALLBACK (load_options_cb),
data);
g_signal_connect (G_OBJECT (data->save_button),
"clicked",
G_CALLBACK (save_options_cb),
data);
g_signal_connect (G_OBJECT (data->clear_button),
"clicked",
G_CALLBACK (clear_options_cb),
data);
gtk_window_set_modal (GTK_WINDOW (file_sel),TRUE);
gtk_widget_show (file_sel);
}
static void
dlg_extract__common (FrWindow *window,
GList *selected_files,
char *base_dir_for_selection)
{
DialogData *data;
data = g_new0 (DialogData, 1);
data->settings = g_settings_new (FILE_ROLLER_SCHEMA_EXTRACT);
data->window = window;
data->selected_files = selected_files;
data->base_dir_for_selection = base_dir_for_selection;
data->extract_clicked = FALSE;
data->dialog = gtk_file_chooser_dialog_new (C_("Window title", "Extract"),
GTK_WINDOW (data->window),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
_GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL,
_GTK_LABEL_EXTRACT, GTK_RESPONSE_OK,
NULL);
gtk_window_set_default_size (GTK_WINDOW (data->dialog), 530, 510);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (data->dialog), FALSE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (data->dialog), FALSE);
gtk_file_chooser_set_create_folders (GTK_FILE_CHOOSER (data->dialog), TRUE);
gtk_dialog_set_default_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK);
data->builder = _gtk_builder_new_from_resource ("extract-dialog-options.ui");
if (data->builder == NULL)
return;
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (data->dialog), GET_WIDGET ("extra_widget"));
/* Set widgets data. */
gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (data->dialog), fr_window_get_extract_default_dir (window), NULL);
if (data->selected_files != NULL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("selected_files_radiobutton")), TRUE);
else {
gtk_widget_set_sensitive (GET_WIDGET ("selected_files_radiobutton"), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("all_files_radiobutton")), TRUE);
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_newer_checkbutton")), g_settings_get_boolean (data->settings, PREF_EXTRACT_SKIP_NEWER));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_structure_checkbutton")), g_settings_get_boolean (data->settings, PREF_EXTRACT_RECREATE_FOLDERS));
/* Set the signals handlers. */
g_signal_connect (G_OBJECT (data->dialog),
"destroy",
G_CALLBACK (file_selector_destroy_cb),
data);
g_signal_connect (G_OBJECT (data->dialog),
"response",
G_CALLBACK (file_selector_response_cb),
data);
g_signal_connect (G_OBJECT (GET_WIDGET ("file_pattern_entry")),
"changed",
G_CALLBACK (files_entry_changed_cb),
data);
/* Run dialog. */
gtk_window_set_modal (GTK_WINDOW (data->dialog),TRUE);
gtk_widget_show (data->dialog);
}
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;
}
/* create the "add" dialog. */
void
add_files_cb (GtkWidget *widget,
void *callback_data)
{
GtkWidget *file_sel;
DialogData *data;
GtkWidget *main_box;
char *folder;
data = g_new0 (DialogData, 1);
data->window = callback_data;
data->settings = g_settings_new (FILE_ROLLER_SCHEMA_ADD);
data->dialog = file_sel =
gtk_file_chooser_dialog_new (_("Add Files"),
GTK_WINDOW (data->window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
FR_STOCK_ADD_FILES, GTK_RESPONSE_OK,
GTK_STOCK_HELP, GTK_RESPONSE_HELP,
NULL);
gtk_window_set_default_size (GTK_WINDOW (data->dialog), 530, 450);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (file_sel), TRUE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_sel), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG (file_sel), GTK_RESPONSE_OK);
/* Translators: add a file to the archive only if the disk version is
* newer than the archive version. */
data->add_if_newer_checkbutton = gtk_check_button_new_with_mnemonic (_("Add only if _newer"));
main_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 20);
gtk_container_set_border_width (GTK_CONTAINER (main_box), 0);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (file_sel), main_box);
gtk_box_pack_start (GTK_BOX (main_box), data->add_if_newer_checkbutton,
TRUE, TRUE, 0);
gtk_widget_show_all (main_box);
/* set data */
folder = g_settings_get_string (data->settings, PREF_ADD_CURRENT_FOLDER);
if ((folder == NULL) || (strcmp (folder, "") == 0))
folder = g_strdup (fr_window_get_add_default_dir (data->window));
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (file_sel), folder);
g_free (folder);
/* signals */
g_signal_connect (G_OBJECT (file_sel),
"destroy",
G_CALLBACK (open_file_destroy_cb),
data);
g_signal_connect (G_OBJECT (file_sel),
"response",
G_CALLBACK (file_sel_response_cb),
data);
gtk_window_set_modal (GTK_WINDOW (file_sel), TRUE);
gtk_widget_show (file_sel);
}
void Picture_Save_Button_Clicked (GObject *object)
{
GtkWidget *FileSelectionWindow;
GtkFileFilter *filter;
GtkWindow *parent_window = NULL;
static gchar *init_dir = NULL;
GtkTreeSelection *selection;
GList *selection_list = NULL;
GList *l;
GtkTreeModel *model;
gint selection_nbr, selection_i = 1;
g_return_if_fail (PictureEntryView != NULL);
parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object)));
if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window)))
{
g_warning("Could not get parent window\n");
return;
}
model = gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView));
selection_list = gtk_tree_selection_get_selected_rows(selection, NULL);
selection_nbr = gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(selection));
for (l = selection_list; l != NULL; l = g_list_next (l))
{
GtkTreePath *path = l->data;
GtkTreeIter iter;
Picture *pic;
gchar *title;
gboolean valid;
gint response;
// Get corresponding picture
valid = gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path);
if (valid)
gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, PICTURE_COLUMN_DATA, &pic, -1);
title = g_strdup_printf (_("Save Image %d/%d"), selection_i++,
selection_nbr);
FileSelectionWindow = gtk_file_chooser_dialog_new(title,
parent_window,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
g_free(title);
// Add files filters
// "All files" filter
filter = gtk_file_filter_new ();
gtk_file_filter_set_name(GTK_FILE_FILTER(filter), _("All Files"));
gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(FileSelectionWindow), GTK_FILE_FILTER(filter));
// "PNG and JPEG" filter
filter = gtk_file_filter_new ();
gtk_file_filter_set_name(GTK_FILE_FILTER(filter), _("PNG and JPEG"));
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filter), "image/jpeg");
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filter), "image/png");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (FileSelectionWindow), GTK_FILE_FILTER(filter));
// Make this filter the default
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(FileSelectionWindow), GTK_FILE_FILTER(filter));
// Set the default folder if defined
if (init_dir)
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow),init_dir);
// Suggest a filename to the user
if ( pic->description && strlen(pic->description) )
{
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(FileSelectionWindow), pic->description); //filename in UTF8
}else
{
gchar *image_name = NULL;
switch (Picture_Format_From_Data(pic))
{
case PICTURE_FORMAT_JPEG :
image_name = g_strdup("image_name.jpg");
break;
case PICTURE_FORMAT_PNG :
image_name = g_strdup("image_name.png");
break;
case PICTURE_FORMAT_UNKNOWN :
image_name = g_strdup("image_name.ext");
break;
}
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(FileSelectionWindow), image_name); //filename in UTF8
g_free(image_name);
}
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (FileSelectionWindow),
TRUE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (FileSelectionWindow),
FALSE);
response = gtk_dialog_run(GTK_DIALOG(FileSelectionWindow));
if (response == GTK_RESPONSE_OK)
{
GFile *file;
GError *error = NULL;
// Save the directory selected for initialize next time
g_free(init_dir);
init_dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow));
file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (FileSelectionWindow));
if (!et_picture_save_file_data (pic, file, &error))
{
Log_Print (LOG_ERROR, _("Image file not saved: %s"),
error->message);
g_error_free (error);
}
g_object_unref (file);
}
gtk_widget_destroy(FileSelectionWindow);
}
g_list_free_full (selection_list, (GDestroyNotify)gtk_tree_path_free);
}
/*
* To add a picture in the list -> call a FileSelectionWindow
*/
void Picture_Add_Button_Clicked (GObject *object)
{
GtkWidget *FileSelectionWindow;
GtkFileFilter *filter;
GtkWindow *parent_window = NULL;
static gchar *init_dir = NULL;
gint response;
g_return_if_fail (PictureEntryView != NULL);
parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object)));
if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window)))
{
g_warning("Could not get parent window\n");
return;
}
FileSelectionWindow = gtk_file_chooser_dialog_new(_("Add Images"),
parent_window,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK,
NULL);
// Add files filters
// "All files" filter
filter = gtk_file_filter_new ();
gtk_file_filter_set_name(GTK_FILE_FILTER(filter), _("All Files"));
gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(FileSelectionWindow), GTK_FILE_FILTER(filter));
// "PNG and JPEG" filter
filter = gtk_file_filter_new ();
gtk_file_filter_set_name(GTK_FILE_FILTER(filter), _("PNG and JPEG"));
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filter), "image/jpeg"); // Using mime type avoid problem of case sensitive with extensions
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filter), "image/png");
//gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*.jpeg"); // Warning: *.JPEG or *.JpEg files will not be displayed
//gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*.jpg");
//gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*.png");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (FileSelectionWindow), GTK_FILE_FILTER(filter));
// Make this filter the default
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(FileSelectionWindow), GTK_FILE_FILTER(filter));
// Behaviour following the tag type...
switch (ETCore->ETFileDisplayed->ETFileDescription->TagType)
{
case MP4_TAG:
{
// Only one file can be selected
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(FileSelectionWindow), FALSE);
break;
}
// Other tag types
default:
{
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(FileSelectionWindow), TRUE);
break;
}
}
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (FileSelectionWindow),
FALSE);
// Starting directory (the same of the current file)
if (ETCore->ETFileDisplayed)
{
gchar *cur_filename_utf8 = ((File_Name *)((GList *)ETCore->ETFileDisplayed->FileNameCur)->data)->value_utf8;
init_dir = g_path_get_dirname(cur_filename_utf8);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow),init_dir);
}else
// Starting directory (the same than the previous one)
if (init_dir)
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow),init_dir);
response = gtk_dialog_run(GTK_DIALOG(FileSelectionWindow));
if (response == GTK_RESPONSE_OK)
{
GtkTreeSelection *selection;
GSList *list;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView));
gtk_tree_selection_unselect_all(selection);
list = gtk_file_chooser_get_files (GTK_FILE_CHOOSER (FileSelectionWindow));
g_slist_foreach (list, (GFunc) et_picture_load_file, NULL);
g_slist_free_full (list, g_object_unref);
// Save the directory selected for initialize next time
g_free(init_dir);
init_dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow));
}
if (ETCore->ETFileDisplayed)
{
ET_Save_File_Data_From_UI (ETCore->ETFileDisplayed);
ET_Display_File_Data_To_UI (ETCore->ETFileDisplayed);
}
gtk_widget_destroy(FileSelectionWindow);
}
static void
dlg_extract__common (FrWindow *window,
GList *selected_files,
char *base_dir_for_selection)
{
DialogData *data;
GtkWidget *file_sel;
data = g_new0 (DialogData, 1);
data->settings = g_settings_new (ENGRAMPA_SCHEMA_EXTRACT);
data->window = window;
data->selected_files = selected_files;
data->base_dir_for_selection = base_dir_for_selection;
data->extract_clicked = FALSE;
data->dialog = file_sel =
gtk_file_chooser_dialog_new (_("Extract"),
GTK_WINDOW (data->window),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
FR_STOCK_EXTRACT, GTK_RESPONSE_OK,
GTK_STOCK_HELP, GTK_RESPONSE_HELP,
NULL);
gtk_window_set_default_size (GTK_WINDOW (file_sel), 530, 510);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (file_sel), FALSE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_sel), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG (file_sel), GTK_RESPONSE_OK);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (file_sel), create_extra_widget (data));
/* Set widgets data. */
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (file_sel), fr_window_get_extract_default_dir (window));
if (data->selected_files != NULL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_selected_radiobutton), TRUE);
else {
gtk_widget_set_sensitive (data->e_selected_radiobutton, FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_all_radiobutton), TRUE);
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_overwrite_checkbutton), g_settings_get_boolean (data->settings, PREF_EXTRACT_OVERWRITE));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton), g_settings_get_boolean (data->settings, PREF_EXTRACT_SKIP_NEWER));
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_overwrite_checkbutton))) {
gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton), TRUE);
gtk_widget_set_sensitive (data->e_not_newer_checkbutton, FALSE);
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_recreate_dir_checkbutton), g_settings_get_boolean (data->settings, PREF_EXTRACT_RECREATE_FOLDERS));
/* Set the signals handlers. */
g_signal_connect (G_OBJECT (data->dialog),
"destroy",
G_CALLBACK (destroy_cb),
data);
g_signal_connect (G_OBJECT (file_sel),
"response",
G_CALLBACK (file_sel_response_cb),
data);
g_signal_connect (G_OBJECT (data->e_overwrite_checkbutton),
"toggled",
G_CALLBACK (overwrite_toggled_cb),
data);
g_signal_connect (G_OBJECT (data->e_files_entry),
"changed",
G_CALLBACK (files_entry_changed_cb),
data);
/* Run dialog. */
gtk_window_set_modal (GTK_WINDOW (file_sel),TRUE);
gtk_widget_show (file_sel);
}
static char *
gtk_openfile( Bool open)
{
char *result = NULL;
struct MsgDlg message_dlg, **storage;
if ( gtk_dialog) return NULL; /* we're not reentrant */
gtk_dialog = gtk_file_chooser_dialog_new (
gtk_dialog_title_ptr ?
gtk_dialog_title_ptr :
( open ? "Open File" : "Save File"),
NULL,
open ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_local_only( GTK_FILE_CHOOSER (gtk_dialog), TRUE);
if (open)
gtk_file_chooser_set_select_multiple( GTK_FILE_CHOOSER (gtk_dialog), gtk_select_multiple);
#if GTK_MAJOR_VERSION >= 2 && GTK_MINOR_VERSION >= 8
gtk_file_chooser_set_do_overwrite_confirmation( GTK_FILE_CHOOSER (gtk_dialog), gtk_overwrite_prompt);
gtk_file_chooser_set_show_hidden( GTK_FILE_CHOOSER (gtk_dialog), gtk_show_hidden_files);
#endif
if ( gtk_current_folder_ptr)
gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER (gtk_dialog), gtk_current_folder_ptr);
if ( gtk_filters) {
int i;
for ( i = 0; i < gtk_filters-> count; i++) {
gtk_file_chooser_add_filter(
GTK_FILE_CHOOSER (gtk_dialog),
GTK_FILE_FILTER (gtk_filters-> items[i])
);
if ( i == gtk_filter_index)
gtk_file_chooser_set_filter(
GTK_FILE_CHOOSER (gtk_dialog),
GTK_FILE_FILTER (gtk_filters-> items[i])
);
}
}
/* lock prima interactions */
bzero( &message_dlg, sizeof(message_dlg));
storage = &guts. message_boxes;
while ( *storage) storage = &((*storage)-> next);
*storage = &message_dlg;
g_idle_add( do_events, NULL);
if (gtk_dialog_run (GTK_DIALOG (gtk_dialog)) == GTK_RESPONSE_ACCEPT) {
/* files */
if ( gtk_select_multiple) {
int size;
char * ptr;
GSList *names, *iter;
names = gtk_file_chooser_get_filenames ( GTK_FILE_CHOOSER (gtk_dialog));
/* count total length with escaped spaces and backslashes */
size = 1;
iter = names;
while ( iter) {
char * c = (char*) iter-> data;
while ( *c) {
if ( *c == ' ' || *c == '\\')
size++;
size++;
c++;
}
size++;
iter = iter-> next;
}
if (( result = ptr = malloc( size))) {
/* copy and encode */
iter = names;
while ( iter) {
char * c = (char*) iter-> data;
while ( *c) {
if ( *c == ' ' || *c == '\\')
*(ptr++) = '\\';
*(ptr++) = *c;
c++;
}
iter = iter-> next;
*(ptr++) = ' ';
}
*(ptr - 1) = 0;
} else {
warn("gtk_openfile: cannot allocate %d bytes of memory", size);
}
/* free */
iter = names;
while ( iter) {
g_free( iter-> data);
iter = iter-> next;
}
g_slist_free( names);
} else {
char * filename = gtk_file_chooser_get_filename ( GTK_FILE_CHOOSER (gtk_dialog));
result = duplicate_string( filename);
g_free (filename);
}
/* directory */
{
char * d = gtk_file_chooser_get_current_folder( GTK_FILE_CHOOSER (gtk_dialog));
if ( d) {
strncpy( gtk_current_folder, d, MAXPATHLEN);
gtk_current_folder_ptr = gtk_current_folder;
g_free( d);
} else {
gtk_current_folder_ptr = NULL;
}
}
/* filter index */
gtk_filter_index = 0;
if ( gtk_filters) {
int i;
Handle f = ( Handle) gtk_file_chooser_get_filter( GTK_FILE_CHOOSER (gtk_dialog));
for ( i = 0; i < gtk_filters-> count; i++)
if ( gtk_filters-> items[i] == f) {
gtk_filter_index = i;
break;
}
}
}
if ( gtk_filters) {
plist_destroy( gtk_filters);
gtk_filters = NULL;
}
*storage = message_dlg. next; /* unlock */
gtk_widget_destroy (gtk_dialog);
gtk_dialog = NULL;
while ( gtk_events_pending()) gtk_main_iteration();
return result;
}
/**
* e_shell_run_save_dialog:
* @shell: an #EShell
* @title: file chooser dialog title
* @suggestion: file name suggestion, or %NULL
* @filters: Possible filters for dialog, or %NULL
* @customize_func: optional dialog customization function
* @customize_data: optional data to pass to @customize_func
*
* Runs a #GtkFileChooserDialog in save mode with the given title and
* returns the selected #GFile. If @customize_func is provided, the
* function is called just prior to running the dialog (the file chooser
* is the first argument, @customize_data is the second). If the user
* cancels the dialog the function will return %NULL.
*
* With non-%NULL @filters will be added also file filters to the dialog.
* The string format is "pat1:mt1;pat2:mt2:...", where 'pat' is a pattern
* and 'mt' is a MIME type for the pattern to be used. There can be more
* than one MIME type, those are separated by comma.
*
* Returns: the #GFile to save to, or %NULL
**/
GFile *
e_shell_run_save_dialog (EShell *shell,
const gchar *title,
const gchar *suggestion,
const gchar *filters,
GtkCallback customize_func,
gpointer customize_data)
{
GtkFileChooser *file_chooser;
GFile *chosen_file = NULL;
GtkWidget *dialog;
GtkWindow *parent;
g_return_val_if_fail (E_IS_SHELL (shell), NULL);
parent = e_shell_get_active_window (shell);
dialog = gtk_file_chooser_dialog_new (
title, parent,
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_ACCEPT, NULL);
file_chooser = GTK_FILE_CHOOSER (dialog);
gtk_dialog_set_default_response (
GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
gtk_file_chooser_set_local_only (file_chooser, FALSE);
gtk_file_chooser_set_do_overwrite_confirmation (file_chooser, TRUE);
if (suggestion != NULL) {
gchar *current_name;
current_name = g_strdup (suggestion);
e_filename_make_safe (current_name);
gtk_file_chooser_set_current_name (file_chooser, current_name);
g_free (current_name);
}
if (filters != NULL) {
gchar **flts = g_strsplit (filters, ";", -1);
gint i;
for (i = 0; flts && flts[i]; i++) {
GtkFileFilter *filter = gtk_file_filter_new ();
gchar *flt = flts[i];
gchar *delim = strchr (flt, ':'), *next = NULL;
if (delim) {
*delim = 0;
next = strchr (delim + 1, ',');
}
gtk_file_filter_add_pattern (filter, flt);
if (g_ascii_strcasecmp (flt, "*.mbox") == 0)
gtk_file_filter_set_name (
filter, _("Berkeley Mailbox (mbox)"));
else if (g_ascii_strcasecmp (flt, "*.vcf") == 0)
gtk_file_filter_set_name (
filter, _("vCard (.vcf)"));
else if (g_ascii_strcasecmp (flt, "*.ics") == 0)
gtk_file_filter_set_name (
filter, _("iCalendar (.ics)"));
else
gtk_file_filter_set_name (filter, flt);
while (delim) {
delim++;
if (next)
*next = 0;
gtk_file_filter_add_mime_type (filter, delim);
delim = next;
if (next)
next = strchr (next + 1, ',');
}
gtk_file_chooser_add_filter (file_chooser, filter);
}
if (flts && flts[0]) {
GtkFileFilter *filter = gtk_file_filter_new ();
gtk_file_filter_add_pattern (filter, "*");
gtk_file_filter_set_name (filter, _("All Files (*)"));
gtk_file_chooser_add_filter (file_chooser, filter);
}
g_strfreev (flts);
}
/* Allow further customizations before running the dialog. */
if (customize_func != NULL)
customize_func (dialog, customize_data);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
chosen_file = gtk_file_chooser_get_file (file_chooser);
gtk_widget_destroy (dialog);
return chosen_file;
}
EAPMethodTTLS *
eap_method_ttls_new (const char *glade_file,
WirelessSecurity *parent,
NMConnection *connection)
{
EAPMethodTTLS *method;
GtkWidget *widget;
GladeXML *xml;
GtkFileFilter *filter;
NMSetting8021x *s_8021x = NULL;
const char *filename;
g_return_val_if_fail (glade_file != NULL, NULL);
xml = glade_xml_new (glade_file, "eap_ttls_notebook", NULL);
if (xml == NULL) {
g_warning ("Couldn't get eap_ttls_widget from glade xml");
return NULL;
}
widget = glade_xml_get_widget (xml, "eap_ttls_notebook");
g_assert (widget);
g_object_ref_sink (widget);
method = g_slice_new0 (EAPMethodTTLS);
if (!method) {
g_object_unref (xml);
g_object_unref (widget);
return NULL;
}
eap_method_init (EAP_METHOD (method),
validate,
add_to_size_group,
fill_connection,
destroy,
xml,
widget,
"eap_ttls_anon_identity_entry");
eap_method_nag_init (EAP_METHOD (method),
glade_file,
"eap_ttls_ca_cert_button",
connection);
method->sec_parent = parent;
if (connection)
s_8021x = NM_SETTING_802_1X (nm_connection_get_setting (connection, NM_TYPE_SETTING_802_1X));
widget = glade_xml_get_widget (xml, "eap_ttls_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,
parent);
filter = eap_method_default_file_chooser_filter_new (FALSE);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (widget), filter);
if (connection) {
filename = g_object_get_data (G_OBJECT (connection), NMA_PATH_CA_CERT_TAG);
if (filename)
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (widget), filename);
}
widget = glade_xml_get_widget (xml, "eap_ttls_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,
parent);
widget = inner_auth_combo_init (method, glade_file, connection, s_8021x);
inner_auth_combo_changed_cb (widget, (gpointer) method);
return method;
}
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;
}
void get_folder_to_play(GtkWidget *widget, gpointer user_data) {
/** User folder selection. **/
#ifdef DEBUG
DEBUG_FUNC_MARK
#endif
GtkWidget *folder_chooser_dialog = gtk_file_chooser_dialog_new("Choose a folder contains music files to listen.", NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "Cancel", GTK_RESPONSE_CANCEL, "Open", GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(folder_chooser_dialog), current_folder.c_str() ) ;
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(folder_chooser_dialog), FALSE) ;
gtk_file_chooser_set_create_folders(GTK_FILE_CHOOSER(folder_chooser_dialog), FALSE) ;
gtk_file_chooser_set_use_preview_label(GTK_FILE_CHOOSER(folder_chooser_dialog), TRUE) ;
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(folder_chooser_dialog), TRUE) ;
gtk_window_set_position(GTK_WINDOW(folder_chooser_dialog), GTK_WIN_POS_CENTER_ALWAYS) ;
gtk_widget_set_size_request(folder_chooser_dialog,-1,-1) ;
gtk_window_set_modal(GTK_WINDOW(folder_chooser_dialog), TRUE) ;
gtk_window_set_destroy_with_parent(GTK_WINDOW(folder_chooser_dialog), TRUE) ;
gtk_window_set_type_hint(GTK_WINDOW(folder_chooser_dialog), GDK_WINDOW_TYPE_HINT_DIALOG) ;
gtk_window_set_transient_for(GTK_WINDOW(folder_chooser_dialog), GTK_WINDOW(gui->window)) ;
gchar *folderpath = NULL ; // Selected folder.
gint result = gtk_dialog_run (GTK_DIALOG (folder_chooser_dialog));
switch (result) {
case GTK_RESPONSE_CANCEL :
if (! is_playing) {
gtk_button_set_label(GTK_BUTTON(gui->folder_chooser_button), "Select a folder to play content") ;
}
gtk_widget_destroy(folder_chooser_dialog);
return ;
case GTK_RESPONSE_ACCEPT :
folderpath = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(folder_chooser_dialog));
gtk_widget_destroy(folder_chooser_dialog);
break ;
}
parse_folder(folderpath) ;
gchar *dirname = g_path_get_dirname(folderpath) ;
current_folder = dirname ;
g_free(dirname) ;
#ifdef DEBUG
fprintf(stdout,"%s current_folder: %s\n", __func__, current_folder.c_str() ) ;
#endif
g_free(folderpath) ;
}
static void
cc_sharing_panel_add_folder (GtkListBox *box,
GtkListBoxRow *row,
CcSharingPanel *self)
{
CcSharingPanelPrivate *priv = self->priv;
GtkWidget *dialog;
gchar *folder = NULL;
gboolean matching = FALSE;
GList *rows, *l;
if (!GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row), "is-add")))
return;
dialog = gtk_file_chooser_dialog_new (_("Choose a Folder"),
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (box))),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), FALSE);
if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_ACCEPT)
goto bail;
gtk_widget_hide (dialog);
box = GTK_LIST_BOX (WID ("shared-folders-listbox"));
rows = gtk_container_get_children (GTK_CONTAINER (box));
folder = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog));
if (!folder || g_str_equal (folder, ""))
goto bail;
g_debug ("Trying to add %s", folder);
for (l = rows; l != NULL; l = l->next)
{
const char *string;
string = g_object_get_data (G_OBJECT (l->data), "path");
matching = (g_strcmp0 (string, folder) == 0);
if (matching)
{
g_debug ("Found a duplicate for %s", folder);
break;
}
}
if (!matching)
{
GtkWidget *row;
int i;
row = cc_sharing_panel_new_media_sharing_row (folder, self);
i = g_list_length (rows);
gtk_list_box_insert (GTK_LIST_BOX (box), row, i - 1);
}
cc_list_box_adjust_scrolling (GTK_LIST_BOX (box));
bail:
g_free (folder);
gtk_widget_destroy (dialog);
}
