/** Callback for a 'Clear' button for GtkFileChooserButton widget.
*
* @internal
*
* @param button A pointer to the button widget emitting signal.
*
* @param user_data A Pointer to the GtkFileChooserButton widget.
*/
static void
file_chooser_clear_cb (GtkButton *button, gpointer user_data)
{
GtkFileChooserButton *fcb = GTK_FILE_CHOOSER_BUTTON(user_data);
const gchar *group = g_object_get_data (G_OBJECT(fcb), "group");
const gchar *pref = g_object_get_data (G_OBJECT(fcb), "pref");
GtkImage *image = g_object_get_data (G_OBJECT(fcb), "path_head_error");
GtkWidget *box;
GtkWidget *fcb_new;
gchar *boxname;
/* We need to distroy the GtkFileChooserButton and recreate as there
does not seem to be away of resetting the folder path to NONE */
box = gtk_widget_get_parent (GTK_WIDGET(fcb));
gtk_widget_destroy (GTK_WIDGET(fcb));
if (!gnc_prefs_set_string (group, pref, ""))
PINFO("Failed to Clear preference at %s, %s", group, pref);
fcb_new = gtk_file_chooser_button_new (_("Select a folder"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
g_object_set_data (G_OBJECT(fcb_new), "path_head_error", image);
gtk_box_pack_start (GTK_BOX (box), fcb_new, TRUE, TRUE, 0);
gtk_box_reorder_child (GTK_BOX (box),fcb_new, 0);
gtk_widget_show (fcb_new);
boxname = g_strconcat ("pref/", group, "/", pref, NULL);
gnc_prefs_connect_file_chooser_button (GTK_FILE_CHOOSER_BUTTON(fcb_new), boxname);
g_free (boxname);
}
static int title_member(lua_State *L)
{
lua_file_chooser_button file_chooser_button;
luaA_to(L,lua_file_chooser_button,&file_chooser_button,1);
if(lua_gettop(L) > 2) {
const char * title = luaL_checkstring(L,3);
gtk_file_chooser_button_set_title(GTK_FILE_CHOOSER_BUTTON(file_chooser_button->parent.widget),title);
return 0;
}
lua_pushstring(L,gtk_file_chooser_button_get_title(GTK_FILE_CHOOSER_BUTTON(file_chooser_button->parent.widget)));
return 1;
}
static GtkWidget* remmina_init_dialog_create_file_button(GtkWidget *table, const gchar *label, gint row, const gchar *filename)
{
GtkWidget *widget;
gchar *pkidir;
widget = gtk_label_new(label);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_widget_show(widget);
remmina_init_dialog_attach(table, widget, 0, row, 1, 1);
widget = gtk_file_chooser_button_new(label, GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_file_chooser_button_set_width_chars(GTK_FILE_CHOOSER_BUTTON(widget), 25);
gtk_widget_show(widget);
remmina_init_dialog_attach(table, widget, 1, row, 2, 1);
if (filename && filename[0] != '\0')
{
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(widget), filename);
}
else
{
pkidir = g_strdup_printf("%s/.pki", g_get_home_dir());
if (g_file_test(pkidir, G_FILE_TEST_IS_DIR))
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(widget), pkidir);
}
g_free(pkidir);
}
return widget;
}
static GtkWidget *xml_file_selector(GtkWidget *vbox, GtkWidget *main_dialog)
{
GtkWidget *hbox, *frame, *chooser, *dialog;
GtkFileFilter *filter;
hbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
frame = gtk_frame_new("XML file name");
gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, TRUE, 3);
dialog = gtk_file_chooser_dialog_new("Open XML File",
GTK_WINDOW(main_window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), FALSE);
filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter, "*.xml");
gtk_file_filter_add_pattern(filter, "*.XML");
gtk_file_filter_add_pattern(filter, "*.sda");
gtk_file_filter_add_pattern(filter, "*.SDA");
gtk_file_filter_add_mime_type(filter, "text/xml");
gtk_file_filter_set_name(filter, "XML file");
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
chooser = gtk_file_chooser_button_new_with_dialog(dialog);
g_signal_connect(G_OBJECT(chooser), "file-set", G_CALLBACK(on_file_set), main_dialog);
gtk_file_chooser_button_set_width_chars(GTK_FILE_CHOOSER_BUTTON(chooser), 30);
gtk_container_add(GTK_CONTAINER(frame), chooser);
return chooser;
}
static void
GetFileChooserButton(
GtkWidget *widget,
_FileChooserButton *data)
{
GtkFileChooserButton *fcb;
GError *error = NULL;
gchar *contents;
gchar *fname;
gsize size;
gchar *folder;
char *longname;
ENTER_FUNC;
fcb = GTK_FILE_CHOOSER_BUTTON(widget);
fname = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fcb));
if (fname == NULL) {
data->filename = NULL;
return;
}
data->filename = g_path_get_basename(fname);
if(!g_file_get_contents(fname,
&contents, &size, &error)) {
g_error_free(error);
return;
}
data->binary->body = contents;
data->binary->size = data->binary->asize = data->binary->ptr = size;
longname = (char *)glade_get_widget_long_name(widget);
folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(fcb));
if (folder != NULL) {
SetWidgetCache(longname,folder);
g_free(folder);
}
LEAVE_FUNC;
}
static void
setup_filepicker (GladeXML *xml,
const char *name,
const char *title,
WirelessSecurity *parent,
EAPMethodTLS *method,
NMConnection *connection,
const char *tag)
{
GtkWidget *widget;
GtkFileFilter *filter;
const char *filename = NULL;
gboolean privkey = FALSE, client_cert = FALSE;
if (!strcmp (tag, NMA_PATH_PHASE2_PRIVATE_KEY_TAG) || !strcmp (tag, NMA_PATH_PRIVATE_KEY_TAG))
privkey = TRUE;
if (!strcmp (tag, NMA_PATH_PHASE2_CLIENT_CERT_TAG) || !strcmp (tag, NMA_PATH_CLIENT_CERT_TAG))
client_cert = TRUE;
widget = glade_xml_get_widget (xml, name);
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), title);
if (connection && tag) {
filename = g_object_get_data (G_OBJECT (connection), tag);
if (filename)
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (widget), filename);
}
/* Connect a special handler for private keys to intercept PKCS#12 key types
* and desensitize the user cert button.
*/
if (privkey) {
g_signal_connect (G_OBJECT (widget), "selection-changed",
(GCallback) private_key_picker_file_set_cb,
method);
if (filename)
private_key_picker_helper ((EAPMethod *) method, filename, FALSE);
}
g_signal_connect (G_OBJECT (widget), "selection-changed",
(GCallback) wireless_security_changed_cb,
parent);
filter = eap_method_default_file_chooser_filter_new (privkey);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (widget), filter);
/* For some reason, GTK+ calls set_current_filter (..., NULL) from
* gtkfilechooserdefault.c::show_and_select_files_finished_loading() on our
* dialog; so force-reset the filter to what we want it to be whenever
* it gets cleared.
*/
if (client_cert)
g_signal_connect (G_OBJECT (widget), "notify::filter", (GCallback) reset_filter, filter);
}
static void
setup_filepicker (GtkBuilder *builder,
const char *name,
const char *title,
WirelessSecurity *ws_parent,
EAPMethod *parent,
NMSetting8021x *s_8021x,
SchemeFunc scheme_func,
PathFunc path_func,
gboolean privkey,
gboolean client_cert)
{
GtkWidget *widget;
GtkFileFilter *filter;
const char *filename = NULL;
widget = GTK_WIDGET (gtk_builder_get_object (builder, name));
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), title);
if (s_8021x && path_func && scheme_func) {
if (scheme_func (s_8021x) == NM_SETTING_802_1X_CK_SCHEME_PATH) {
filename = path_func (s_8021x);
if (filename)
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (widget), filename);
}
}
/* Connect a special handler for private keys to intercept PKCS#12 key types
* and desensitize the user cert button.
*/
if (privkey) {
g_signal_connect (G_OBJECT (widget), "selection-changed",
(GCallback) private_key_picker_file_set_cb,
parent);
if (filename)
private_key_picker_helper (parent, filename, FALSE);
}
g_signal_connect (G_OBJECT (widget), "selection-changed",
(GCallback) wireless_security_changed_cb,
ws_parent);
filter = eap_method_default_file_chooser_filter_new (privkey);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (widget), filter);
/* For some reason, GTK+ calls set_current_filter (..., NULL) from
* gtkfilechooserdefault.c::show_and_select_files_finished_loading() on our
* dialog; so force-reset the filter to what we want it to be whenever
* it gets cleared.
*/
if (client_cert)
g_signal_connect (G_OBJECT (widget), "notify::filter", (GCallback) reset_filter, filter);
}
SettingItem * register_img_file_setting(GtkWidget * widget, gchar * section, gchar * key, GtkImage * image)
{
SettingItem * item = register_setting(widget,ST_IMG_FILE,section,key);
gtk_file_chooser_button_set_width_chars(GTK_FILE_CHOOSER_BUTTON(widget),0);
item->image = image;
item->preview = GTK_IMAGE(gtk_image_new());
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(widget),GTK_WIDGET(item->preview));
g_signal_connect(widget,"update-preview",G_CALLBACK(update_preview_cb),
item->preview);
return item;
}
static void
SetFileChooserButton(
GtkWidget *widget,
WidgetData *wdata,
_FileChooserButton *data)
{
GtkFileChooserButton *fcb;
gchar *folder;
char *longname;
ENTER_FUNC;
SetCommon(widget,wdata);
fcb = GTK_FILE_CHOOSER_BUTTON(widget);
gtk_file_chooser_unselect_all(GTK_FILE_CHOOSER(fcb));
longname = (char *)glade_get_widget_long_name(widget);
folder = GetWidgetCache(longname);
if (folder == NULL) {
folder = "";
}
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fcb),folder);
_AddChangedWidget(widget);
LEAVE_FUNC;
}
void termit_preferences_dialog(struct TermitTab *pTab)
{
// store font_name, foreground, background
struct TermitDlgHelper* hlp = termit_dlg_helper_new(pTab);
GtkStockItem item = {};
gtk_stock_lookup(GTK_STOCK_PREFERENCES, &item); // may be memory leak inside
GtkWidget* dialog = gtk_dialog_new_with_buttons(item.label,
GTK_WINDOW_TOPLEVEL,
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_NONE,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_signal_connect(G_OBJECT(dialog), "key-press-event", G_CALLBACK(dlg_key_press), dialog);
GtkWidget* dlg_table = gtk_table_new(5, 2, FALSE);
#define TERMIT_PREFERENCE_ROW(pref_name, widget) \
gtk_table_attach(GTK_TABLE(dlg_table), gtk_label_new(pref_name), 0, 1, row, row + 1, 0, 0, 0, 0); \
gtk_table_attach_defaults(GTK_TABLE(dlg_table), widget, 1, 2, row, row + 1); \
hlp->widget = widget; \
row++;
#define TERMIT_PREFERENCE_ROW2(pref_widget, widget) \
gtk_table_attach(GTK_TABLE(dlg_table), pref_widget, 0, 1, row, row + 1, 0, 0, 0, 0); \
gtk_table_attach_defaults(GTK_TABLE(dlg_table), widget, 1, 2, row, row + 1); \
hlp->widget = widget; \
row++;
gboolean apply_to_all_tabs_flag = FALSE;
GtkWidget* entry_title = gtk_entry_new();
guint row = 0;
{ // tab title
gtk_entry_set_text(GTK_ENTRY(entry_title), hlp->tab_title);
TERMIT_PREFERENCE_ROW(_("Title"), entry_title);
}
// font selection
GtkWidget* btn_font = gtk_font_button_new_with_font(pTab->style.font_name);
g_signal_connect(btn_font, "font-set", G_CALLBACK(dlg_set_font), pTab);
TERMIT_PREFERENCE_ROW(_("Font"), btn_font);
// foreground
GtkWidget* btn_foreground = (pTab->style.foreground_color)
? gtk_color_button_new_with_color(pTab->style.foreground_color)
: gtk_color_button_new();
g_signal_connect(btn_foreground, "color-set", G_CALLBACK(dlg_set_foreground), pTab);
TERMIT_PREFERENCE_ROW(_("Foreground"), btn_foreground);
// background
GtkWidget* btn_background = (pTab->style.background_color)
? gtk_color_button_new_with_color(pTab->style.background_color)
: gtk_color_button_new();
g_signal_connect(btn_background, "color-set", G_CALLBACK(dlg_set_background), pTab);
TERMIT_PREFERENCE_ROW(_("Background"), btn_background);
// background image
GtkWidget* btn_image_file = gtk_file_chooser_button_new(pTab->style.image_file,
GTK_FILE_CHOOSER_ACTION_OPEN);
GtkFileFilter* filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, _("images"));
gtk_file_filter_add_mime_type(filter, "image/*");
if (pTab->style.image_file) {
gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(btn_image_file), pTab->style.image_file);
}
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(btn_image_file), filter);
g_signal_connect(btn_image_file, "file-set", G_CALLBACK(dlg_set_image_file), pTab);
g_signal_connect(btn_image_file, "key-press-event", G_CALLBACK(dlg_clear_image_file), pTab);
GtkWidget* btn_switch_image_file = gtk_check_button_new_with_label(_("Background image"));
if (pTab->style.image_file) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn_switch_image_file), TRUE);
}
/*g_signal_connect(btn_switch_image_file, "toggled", G_CALLBACK(dlg_switch_image_file), btn_image_file);*/
/*TERMIT_PREFERENCE_ROW2(btn_switch_image_file, btn_image_file);*/
TERMIT_PREFERENCE_ROW(_("Image"), btn_image_file);
// transparency
GtkWidget* scale_transparency = gtk_spin_button_new_with_range(0, 1, 0.05);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(scale_transparency), pTab->style.transparency);
g_signal_connect(scale_transparency, "value-changed", G_CALLBACK(dlg_set_transparency), pTab);
TERMIT_PREFERENCE_ROW(_("Transparency"), scale_transparency);
// audible_bell
GtkWidget* audible_bell = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(audible_bell), pTab->audible_bell);
g_signal_connect(audible_bell, "toggled", G_CALLBACK(dlg_set_audible_bell), pTab);
TERMIT_PREFERENCE_ROW(_("Audible bell"), audible_bell);
// visible_bell
GtkWidget* visible_bell = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(visible_bell), pTab->visible_bell);
g_signal_connect(visible_bell, "toggled", G_CALLBACK(dlg_set_visible_bell), pTab);
TERMIT_PREFERENCE_ROW(_("Visible bell"), visible_bell);
// apply to al tabs
GtkWidget* btn_apply_to_all_tabs = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn_apply_to_all_tabs), FALSE);
g_signal_connect(btn_apply_to_all_tabs, "toggled", G_CALLBACK(dlg_set_apply_to_all_tabs), &apply_to_all_tabs_flag);
TERMIT_PREFERENCE_ROW(_("Apply to all tabs"), btn_apply_to_all_tabs);
GtkWidget* btn_restore = gtk_button_new_from_stock(GTK_STOCK_REVERT_TO_SAVED);
g_signal_connect(G_OBJECT(btn_restore), "clicked", G_CALLBACK(dlg_restore_defaults), hlp);
gtk_table_attach(GTK_TABLE(dlg_table), btn_restore, 1, 2, row, row + 1, 0, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), dlg_table);
gtk_widget_show_all(dialog);
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
dlg_set_tab_default_values(pTab, hlp);
} else {
if (apply_to_all_tabs_flag) {
gint page_num = gtk_notebook_get_n_pages(GTK_NOTEBOOK(termit.notebook));
gint i=0;
for (; i<page_num; ++i) {
TERMIT_GET_TAB_BY_INDEX(pTab, i, continue);
dlg_set_font(GTK_FONT_BUTTON(btn_font), pTab);
dlg_set_foreground(GTK_COLOR_BUTTON(btn_foreground), pTab);
dlg_set_background(GTK_COLOR_BUTTON(btn_background), pTab);
dlg_set_transparency(GTK_SPIN_BUTTON(scale_transparency), pTab);
dlg_set_image_file(GTK_FILE_CHOOSER_BUTTON(btn_image_file), pTab);
dlg_set_audible_bell(GTK_TOGGLE_BUTTON(audible_bell), pTab);
dlg_set_visible_bell(GTK_TOGGLE_BUTTON(visible_bell), pTab);
}
}
// insane title flag
if (pTab->title ||
(!pTab->title &&
strcmp(gtk_label_get_text(GTK_LABEL(pTab->tab_name)),
gtk_entry_get_text(GTK_ENTRY(entry_title))) != 0)) {
termit_tab_set_title(pTab, gtk_entry_get_text(GTK_ENTRY(entry_title)));
}
}
termit_dlg_helper_free(hlp);
gtk_widget_destroy(dialog);
}
EAPMethodTTLS *
eap_method_ttls_new (WirelessSecurity *ws_parent,
NMConnection *connection,
gboolean is_editor,
gboolean secrets_only)
{
EAPMethod *parent;
EAPMethodTTLS *method;
GtkWidget *widget;
GtkFileFilter *filter;
NMSetting8021x *s_8021x = NULL;
const char *filename;
parent = eap_method_init (sizeof (EAPMethodTTLS),
validate,
add_to_size_group,
fill_connection,
update_secrets,
destroy,
UIDIR "/eap-method-ttls.ui",
"eap_ttls_notebook",
"eap_ttls_anon_identity_entry",
FALSE);
if (!parent)
return NULL;
eap_method_nag_init (parent, "eap_ttls_ca_cert_button", connection);
method = (EAPMethodTTLS *) 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_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,
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) {
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);
}
}
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "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,
ws_parent);
widget = inner_auth_combo_init (method, connection, s_8021x, secrets_only);
inner_auth_combo_changed_cb (widget, (gpointer) method);
if (secrets_only) {
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_ttls_anon_identity_label"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_ttls_anon_identity_entry"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_ttls_ca_cert_label"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_ttls_ca_cert_button"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_ttls_inner_auth_label"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_ttls_inner_auth_combo"));
gtk_widget_hide (widget);
}
return method;
}
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;
}
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/freedesktop/network-manager-applet/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;
}
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);
}
}
void configure_program_dialog(GtkWidget *widget, gpointer user_data) {
/** Program configuration dailog window. **/
#ifdef DEBUG
DEBUG_FUNC_MARK
#endif
GtkWidget *configure_dialog = gtk_dialog_new() ;
gtk_window_set_icon_from_file(GTK_WINDOW(configure_dialog), PATH_TO_PRG_WIN_ICON, NULL) ;
gtk_window_set_title(GTK_WINDOW(configure_dialog), "Configure program") ;
gtk_window_set_position(GTK_WINDOW(configure_dialog), GTK_WIN_POS_CENTER_ALWAYS) ;
gtk_window_set_resizable(GTK_WINDOW(configure_dialog), FALSE);
gtk_widget_set_size_request(configure_dialog,-1,-1) ;
gtk_window_set_modal(GTK_WINDOW(configure_dialog), FALSE) ;
gtk_window_set_destroy_with_parent(GTK_WINDOW(configure_dialog), TRUE) ;
gtk_window_set_decorated(GTK_WINDOW(configure_dialog), TRUE) ;
gtk_window_set_type_hint(GTK_WINDOW(configure_dialog), GDK_WINDOW_TYPE_HINT_NORMAL) ;
gtk_window_set_transient_for(GTK_WINDOW(configure_dialog), GTK_WINDOW(gui->window)) ;
gtk_container_set_border_width(GTK_CONTAINER(configure_dialog), 12) ;
#define DIALOG_DEFAULT_SPACE 12
/** ***** [START] Icon set choice [START] ***** **/
GtkWidget *icon_set_choice_frame = gtk_frame_new(" Icon set ") ;
GtkWidget *icon_set_choice_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;
gtk_container_set_border_width(GTK_CONTAINER(icon_set_choice_hbox), DIALOG_DEFAULT_SPACE) ;
gtk_box_set_spacing(GTK_BOX(icon_set_choice_hbox), DIALOG_DEFAULT_SPACE) ;
gtk_box_set_homogeneous(GTK_BOX(icon_set_choice_hbox), TRUE) ;
GtkWidget *radiobutton_icons_high_contrast = gtk_radio_button_new_with_label(NULL, " HighContrast") ;
GtkWidget *image_icons_high_contrast ;
GtkWidget *radiobutton_icons_oxygen = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_icons_high_contrast)), " Oxygen") ;
GtkWidget *image_icons_oxygen ;
gtk_widget_set_tooltip_markup(radiobutton_icons_high_contrast, "Set the <b>HighContrast</b> theme icon set.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_widget_set_tooltip_markup(radiobutton_icons_oxygen, "Set the <b>Oxygen</b> theme icon set.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(radiobutton_icons_high_contrast), FALSE) ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(radiobutton_icons_oxygen), FALSE) ;
if (settings.icon_set_oxygen) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_icons_oxygen), TRUE) ;
image_icons_high_contrast = gtk_image_new_from_file( PATH_TO_HIGH_CONTRAST_BUTTON_ICONS "face-angry.png") ;
image_icons_oxygen = gtk_image_new_from_file( PATH_TO_OXYGEN_BUTTON_ICONS "face-smile-big.png") ;
}
else {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_icons_high_contrast), TRUE) ;
image_icons_high_contrast = gtk_image_new_from_file( PATH_TO_HIGH_CONTRAST_BUTTON_ICONS "face-smile-big.png") ;
image_icons_oxygen = gtk_image_new_from_file( PATH_TO_OXYGEN_BUTTON_ICONS "face-angry.png") ;
}
gtk_button_set_image(GTK_BUTTON(radiobutton_icons_high_contrast), image_icons_high_contrast) ;
gtk_button_set_always_show_image(GTK_BUTTON(radiobutton_icons_high_contrast), TRUE) ;
gtk_button_set_image(GTK_BUTTON(radiobutton_icons_oxygen), image_icons_oxygen) ;
gtk_button_set_always_show_image(GTK_BUTTON(radiobutton_icons_oxygen), TRUE) ;
gtk_box_pack_start(GTK_BOX(icon_set_choice_hbox), radiobutton_icons_high_contrast, TRUE, TRUE, 0) ;
gtk_box_pack_start(GTK_BOX(icon_set_choice_hbox), radiobutton_icons_oxygen, TRUE, TRUE, 0) ;
gtk_container_add(GTK_CONTAINER(icon_set_choice_frame), icon_set_choice_hbox) ;
/** ***** [END] Icon set choice [END] ***** **/
/** ***** [START] Playing settings [START] ***** **/
GtkWidget *playing_settings_frame = gtk_frame_new(" Player settings ") ;
GtkWidget *playing_settings_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0) ;
gtk_container_set_border_width(GTK_CONTAINER(playing_settings_vbox), DIALOG_DEFAULT_SPACE) ;
GtkWidget *playing_settings_repeat_all = gtk_check_button_new_with_label(" Repeat all mode. ") ;
gtk_widget_set_tooltip_markup(playing_settings_repeat_all, "Enable the <b>repeat all</b> feature.\nThis will update the player settings.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(playing_settings_repeat_all), is_repeat_all) ;
GtkWidget *playing_settings_shuffle = gtk_check_button_new_with_label(" Shuffle mode. ") ;
gtk_widget_set_tooltip_markup(playing_settings_shuffle, "Enable the <b>shuffle</b> feature.\nThis will update the player settings.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(playing_settings_shuffle), is_shuffle ) ;
GtkWidget *playing_settings_volume_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;
GtkWidget *playing_settings_volume_label_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;
GtkWidget *playing_settings_volume_image = gtk_image_new_from_file( (settings.path_to_button_icons + "audio-volume-medium.png").c_str() ) ;
GtkWidget *playing_settings_volume_label = gtk_label_new(" Default Volume:") ;
gtk_box_pack_start(GTK_BOX(playing_settings_volume_label_hbox), playing_settings_volume_image, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_volume_label_hbox), playing_settings_volume_label, FALSE, FALSE, 0) ;
GtkWidget *playing_settings_volume_scale = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0.0, 100.0, 1.0) ;
gtk_widget_set_tooltip_markup(playing_settings_volume_scale, "Set the <b>default player volume</b> at start.\nThis will <b>not</b> update the player settings.\nYou must press the <b>Apply</b> button to store your configuration.") ;
gtk_range_set_value(GTK_RANGE(playing_settings_volume_scale), settings.volume) ;
gtk_scale_set_draw_value(GTK_SCALE(playing_settings_volume_scale), TRUE) ;
gtk_scale_set_has_origin(GTK_SCALE(playing_settings_volume_scale), TRUE) ;
gtk_scale_set_value_pos(GTK_SCALE(playing_settings_volume_scale), GTK_POS_TOP) ;
gtk_scale_add_mark(GTK_SCALE(playing_settings_volume_scale), 50.0, GTK_POS_TOP, NULL) ;
gtk_box_pack_start(GTK_BOX(playing_settings_volume_hbox), playing_settings_volume_label_hbox, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_volume_hbox), playing_settings_volume_scale, TRUE, TRUE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_repeat_all, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_shuffle, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_volume_hbox, FALSE, FALSE, 0) ;
gtk_container_add(GTK_CONTAINER(playing_settings_frame), playing_settings_vbox) ;
/** ***** [END] Playing settings [END] ***** **/
/** ***** [START] Interface size setting [START] ***** **/
GtkWidget *interface_size_frame = gtk_frame_new(" Interface size ") ;
GtkWidget *interface_size_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;
gtk_container_set_border_width(GTK_CONTAINER(interface_size_hbox), DIALOG_DEFAULT_SPACE) ;
GtkWidget *interface_size_radiobutton_little = gtk_radio_button_new_with_label(NULL, " Little") ;
GtkWidget *interface_size_radiobutton_middle = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(interface_size_radiobutton_little)), " Medium") ;
GtkWidget *interface_size_radiobutton_big = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(interface_size_radiobutton_little)), " Big ") ;
GtkWidget *interface_size_little_image = gtk_image_new_from_file((settings.path_to_button_icons + "interface-little.png").c_str() ) ;
GtkWidget *interface_size_middle_image = gtk_image_new_from_file((settings.path_to_button_icons + "interface-middle.png").c_str() ) ;
GtkWidget *interface_size_big_image = gtk_image_new_from_file((settings.path_to_button_icons + "interface-big.png").c_str() ) ;
gtk_widget_set_tooltip_markup(interface_size_radiobutton_little, "Set the <b>interface size</b> on <b>little</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_widget_set_tooltip_markup(interface_size_radiobutton_middle, "Set the <b>interface size</b> on <b>middle</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_widget_set_tooltip_markup(interface_size_radiobutton_big, "Set the <b>interface size</b> on <b>big</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_little), interface_size_little_image) ;
gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_middle), interface_size_middle_image) ;
gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_big), interface_size_big_image ) ;
gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_little), TRUE) ;
gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_middle), TRUE) ;
gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_big), TRUE) ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_little), FALSE) ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_middle), FALSE) ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_big), FALSE) ;
switch (settings.image_resized_size) {
case IMAGE_RESIZED_SIZE_LITTLE :
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_little), TRUE) ;
break ;
case IMAGE_RESIZED_SIZE_MIDDLE :
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_middle), TRUE) ;
break ;
case IMAGE_RESIZED_SIZE_BIG :
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_big), TRUE) ;
break ;
default :
break ;
}
gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_little, TRUE, TRUE, 0) ;
gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_middle, TRUE, TRUE, 0) ;
gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_big, TRUE, TRUE, 0) ;
gtk_box_set_homogeneous(GTK_BOX(interface_size_hbox), TRUE) ;
gtk_box_set_spacing(GTK_BOX(interface_size_hbox), DIALOG_DEFAULT_SPACE) ;
gtk_container_add(GTK_CONTAINER(interface_size_frame), interface_size_hbox) ;
/** ***** [END] Interface size setting [END] ***** **/
/** ***** [START] Music folder setting [START] ***** **/
GtkWidget *folder_selecting_frame = gtk_frame_new(" Music folder ") ;
GtkWidget *folder_selecting_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0) ;
gtk_container_set_border_width(GTK_CONTAINER(folder_selecting_box), DIALOG_DEFAULT_SPACE) ;
GtkWidget *folder_selecting_button = gtk_file_chooser_button_new("Set the Music folder to open per default.", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) ;
gtk_widget_set_tooltip_markup(folder_selecting_button, "Set the folder to open per default: your <b>default music folder</b>.\n<i>The default folder from the folder selector</i>.\nSet it simply to your <b>Music folder</b>.\nChanges are immediatly applied.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_file_chooser_button_set_title(GTK_FILE_CHOOSER_BUTTON(folder_selecting_button), "Set the Music folder to open per default.") ;
const char *user_music_folder = g_get_user_special_dir(G_USER_DIRECTORY_MUSIC) ;
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(folder_selecting_button), (g_file_test(settings.path_to_music_folder.c_str(), G_FILE_TEST_IS_DIR)) ? settings.path_to_music_folder.c_str() : (user_music_folder != NULL) ? user_music_folder : g_get_home_dir() ) ;
gtk_box_pack_start(GTK_BOX(folder_selecting_box), folder_selecting_button, TRUE, TRUE, 0) ;
gtk_container_add(GTK_CONTAINER(folder_selecting_frame), folder_selecting_box) ;
/** ***** [END] Music folder setting [END] ***** **/
/** ***** [START] Dialog main content box [START] ***** **/
GtkWidget *content_area = gtk_dialog_get_content_area( GTK_DIALOG(configure_dialog) ) ;
gtk_box_pack_start(GTK_BOX(content_area), icon_set_choice_frame, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(content_area), playing_settings_frame, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(content_area), interface_size_frame, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(content_area), folder_selecting_frame, FALSE, FALSE, 0) ;
gtk_box_set_spacing(GTK_BOX(content_area), DIALOG_DEFAULT_SPACE) ;
/** ***** [END] Dialog main content box [END] ***** **/
/** ***** [START] Dialog action buttons [START] ***** **/
GtkWidget *button_close = gtk_button_new_with_label("Close") ; // gtk_dialog_add_button(GTK_DIALOG(configure_dialog), "Cancel", GTK_RESPONSE_CANCEL) ;
GtkWidget *image_close = gtk_image_new_from_file((settings.path_to_button_icons + "dialog-close.png").c_str()) ;
gtk_widget_set_tooltip_markup(button_close, "<b>Close</b> the configuration window and don't store any setting.") ;
gtk_button_set_image(GTK_BUTTON(button_close), image_close) ;
gtk_button_set_always_show_image(GTK_BUTTON(button_close), TRUE) ;
GtkWidget *button_ok = gtk_button_new_with_label("Apply") ; // gtk_dialog_add_button(GTK_DIALOG(configure_dialog), "Apply", GTK_RESPONSE_APPLY) ;
GtkWidget *image_ok = gtk_image_new_from_file((settings.path_to_button_icons + "dialog-ok.png").c_str()) ;
gtk_widget_set_tooltip_markup(button_ok, "<b>Register</b> all the settings as <i>your default configuration</i> at start.") ;
gtk_button_set_image(GTK_BUTTON(button_ok), image_ok) ;
gtk_button_set_always_show_image(GTK_BUTTON(button_ok), TRUE) ;
gtk_dialog_add_action_widget(GTK_DIALOG(configure_dialog), button_close, GTK_RESPONSE_CLOSE) ;
gtk_dialog_add_action_widget(GTK_DIALOG(configure_dialog), button_ok, GTK_RESPONSE_APPLY) ;
GtkWidget *action_area = gtk_dialog_get_action_area(GTK_DIALOG(configure_dialog)) ;
gtk_container_set_border_width(GTK_CONTAINER(action_area), 0) ;
gtk_button_box_set_layout(GTK_BUTTON_BOX(action_area), GTK_BUTTONBOX_EDGE) ;
/** ***** [END] Dialog action buttons [END] ***** **/
Radio_Config high_contrast_radiobutton ;
high_contrast_radiobutton.button = radiobutton_icons_high_contrast ;
high_contrast_radiobutton.image = image_icons_high_contrast ;
high_contrast_radiobutton.volume = playing_settings_volume_image ;
high_contrast_radiobutton.cancel = image_close ;
high_contrast_radiobutton.apply = image_ok ;
high_contrast_radiobutton.little = interface_size_little_image ;
high_contrast_radiobutton.middle = interface_size_middle_image ;
high_contrast_radiobutton.big = interface_size_big_image ;
Radio_Config oxygen_radiobutton ;
oxygen_radiobutton.button = radiobutton_icons_oxygen ;
oxygen_radiobutton.image = image_icons_oxygen ;
oxygen_radiobutton.volume = playing_settings_volume_image ;
oxygen_radiobutton.cancel = image_close ;
oxygen_radiobutton.apply = image_ok ;
oxygen_radiobutton.little = interface_size_little_image ;
oxygen_radiobutton.middle = interface_size_middle_image ;
oxygen_radiobutton.big = interface_size_big_image ;
g_signal_connect(G_OBJECT(radiobutton_icons_high_contrast), "clicked", G_CALLBACK(configure_high_contrast_radiobutton), &high_contrast_radiobutton) ;
g_signal_connect(G_OBJECT(radiobutton_icons_oxygen), "clicked", G_CALLBACK(configure_oxygen_radiobutton), &oxygen_radiobutton ) ;
int little = -1 ;
int middle = 0 ;
int big = 1 ;
g_signal_connect(G_OBJECT(interface_size_radiobutton_little), "clicked", G_CALLBACK(reconfigure_interface_size), &little) ;
g_signal_connect(G_OBJECT(interface_size_radiobutton_middle), "clicked", G_CALLBACK(reconfigure_interface_size), &middle) ;
g_signal_connect(G_OBJECT(interface_size_radiobutton_big), "clicked", G_CALLBACK(reconfigure_interface_size), &big) ;
g_signal_connect(G_OBJECT(playing_settings_repeat_all), "toggled", G_CALLBACK(repeat_all_feature_set), NULL) ;
g_signal_connect(G_OBJECT(playing_settings_shuffle), "toggled", G_CALLBACK(shuffle_feature_set), NULL) ;
g_signal_connect(G_OBJECT(playing_settings_volume_scale), "value-changed", G_CALLBACK(get_volume), NULL) ;
g_signal_connect(G_OBJECT(folder_selecting_button), "file-set", G_CALLBACK(set_default_folder), NULL) ;
gtk_widget_show_all(configure_dialog) ;
int response = gtk_dialog_run(GTK_DIALOG(configure_dialog)) ;
switch (response) {
case GTK_RESPONSE_APPLY :
{
GKeyFile *conf_file = g_key_file_new() ;
GError *error = NULL ;
settings.is_repeat_all = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(playing_settings_repeat_all)) ;
settings.is_shuffle = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(playing_settings_shuffle)) ;
// Set configuration settings to configuration file buffer.
g_key_file_set_string(conf_file, "Config", "Buttons_Icons_Path", settings.path_to_button_icons.c_str()) ;
g_key_file_set_string(conf_file, "Config", "Menu_Icons_Path", settings.path_to_menu_icons.c_str()) ;
g_key_file_set_string(conf_file, "Config", "Music_Folder", settings.path_to_music_folder.c_str()) ;
g_key_file_set_boolean(conf_file, "Config", "Is_Oxygen", settings.icon_set_oxygen) ;
g_key_file_set_boolean(conf_file, "Config", "Repeat_all", settings.is_repeat_all) ;
g_key_file_set_boolean(conf_file, "Config", "Shuffle", settings.is_shuffle) ;
g_key_file_set_double(conf_file, "Config", "Volume", settings.volume) ;
g_key_file_set_uint64(conf_file, "Config", "Buttons_space", settings.space_buttons) ;
g_key_file_set_uint64(conf_file, "Config", "Display_Size", settings.display_size) ;
g_key_file_set_uint64(conf_file, "Config", "Image_Resizing", settings.image_resized_size) ;
g_key_file_set_string(conf_file, "Config", "Sized_Default_Image", settings.path_to_default_image.c_str()) ;
// Write to configuration file
g_key_file_save_to_file(conf_file, PATH_TO_CONF_FILE, &error);
// Setting global variables.
cover_image = settings.path_to_default_image ;
current_folder = settings.path_to_music_folder ;
if ( error != NULL ) {
display_message_dialog("Error store configuration !", "Cannot store the configuration.") ;
#ifdef DEBUG
fprintf(stdout,"\n%s: Error store configuratiom settings.\n", prgname.c_str() ) ; fflush(stdout) ;
#endif
}
else { // Success
#ifdef DEBUG
fprintf(stdout,"\n%s: Success store configuratiom settings.\n", prgname.c_str() ) ;
#endif
}
}
break ;
case GTK_RESPONSE_CLOSE :
// Do nothing.
break ;
}
gtk_widget_destroy(configure_dialog) ;
return ;
}
/** Connect a GtkFileChooserButton widget to its stored value in the preferences database.
*
* @internal
*
* @param fb A pointer to the file chooser button that should be connected.
*
* @param boxname The Hbox name that contains the GtkFileChooserButton and Clear button
*/
static void
gnc_prefs_connect_file_chooser_button (GtkFileChooserButton *fcb, const gchar *boxname)
{
GtkImage *image;
gchar *group, *pref;
gchar *uri;
gboolean folder_set = TRUE;
g_return_if_fail(GTK_FILE_CHOOSER_BUTTON(fcb));
if (boxname == NULL)
gnc_prefs_split_widget_name (gtk_buildable_get_name(GTK_BUILDABLE(fcb)), &group, &pref);
else
gnc_prefs_split_widget_name (boxname, &group, &pref);
uri = gnc_prefs_get_string (group, pref);
PINFO("Uri is %s", uri);
if ((uri != NULL) && (g_strcmp0 (uri, "") != 0)) // default entry
{
gchar *path_head = g_filename_from_uri (uri, NULL, NULL);
// test for current folder present and set chooser to it
if (g_file_test (path_head, G_FILE_TEST_IS_DIR))
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER(fcb), uri);
else
folder_set = FALSE;
g_free (path_head);
}
image = g_object_get_data(G_OBJECT(fcb), "path_head_error");
if (folder_set) // If current folder missing, display error and tt message
gtk_widget_hide (GTK_WIDGET(image));
else
{
gchar *uri_u = g_uri_unescape_string (uri, NULL);
gchar *path_head = g_filename_from_uri (uri_u, NULL, NULL);
gchar *ttip = g_strconcat (_("Path does not exist, "), path_head, NULL);
gtk_widget_set_tooltip_text(GTK_WIDGET(image), ttip);
gtk_widget_show (GTK_WIDGET(image));
g_free (ttip);
g_free (uri_u);
g_free (path_head);
}
g_signal_connect (GTK_FILE_CHOOSER(fcb), "selection-changed",
G_CALLBACK(file_chooser_selected_cb), NULL);
g_object_set_data_full (G_OBJECT(fcb),"group", g_strdup (group), (GDestroyNotify) g_free);
g_object_set_data_full (G_OBJECT(fcb),"pref", g_strdup (pref), (GDestroyNotify) g_free);
g_free (group);
g_free (pref);
g_free (uri);
gtk_widget_show_all(GTK_WIDGET(fcb));
}
static void
save_got_message(CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *d)
{
struct _save_data *data = d;
GtkDialog *dialog;
GtkWidget *w, *tree;
GtkTreeStore *model;
GtkCellRenderer *renderer;
/* not found, the mailer will show an error box for this */
if (msg == NULL) {
free_data(data);
return;
}
data->msg = msg;
camel_object_ref(msg);
dialog = (GtkDialog *)gtk_dialog_new_with_buttons(_("Save attachments"),
NULL, /* target->parent? */
0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
w = gtk_file_chooser_button_new (_("Select save base name"), GTK_FILE_CHOOSER_ACTION_OPEN);
data->entry = w;
g_object_set(w, "filechooser_action", GTK_FILE_CHOOSER_ACTION_SAVE, NULL);
gtk_widget_show(w);
gtk_box_pack_start((GtkBox *)dialog->vbox, w, FALSE, TRUE, 6);
g_signal_connect(GTK_FILE_CHOOSER_BUTTON (w), "selection-changed", G_CALLBACK(entry_changed), data);
model = gtk_tree_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
data->model = model;
fill_model(msg, model);
tree = gtk_tree_view_new_with_model((GtkTreeModel *)model);
data->tree = tree;
gtk_widget_show(tree);
gtk_tree_view_expand_all((GtkTreeView *)tree);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1,
_("MIME Type"), renderer, "text", 1, NULL);
gtk_tree_view_set_expander_column((GtkTreeView *)tree, gtk_tree_view_get_column((GtkTreeView *)tree, 0));
renderer = gtk_cell_renderer_toggle_new();
g_object_set(renderer, "activatable", TRUE, NULL);
g_signal_connect(renderer, "toggled", G_CALLBACK(toggle_changed), data);
gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1,
_("Save"), renderer, "active", 0, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1,
_("Name"), renderer, "text", 2, NULL);
w = g_object_new(gtk_frame_get_type(),
"shadow_type", GTK_SHADOW_NONE,
"label_widget", g_object_new(gtk_label_get_type(),
"label", "<span weight=\"bold\">Attachments</span>",
"use_markup", TRUE,
"xalign", 0.0, NULL),
"child", g_object_new(gtk_alignment_get_type(),
"left_padding", 12,
"top_padding", 6,
"child", g_object_new(gtk_scrolled_window_get_type(),
"hscrollbar_policy", GTK_POLICY_AUTOMATIC,
"vscrollbar_policy", GTK_POLICY_AUTOMATIC,
"shadow_type", GTK_SHADOW_IN,
"child", tree,
NULL),
NULL),
NULL);
gtk_widget_show_all(w);
gtk_box_pack_start((GtkBox *)dialog->vbox, w, TRUE, TRUE, 0);
g_signal_connect(dialog, "response", G_CALLBACK(save_response), data);
gtk_window_set_default_size((GtkWindow *)dialog, 500, 500);
gtk_widget_show((GtkWidget *)dialog);
}
GtkWidget*
gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * ctor )
{
guint row;
guint col;
const char * str;
GtkWidget * w;
GtkWidget * d;
GtkWidget * t;
GtkWidget * l;
GtkWidget * source_chooser;
struct OpenData * data;
bool flag;
GSList * list;
GSList * walk;
/* make the dialog */
d = gtk_dialog_new_with_buttons( _( "Torrent Options" ), parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL );
gtk_dialog_set_default_response( GTK_DIALOG( d ),
GTK_RESPONSE_ACCEPT );
gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_CANCEL,
-1 );
if( tr_ctorGetDownloadDir( ctor, TR_FORCE, &str ) )
g_assert_not_reached( );
g_assert( str );
data = g_new0( struct OpenData, 1 );
data->core = core;
data->ctor = ctor;
data->filename = g_strdup( tr_ctorGetSourceFile( ctor ) );
data->downloadDir = g_strdup( str );
data->file_list = gtr_file_list_new( core, 0 );
str = _( "Mo_ve .torrent file to the trash" );
data->trash_check = gtk_check_button_new_with_mnemonic( str );
str = _( "_Start when added" );
data->run_check = gtk_check_button_new_with_mnemonic( str );
w = data->priority_combo = gtr_priority_combo_new( );
gtr_priority_combo_set_value( GTK_COMBO_BOX( w ), TR_PRI_NORMAL );
g_signal_connect( G_OBJECT( d ), "response",
G_CALLBACK( addResponseCB ), data );
t = gtk_table_new( 6, 2, FALSE );
gtk_container_set_border_width( GTK_CONTAINER( t ), GUI_PAD_BIG );
gtk_table_set_row_spacings( GTK_TABLE( t ), GUI_PAD );
gtk_table_set_col_spacings( GTK_TABLE( t ), GUI_PAD_BIG );
row = col = 0;
l = gtk_label_new_with_mnemonic( _( "_Torrent file:" ) );
gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 );
++col;
w = gtk_file_chooser_button_new( _( "Select Source File" ),
GTK_FILE_CHOOSER_ACTION_OPEN );
source_chooser = w;
gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w );
addTorrentFilters( GTK_FILE_CHOOSER( w ) );
g_signal_connect( w, "selection-changed",
G_CALLBACK( sourceChanged ), data );
++row;
col = 0;
l = gtk_label_new_with_mnemonic( _( "_Destination folder:" ) );
gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 );
++col;
w = gtk_file_chooser_button_new( _( "Select Destination Folder" ),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
if( !gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ),
data->downloadDir ) )
g_warning( "couldn't select '%s'", data->downloadDir );
list = get_recent_destinations( );
for( walk = list; walk; walk = walk->next )
gtk_file_chooser_add_shortcut_folder( GTK_FILE_CHOOSER( w ), walk->data, NULL );
g_slist_free( list );
gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w );
g_signal_connect( w, "selection-changed",
G_CALLBACK( downloadDirChanged ), data );
++row;
col = 0;
w = data->file_list;
gtk_widget_set_size_request ( w, 466u, 300u );
gtk_table_attach_defaults( GTK_TABLE( t ), w, col, col + 2, row, row + 1 );
++row;
col = 0;
w = gtk_label_new_with_mnemonic( _( "Torrent _priority:" ) );
gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.5f );
gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
++col;
gtk_table_attach( GTK_TABLE( t ), data->priority_combo, col, col + 1, row, row + 1, ~0, 0, 0, 0 );
gtk_label_set_mnemonic_widget( GTK_LABEL( w ), data->priority_combo );
++row;
col = 0;
w = data->run_check;
if( tr_ctorGetPaused( ctor, TR_FORCE, &flag ) )
g_assert_not_reached( );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), !flag );
gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 );
++row;
col = 0;
w = data->trash_check;
if( tr_ctorGetDeleteSource( ctor, &flag ) )
g_assert_not_reached( );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), flag );
gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 );
/* trigger sourceChanged, either directly or indirectly,
* so that it creates the tor/gtor objects */
w = source_chooser;
if( data->filename )
gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( w ), data->filename );
else
sourceChanged( GTK_FILE_CHOOSER_BUTTON( w ), data );
gtr_dialog_set_content( GTK_DIALOG( d ), t );
w = gtk_dialog_get_widget_for_response( GTK_DIALOG( d ), GTK_RESPONSE_ACCEPT );
gtk_widget_grab_focus( w );
return d;
}
int music_build_element_widgets () {
int i = 0;
for (i = 0; i < 9; i++) {
label_music_info[i] = gtk_label_new(NULL);
gtk_label_set_width_chars(GTK_LABEL(label_music_info[i]), 15);
gtk_label_set_max_width_chars(GTK_LABEL(label_music_info[i]), 150);
gtk_label_set_line_wrap(GTK_LABEL(label_music_info[i]), TRUE);
}
separator_music_info = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
for (i = 0; i < 9; i++) {
label_music_lyric[i] = gtk_label_new(NULL);
gtk_label_set_max_width_chars(GTK_LABEL(label_music_lyric[i]), 305);
// gtk_label_set_line_wrap(GTK_LABEL(label_music_lyric[i]), TRUE);
}
gtk_label_set_selectable(GTK_LABEL(label_music_lyric[4]), TRUE);
gtk_label_set_use_underline (GTK_LABEL(label_music_lyric[4]), TRUE);
gtk_label_set_use_markup (GTK_LABEL(label_music_lyric[4]), TRUE);
gtk_label_set_pattern (GTK_LABEL(label_music_lyric[4]), "________");
separator_music_lyric1 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
separator_music_lyric2 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
button_music_start_server = gtk_button_new_with_label("启动服务器");
// set_button_music_start_server(button_music_start_server);
button_music_exit_server = gtk_button_new_with_label("关闭服务器");
// set_button_music_exit_server(button_music_exit_server);
button_music_play = gtk_button_new();
// box_music_play = button_with_image("/usr/share/raspi_remote_control/ui_images/ui_images_music/play.png");
// box_music_pause = button_with_image("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause.png");
image_music_play = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/play.png");
image_music_play_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/play_light.png");
image_music_pause = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause.png");
image_music_pause_light = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause_light.png");
gtk_button_set_relief(GTK_BUTTON(button_music_play), GTK_RELIEF_NONE);
set_button_music_play(button_music_play);
button_music_pause = gtk_button_new_with_label("暂停");
// set_button_music_pause(button_music_pause);
button_music_unpause = gtk_button_new_with_label("取消暂停");
// set_button_music_unpause(button_music_unpause);
// button_music_stop = gtk_button_new_with_label("停止");
button_music_stop = gtk_button_new();
image_music_stop = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/stop.png");
image_music_stop_light = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/stop_light.png");
gtk_button_set_image(GTK_BUTTON(button_music_stop), image_music_stop);
gtk_button_set_relief(GTK_BUTTON(button_music_stop), GTK_RELIEF_NONE);
set_button_music_stop(button_music_stop);
// button_music_next = gtk_button_new_with_label("下一首");
button_music_next = gtk_button_new();
image_music_next = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/next.png");
image_music_next_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/next_light.png");
gtk_button_set_image(GTK_BUTTON(button_music_next), image_music_next);
gtk_button_set_relief(GTK_BUTTON(button_music_next), GTK_RELIEF_NONE);
set_button_music_next(button_music_next);
// button_music_pre = gtk_button_new_with_label("上一首");
button_music_pre = gtk_button_new();
image_music_pre = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/pre.png");
image_music_pre_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/pre_light.png");
gtk_button_set_image (GTK_BUTTON(button_music_pre), image_music_pre);
gtk_button_set_relief(GTK_BUTTON(button_music_pre), GTK_RELIEF_NONE);
set_button_music_pre(button_music_pre);
// button_music_volume_up = gtk_button_new_with_label("音量+");
// set_button_music_volume_up(button_music_volume_up);
// button_music_volume_silence = gtk_button_new_with_label("静音");
button_music_silence = gtk_button_new();
image_music_silence = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/silence.png");
image_music_silence_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/silence_light.png");
image_music_unsilence = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/unsilence.png");
image_music_unsilence_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/unsilence_light.png");
gtk_button_set_image (GTK_BUTTON(button_music_silence), image_music_silence);
gtk_button_set_relief(GTK_BUTTON(button_music_silence), GTK_RELIEF_NONE);
set_button_music_silence(button_music_silence);
button_music_volume = gtk_volume_button_new();
set_button_music_volume( button_music_volume);
button_music_reset_list = gtk_button_new_with_label("重设列表");
set_button_music_reset_list(button_music_reset_list);
// button_music_choose_path = gtk_button_new_with_label("添加路径");
// set_button_music_choose_path(button_music_choose_path);
// music_path_dialog = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
music_path_dialog = gtk_file_chooser_dialog_new ("test_title", NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "test_button_text", NULL);
button_music_choose_path = gtk_file_chooser_button_new_with_dialog (music_path_dialog);
gtk_file_chooser_button_set_title (GTK_FILE_CHOOSER_BUTTON(button_music_choose_path), "添加路径");
// gtk_file_chooser_set_select_multiple (music_path_dialog, TRUE);
button_music_delete_path = gtk_button_new_with_label("删除当前路径");
set_button_music_delete_path(button_music_delete_path);
scale_music_process = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
set_scale_music_process(scale_music_process);
label_music_cur_time = gtk_label_new ("--:--:--");
label_music_total_time = gtk_label_new ("--:--:--");
switch_music_autonext = gtk_switch_new ();
set_switch_music_autonext ();
label_music_autonext = gtk_label_new ("AutoNext: ");
switch_music_repeat = gtk_switch_new ();
set_switch_music_repeat ();
label_music_repeat = gtk_label_new ("Repeat: ");
switch_music_shuffle = gtk_switch_new ();
set_switch_music_shuffle ();
label_music_shuffle = gtk_label_new ("Shuffle: ");
radio_button_music_mode_shuffle = gtk_radio_button_new (NULL);
label_music_mode_shuffle = gtk_label_new ("随机:");
radio_button_music_mode_loop_list = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle));
label_music_mode_loop_list = gtk_label_new ("列表循环:");
radio_button_music_mode_play_list = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle));
label_music_mode_play_list = gtk_label_new ("播放列表:");
radio_button_music_mode_loop_one = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle));
label_music_mode_loop_one = gtk_label_new ("单曲:");
spinner_music_mode_changing = gtk_spinner_new ();
set_radio_button_music_mode ();
store_music_dir_list = gtk_tree_store_new(dir_n_columns, G_TYPE_STRING);
tree_view_music_dir_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store_music_dir_list));
text_renderer_music_dir_list = gtk_cell_renderer_text_new ();
column_music_dir_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_dir_list, "text", dir_name, NULL);
gtk_tree_view_column_set_fixed_width(column_music_dir_list, 100);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_dir_list), column_music_dir_list);
music_dir_list_sw_adj_h = gtk_adjustment_new(100, 0, 100, 1, 1, 50);
music_dir_list_sw = gtk_scrolled_window_new(NULL, music_dir_list_sw_adj_h);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(music_dir_list_sw), 330);
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(music_dir_list_sw), 100);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_SHADOW_NONE);
// gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(music_dir_list_sw), tree_view_music_dir_list);
selection_music_dir_list = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view_music_dir_list));
set_tree_view_music_dir_list ();
store_music_list = gtk_tree_store_new(list_n_columns, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
// char file_index[BUFSIZ];
// printf("music_list_num is: %s\n", music_list_num);
// while (i < music_list_num) {
// // printf("%d: %s\n", i, music_list[i]);
// sprintf(file_index, "%d", i + 1);
// gtk_tree_store_append(store_music_list, &iter_music_list, NULL);
// gtk_tree_store_set (store_music_list, &iter_music_list, list_index, file_index, list_title, music_list[i], list_total_sec, "03:00", -1);
// i++;
// }
//
tree_view_music_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store_music_list));
text_renderer_music_list = gtk_cell_renderer_text_new ();
column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_index, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list);
gtk_tree_view_column_set_title(column_music_list, "序号");
text_renderer_music_list = gtk_cell_renderer_text_new ();
column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_title, NULL);
gtk_tree_view_column_set_fixed_width(column_music_list, 100);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list);
// text_renderer_music_list = gtk_cell_renderer_text_new ();
// column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_total_sec, NULL);
// gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list);
music_list_sw_adj_h = gtk_adjustment_new(100, 0, 100, 1, 1, 50);
music_list_sw = gtk_scrolled_window_new(NULL, music_list_sw_adj_h);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(music_list_sw), 370);
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(music_list_sw), 200);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(music_list_sw), GTK_SHADOW_NONE);
// gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_list_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_list_sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(music_list_sw), tree_view_music_list);
selection_music_list = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view_music_list));
set_tree_view_music_list ();
return 1;
}
static void gui_get_objects(GtkBuilder *builder)
{
// Window
gui.window = GTK_WINDOW(gui_get_object(builder,
"window"));
// Menus
gui.menuitem_file = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_file"));
gui.menuitem_save_as = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_save_as"));
gui.menuitem_quit = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_quit"));
gui.menuitem_edit = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_edit"));
gui.menuitem_cut = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_cut"));
gui.menuitem_copy = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_copy"));
gui.menuitem_paste = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_paste"));
gui.menuitem_delete = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_delete"));
gui.menuitem_select_all = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_select_all"));
gui.menuitem_prefs = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_prefs"));
gui.menuitem_about = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_about"));
gui.radiomenuitem_file = GTK_RADIO_MENU_ITEM(gui_get_object(builder,
"radiomenuitem_file"));
gui.radiomenuitem_text = GTK_RADIO_MENU_ITEM(gui_get_object(builder,
"radiomenuitem_text"));
gui.radiomenuitem_file_list = GTK_RADIO_MENU_ITEM(gui_get_object(builder,
"radiomenuitem_file_list"));
// Toolbar
gui.toolbar = GTK_TOOLBAR(gui_get_object(builder,
"toolbar"));
gui.toolbutton_add = GTK_TOOL_BUTTON(gui_get_object(builder,
"toolbutton_add"));
gui.toolbutton_remove = GTK_TOOL_BUTTON(gui_get_object(builder,
"toolbutton_remove"));
gui.toolbutton_clear = GTK_TOOL_BUTTON(gui_get_object(builder,
"toolbutton_clear"));
// Containers
gui.vbox_single = GTK_VBOX(gui_get_object(builder,
"vbox_single"));
gui.vbox_list = GTK_VBOX(gui_get_object(builder,
"vbox_list"));
gui.hbox_input = GTK_HBOX(gui_get_object(builder,
"hbox_input"));
gui.hbox_output = GTK_HBOX(gui_get_object(builder,
"hbox_output"));
gui.vbox_outputlabels = GTK_VBOX(gui_get_object(builder,
"vbox_outputlabels"));
gui.vbox_digests_file = GTK_VBOX(gui_get_object(builder,
"vbox_digests_file"));
gui.vbox_digests_text = GTK_VBOX(gui_get_object(builder,
"vbox_digests_text"));
// Inputs
gui.entry = GTK_ENTRY(gui_get_object(builder,
"entry"));
gui.filechooserbutton = GTK_FILE_CHOOSER_BUTTON(gui_get_object(builder,
"filechooserbutton"));
// Labels
gui.label_text = GTK_LABEL(gui_get_object(builder,
"label_text"));
gui.label_file = GTK_LABEL(gui_get_object(builder,
"label_file"));
// Tree View
gui.treeview = GTK_TREE_VIEW(gui_get_object(builder,
"treeview"));
gui.treeselection = GTK_TREE_SELECTION(gui_get_object(builder,
"treeselection"));
gui.menu_treeview = GTK_MENU(gui_get_object(builder,
"menu_treeview"));
gui.menuitem_treeview_add = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_treeview_add"));
gui.menuitem_treeview_remove = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_treeview_remove"));
gui.menuitem_treeview_clear = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_treeview_clear"));
gui.menu_treeview_copy = GTK_MENU(gui_get_object(builder,
"menu_treeview_copy"));
gui.menuitem_treeview_copy = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_treeview_copy"));
gui.menuitem_treeview_show_toolbar = GTK_MENU_ITEM(gui_get_object(builder,
"menuitem_treeview_show_toolbar"));
// Buttons
gui.hseparator_buttons = GTK_HSEPARATOR(gui_get_object(builder,
"hseparator_buttons"));
gui.button_hash = GTK_BUTTON(gui_get_object(builder,
"button_hash"));
gui.button_stop = GTK_BUTTON(gui_get_object(builder,
"button_stop"));
// Progress Bar
gui.progressbar = GTK_PROGRESS_BAR(gui_get_object(builder,
"progressbar"));
// Dialog
gui.dialog = GTK_DIALOG(gui_get_object(builder,
"dialog"));
gui.dialog_table = GTK_TABLE(gui_get_object(builder,
"dialog_table"));
gui.dialog_combobox = GTK_COMBO_BOX(gui_get_object(builder,
"dialog_combobox"));
gui.dialog_button_close = GTK_BUTTON(gui_get_object(builder,
"dialog_button_close"));
}
void config_missing_letter(GcomprisBoardConf *bconf, GHashTable *config)
{
GtkWidget *frame, *view, *pixmap, *question, *answer, *choice;
GtkWidget *level, *vbox, *hbox, *label;
GtkWidget *bbox, *button, *table;
GtkFileFilter *file_filter;
_config_missing *conf_data;
int i;
conf_data = g_new0(_config_missing,1);
/* frame */
frame = gtk_frame_new("");
gtk_widget_show(frame);
gtk_box_pack_start(GTK_BOX(bconf->main_conf_box), frame, TRUE, TRUE, 8);
vbox = gtk_vbox_new(FALSE, 8);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* hbox */
hbox = gtk_hbox_new(FALSE, 8);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 8);
/* combo level */
label = gtk_label_new(_("Level:"));
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 8);
level = gtk_combo_box_new_text();
for(i=1; i< gcomprisBoard_missing->maxlevel; i++)
{
gchar *tmp;
tmp = g_strdup_printf(_("Level %d"), i);
gtk_combo_box_append_text(GTK_COMBO_BOX(level), tmp);
g_free(tmp);
}
gtk_widget_show(level);
gtk_box_pack_start(GTK_BOX(hbox), level, FALSE, FALSE, 8);
/* upper case */
gboolean up_init = FALSE;
gchar *up_init_str = g_hash_table_lookup( config, "uppercase_only");
if (up_init_str && (strcmp(up_init_str, "True")==0))
up_init = TRUE;
gc_board_config_boolean_box(bconf, _("Uppercase only text"),
"uppercase_only",
up_init);
/* list view */
GtkListStore *list = gtk_list_store_new(N_COLUMNS,
G_TYPE_STRING, /*Question */
G_TYPE_STRING, /* Answer */
G_TYPE_STRING, /* Choice */
G_TYPE_STRING, /* pixmap */
GDK_TYPE_PIXBUF /* pixbuf */
);
view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list));
configure_colummns(GTK_TREE_VIEW(view));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (view), ANSWER_COLUMN);
gtk_widget_set_size_request(view, -1, 200);
gtk_widget_show(view);
GtkScrolledWindow *scroll = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL,NULL));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_widget_show(GTK_WIDGET(scroll));
gtk_container_add(GTK_CONTAINER(scroll), view);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(scroll), TRUE, TRUE, 10);
/* button box */
bbox = gtk_hbutton_box_new();
gtk_widget_show(bbox);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 8);
button = gtk_button_new_from_stock(GTK_STOCK_NEW);
gtk_widget_show(button);
gtk_container_add(GTK_CONTAINER(bbox), button);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(new_clicked), (gpointer) conf_data);
button = gtk_button_new_from_stock(GTK_STOCK_DELETE);
gtk_widget_show(button);
gtk_container_add(GTK_CONTAINER(bbox), button);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(delete_clicked), (gpointer) conf_data);
button = gtk_button_new_from_stock(GTK_STOCK_SAVE);
gtk_widget_show(button);
gtk_container_add(GTK_CONTAINER(bbox), button);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(save_clicked), (gpointer) conf_data);
/* table */
table = gtk_table_new(2, 4, FALSE);
gtk_widget_show(table);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 8);
/* answer */
label = gtk_label_new(_("Answer"));
gtk_widget_show(label);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
answer = gtk_entry_new();
gtk_widget_show(answer);
gtk_table_attach_defaults(GTK_TABLE(table), answer, 1, 2, 0, 1);
/* pixmap */
label = gtk_label_new(_("Picture"));
gtk_widget_show(label);
gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 3, 0, 1);
pixmap = gtk_file_chooser_button_new(_("Filename:"),
GTK_FILE_CHOOSER_ACTION_OPEN);
file_filter = gtk_file_filter_new();
gtk_file_filter_add_pixbuf_formats(file_filter);
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(pixmap), file_filter);
gtk_widget_show(pixmap);
gtk_table_attach_defaults(GTK_TABLE(table), pixmap, 3, 4, 0, 1);
/* question */
label = gtk_label_new(_("Question"));
gtk_widget_show(label);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
question = gtk_entry_new();
gtk_widget_show(question);
gtk_table_attach_defaults(GTK_TABLE(table), question, 1, 2, 1, 2);
gtk_widget_set_tooltip_text(question,
_("Replace the letter to guess "
"by the character '_'.") );
/* choice */
label = gtk_label_new(_("Choice"));
gtk_widget_show(label);
gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 3, 1, 2);
choice = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(choice), MAX_PROPOSAL);
gtk_widget_show(choice);
gtk_table_attach_defaults(GTK_TABLE(table), choice, 3, 4, 1, 2);
gtk_widget_set_tooltip_text(choice, _("Enter here the letter that will be proposed. "
"The first letter here must be the solution."));
conf_data -> combo_level = GTK_COMBO_BOX(level);
conf_data -> view = GTK_TREE_VIEW(view);
conf_data -> pixmap = GTK_FILE_CHOOSER_BUTTON(pixmap);
conf_data -> question = GTK_ENTRY(question);
conf_data -> answer = GTK_ENTRY(answer);
conf_data -> choice = GTK_ENTRY(choice);
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(selection),
"changed",
G_CALLBACK(selection_changed),
(gpointer) conf_data);
g_signal_connect(G_OBJECT(frame), "destroy",
G_CALLBACK(destroy_conf_data), (gpointer) conf_data);
g_signal_connect(G_OBJECT(level), "changed",
G_CALLBACK(level_changed), (gpointer) conf_data);
g_signal_connect(G_OBJECT(question), "changed",
G_CALLBACK(text_changed), (gpointer) conf_data);
g_signal_connect(G_OBJECT(answer), "changed",
G_CALLBACK(text_changed), (gpointer) conf_data);
g_signal_connect(G_OBJECT(choice), "changed",
G_CALLBACK(text_changed), (gpointer) conf_data);
g_signal_connect(G_OBJECT(pixmap), "file-set",
G_CALLBACK(text_changed), (gpointer) conf_data);
gtk_combo_box_set_active(GTK_COMBO_BOX(level), 0);
}
/** Connect one dialog widget to the appropriate callback function for
* its type.
*
* @internal
*
* @param name The name of the widget.
*
* @param widget A pointer to the widget.
*
* @param dialog A pointer to the dialog.
*/
static void
gnc_prefs_connect_one (const gchar *name,
GtkWidget *widget,
gpointer user_data)
{
/* These tests must be ordered from more specific widget to less
* specific widget. */
if (GTK_IS_FONT_BUTTON(widget))
{
DEBUG(" %s - font button", name);
gnc_prefs_connect_font_button(GTK_FONT_BUTTON(widget));
}
else if (GTK_IS_FILE_CHOOSER_BUTTON(widget))
{
DEBUG(" %s - file chooser button", name);
gnc_prefs_connect_file_chooser_button(GTK_FILE_CHOOSER_BUTTON(widget), NULL);
}
else if (GTK_IS_RADIO_BUTTON(widget))
{
DEBUG(" %s - radio button", name);
gnc_prefs_connect_radio_button(GTK_RADIO_BUTTON(widget));
}
else if (GTK_IS_CHECK_BUTTON(widget))
{
DEBUG(" %s - check button", name);
gnc_prefs_connect_check_button(GTK_CHECK_BUTTON(widget));
}
else if (GTK_IS_SPIN_BUTTON(widget))
{
DEBUG(" %s - spin button", name);
gnc_prefs_connect_spin_button(GTK_SPIN_BUTTON(widget));
}
else if (GTK_IS_COMBO_BOX(widget))
{
DEBUG(" %s - combo box", name);
gnc_prefs_connect_combo_box(GTK_COMBO_BOX(widget));
}
else if (GTK_IS_ENTRY(widget))
{
DEBUG(" %s - entry", name);
gnc_prefs_connect_entry(GTK_ENTRY(widget));
}
else if (GTK_IS_BOX(widget))
{
/* Test custom widgets are all children of a hbox */
GtkWidget *widget_child;
GList* child = gtk_container_get_children(GTK_CONTAINER(widget));
widget_child = child->data;
g_list_free(child);
DEBUG(" %s - hbox", name);
DEBUG("Hbox widget type is %s and name is %s", gtk_widget_get_name(GTK_WIDGET(widget_child)), name);
if (GNC_IS_CURRENCY_EDIT(widget_child))
{
DEBUG(" %s - currency_edit", name);
gnc_prefs_connect_currency_edit(GNC_CURRENCY_EDIT(widget_child), name );
}
else if (GNC_IS_PERIOD_SELECT(widget_child))
{
DEBUG(" %s - period_Select", name);
gnc_prefs_connect_period_select(GNC_PERIOD_SELECT(widget_child), name );
}
else if (GNC_IS_DATE_EDIT(widget_child))
{
DEBUG(" %s - date_edit", name);
gnc_prefs_connect_date_edit(GNC_DATE_EDIT(widget_child), name );
}
else if (GTK_FILE_CHOOSER_BUTTON(widget_child))
{
DEBUG(" %s - file chooser buuton", name);
gnc_prefs_connect_file_chooser_button(GTK_FILE_CHOOSER_BUTTON(widget_child), name );
}
}
else
{
DEBUG(" %s - unsupported %s", name,
G_OBJECT_TYPE_NAME(G_OBJECT(widget)));
}
}
EAPMethodPEAP *
eap_method_peap_new (const char *glade_file,
WirelessSecurity *parent,
NMConnection *connection)
{
EAPMethodPEAP *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_peap_notebook", NULL);
if (xml == NULL) {
g_warning ("Couldn't get eap_peap_widget from glade xml");
return NULL;
}
widget = glade_xml_get_widget (xml, "eap_peap_notebook");
g_assert (widget);
g_object_ref_sink (widget);
method = g_slice_new0 (EAPMethodPEAP);
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_peap_anon_identity_entry");
eap_method_nag_init (EAP_METHOD (method),
glade_file,
"eap_peap_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_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,
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 = inner_auth_combo_init (method, glade_file, connection, s_8021x);
inner_auth_combo_changed_cb (widget, (gpointer) method);
widget = glade_xml_get_widget (xml, "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,
parent);
widget = glade_xml_get_widget (xml, "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,
parent);
return method;
}
static void
stm_new_transfer_window_ui (StmNewTransferWindow *self)
{
StmNewTransferWindowPrivate *priv = self->priv;
gtk_window_set_title (GTK_WINDOW (self), _("Add transfer"));
/* Buttons */
GtkWidget *close = gtk_dialog_add_button (GTK_DIALOG (self),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
g_signal_connect (G_OBJECT (close), "clicked",
G_CALLBACK (stm_new_transfer_window_close_clicked), self);
/* Table */
GtkWidget *table = gtk_table_new (3, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
GtkWidget *label;
/* Left column */
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), _("<b>URL:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), _("<b>Save to:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 1, 2,
GTK_FILL, GTK_SHRINK, 0, 0);
/* Right column */
GtkWidget *entry;
entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), entry,
1, 2, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->source = GTK_ENTRY (entry);
entry = gtk_file_chooser_button_new (_("Select destination"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_table_attach (GTK_TABLE (table), entry,
1, 2, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->destination = GTK_FILE_CHOOSER_BUTTON (entry);
entry = gtk_check_button_new_with_label (_("Automatically start transfer"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (entry), TRUE);
gtk_table_attach (GTK_TABLE (table), entry,
0, 2, 2, 3,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->auto_start = GTK_CHECK_BUTTON (entry);
gtk_widget_show_all (table);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (self)->vbox), table,
FALSE, FALSE, 0);
/* Buttons */
GtkWidget *ok = gtk_dialog_add_button (GTK_DIALOG (self),
GTK_STOCK_OK,
GTK_RESPONSE_OK);
g_signal_connect (G_OBJECT (ok), "clicked",
G_CALLBACK (stm_new_transfer_window_close_clicked), self);
}
