static void
device_combo_changed (GtkWidget *combo,
                      gpointer user_data)
{
    NMAWirelessDialog *self = NMA_WIRELESS_DIALOG (user_data);
    NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);
    GtkTreeIter iter;
    GtkTreeModel *model;

    gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter);
    model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));

    g_object_unref (priv->device);
    gtk_tree_model_get (model, &iter, D_DEV_COLUMN, &priv->device, -1);

    if (!connection_combo_init (self, NULL)) {
        g_warning ("Couldn't change connection combo box.");
        return;
    }

    if (!security_combo_init (self)) {
        g_warning ("Couldn't change wireless security combo box.");
        return;
    }

    security_combo_changed (priv->sec_combo, self);
}
static gboolean
revalidate (gpointer user_data)
{
    NMAWirelessDialog *self = NMA_WIRELESS_DIALOG (user_data);
    NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);

    security_combo_changed (priv->sec_combo, self);
    return FALSE;
}
static void
connection_combo_changed (GtkWidget *combo,
                          gpointer user_data)
{
    NMAWirelessDialog *self = NMA_WIRELESS_DIALOG (user_data);
    NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);
    GtkTreeIter iter;
    GtkTreeModel *model;
    gboolean is_new = FALSE;
    NMSettingWireless *s_wireless;
    char *utf8_ssid;
    GtkWidget *widget;

    gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter);
    model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));

    if (priv->connection)
        g_object_unref (priv->connection);

    gtk_tree_model_get (model, &iter,
                        C_CON_COLUMN, &priv->connection,
                        C_NEW_COLUMN, &is_new, -1);

    if (!security_combo_init (self)) {
        g_warning ("Couldn't change wireless security combo box.");
        return;
    }
    security_combo_changed (priv->sec_combo, self);

    widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_entry"));
    if (priv->connection) {
        const GByteArray *ssid;

        s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (priv->connection, NM_TYPE_SETTING_WIRELESS));
        ssid = nm_setting_wireless_get_ssid (s_wireless);
        utf8_ssid = nm_utils_ssid_to_utf8 ((const char *) ssid->data, ssid->len);
        gtk_entry_set_text (GTK_ENTRY (widget), utf8_ssid);
        g_free (utf8_ssid);
    } else {
        gtk_entry_set_text (GTK_ENTRY (widget), "");
    }

    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_entry")), is_new);
    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_label")), is_new);
    gtk_widget_set_sensitive (priv->sec_combo, is_new);
    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (priv->builder, "security_combo_label")), is_new);
    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (priv->builder, "security_vbox")), is_new);
}
static void
finish_setup (CEPageSecurity *page)
{
        NMConnection *connection = CE_PAGE (page)->connection;
        NMSettingWireless *sw;
        NMSettingWirelessSecurity *sws;
        gboolean is_adhoc = FALSE;
        GtkListStore *sec_model;
        GtkTreeIter iter;
        const gchar *mode;
        const gchar *security;
        guint32 dev_caps = 0;
        NMUtilsSecurityType default_type = NMU_SEC_NONE;
        int active = -1;
        int item = 0;
        GtkComboBox *combo;
        GtkCellRenderer *renderer;

        sw = nm_connection_get_setting_wireless (connection);
        g_assert (sw);

        page->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);

        page->security_heading = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "heading_sec"));
        page->security_combo = combo = GTK_COMBO_BOX (gtk_builder_get_object (CE_PAGE (page)->builder, "combo_sec"));

        dev_caps =   NM_WIFI_DEVICE_CAP_CIPHER_WEP40
                   | NM_WIFI_DEVICE_CAP_CIPHER_WEP104
                   | NM_WIFI_DEVICE_CAP_CIPHER_TKIP
                   | NM_WIFI_DEVICE_CAP_CIPHER_CCMP
                   | NM_WIFI_DEVICE_CAP_WPA
                   | NM_WIFI_DEVICE_CAP_RSN;

        mode = nm_setting_wireless_get_mode (sw);
        if (mode && !strcmp (mode, "adhoc"))
                is_adhoc = TRUE;
        page->adhoc = is_adhoc;

        sws = nm_connection_get_setting_wireless_security (connection);
        security = nm_setting_wireless_get_security (sw);
        if (!security || strcmp (security, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME) != 0)
                sws = NULL;
        if (sws)
                default_type = get_default_type_for_security (sws);

        sec_model = gtk_list_store_new (3, G_TYPE_STRING, wireless_security_get_g_type (), G_TYPE_BOOLEAN);

        if (nm_utils_security_valid (NMU_SEC_NONE, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
                gtk_list_store_insert_with_values (sec_model, &iter, -1,
                                                   S_NAME_COLUMN, C_("Wi-Fi/Ethernet security", "None"),
                                                   S_ADHOC_VALID_COLUMN, TRUE,
                                                   -1);
                if (default_type == NMU_SEC_NONE)
                        active = item;
                item++;
        }

        if (nm_utils_security_valid (NMU_SEC_STATIC_WEP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
                WirelessSecurityWEPKey *ws_wep;
                NMWepKeyType wep_type = NM_WEP_KEY_TYPE_KEY;

                if (default_type == NMU_SEC_STATIC_WEP) {
                        sws = nm_connection_get_setting_wireless_security (connection);
                        if (sws)
                                wep_type = nm_setting_wireless_security_get_wep_key_type (sws);
                        if (wep_type == NM_WEP_KEY_TYPE_UNKNOWN)
                                wep_type = NM_WEP_KEY_TYPE_KEY;
                }

                ws_wep = ws_wep_key_new (connection, NM_WEP_KEY_TYPE_KEY, FALSE, FALSE);
                if (ws_wep) {
                        add_security_item (page, WIRELESS_SECURITY (ws_wep), sec_model,
                                           &iter, _("WEP 40/128-bit Key (Hex or ASCII)"),
                                           TRUE);
                        if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_KEY))
                                active = item;
                        item++;
                }

                ws_wep = ws_wep_key_new (connection, NM_WEP_KEY_TYPE_PASSPHRASE, FALSE, FALSE);
                if (ws_wep) {
                        add_security_item (page, WIRELESS_SECURITY (ws_wep), sec_model,
                                           &iter, _("WEP 128-bit Passphrase"), TRUE);
                        if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_PASSPHRASE))
                                active = item;
                        item++;
                }
        }

        if (nm_utils_security_valid (NMU_SEC_LEAP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
                WirelessSecurityLEAP *ws_leap;

                ws_leap = ws_leap_new (connection, FALSE);
                if (ws_leap) {
                        add_security_item (page, WIRELESS_SECURITY (ws_leap), sec_model,
                                           &iter, _("LEAP"), FALSE);
                        if ((active < 0) && (default_type == NMU_SEC_LEAP))
                                active = item;
                        item++;
                }
        }

        if (nm_utils_security_valid (NMU_SEC_DYNAMIC_WEP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
                WirelessSecurityDynamicWEP *ws_dynamic_wep;

                ws_dynamic_wep = ws_dynamic_wep_new (connection, TRUE, FALSE);
                if (ws_dynamic_wep) {
                        add_security_item (page, WIRELESS_SECURITY (ws_dynamic_wep), sec_model,
                                           &iter, _("Dynamic WEP (802.1x)"), FALSE);
                        if ((active < 0) && (default_type == NMU_SEC_DYNAMIC_WEP))
                                active = item;
                        item++;
                }
        }

        if (nm_utils_security_valid (NMU_SEC_WPA_PSK, dev_caps, FALSE, is_adhoc, 0, 0, 0) ||
            nm_utils_security_valid (NMU_SEC_WPA2_PSK, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
                WirelessSecurityWPAPSK *ws_wpa_psk;

                ws_wpa_psk = ws_wpa_psk_new (connection, FALSE);
                if (ws_wpa_psk) {
                        add_security_item (page, WIRELESS_SECURITY (ws_wpa_psk), sec_model,
                                           &iter, _("WPA & WPA2 Personal"), FALSE);
                        if ((active < 0) && ((default_type == NMU_SEC_WPA_PSK) || (default_type == NMU_SEC_WPA2_PSK)))
                                active = item;
                        item++;
                }
        }

        if (nm_utils_security_valid (NMU_SEC_WPA_ENTERPRISE, dev_caps, FALSE, is_adhoc, 0, 0, 0) ||
            nm_utils_security_valid (NMU_SEC_WPA2_ENTERPRISE, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
                WirelessSecurityWPAEAP *ws_wpa_eap;

                ws_wpa_eap = ws_wpa_eap_new (connection, TRUE, FALSE);
                if (ws_wpa_eap) {
                        add_security_item (page, WIRELESS_SECURITY (ws_wpa_eap), sec_model,
                                           &iter, _("WPA & WPA2 Enterprise"), FALSE);
                        if ((active < 0) && ((default_type == NMU_SEC_WPA_ENTERPRISE) || (default_type == NMU_SEC_WPA2_ENTERPRISE)))
                                active = item;
                        item++;
                }
        }

        gtk_combo_box_set_model (combo, GTK_TREE_MODEL (sec_model));
        gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));

        renderer = gtk_cell_renderer_text_new ();
        gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
        gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "text", S_NAME_COLUMN, NULL);
        gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), renderer, set_sensitive, &page->adhoc, NULL);

        gtk_combo_box_set_active (combo, active < 0 ? 0 : (guint32) active);
        g_object_unref (G_OBJECT (sec_model));

        page->security_combo = combo;

        security_combo_changed (combo, page);
        g_signal_connect (combo, "changed",
                          G_CALLBACK (security_combo_changed), page);
}
static gboolean
internal_init (NMAWirelessDialog *self,
               NMConnection *specific_connection,
               NMDevice *specific_device,
               gboolean auth_only,
               gboolean create)
{
    NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);
    GtkWidget *widget;
    char *label, *icon_name = "network-wireless";
    gboolean security_combo_focus = FALSE;

    gtk_window_set_position (GTK_WINDOW (self), GTK_WIN_POS_CENTER_ALWAYS);
    gtk_container_set_border_width (GTK_CONTAINER (self), 6);
    gtk_window_set_default_size (GTK_WINDOW (self), 488, -1);
    gtk_window_set_resizable (GTK_WINDOW (self), FALSE);
    gtk_dialog_set_has_separator (GTK_DIALOG (self), FALSE);

    if (auth_only)
        icon_name = "dialog-password";
    else
        icon_name = "network-wireless";

    gtk_window_set_icon_name (GTK_WINDOW (self), icon_name);
    widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "image1"));
    gtk_image_set_from_icon_name (GTK_IMAGE (widget), icon_name, GTK_ICON_SIZE_DIALOG);

    gtk_box_set_spacing (GTK_BOX (gtk_bin_get_child (GTK_BIN (self))), 2);

    widget = gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
    gtk_box_set_child_packing (GTK_BOX (GTK_DIALOG (self)->action_area), widget,
                               FALSE, TRUE, 0, GTK_PACK_END);

    /* Connect/Create button */
    if (create) {
        GtkWidget *image;

        widget = gtk_button_new_with_mnemonic (_("C_reate"));
        image = gtk_image_new_from_stock (GTK_STOCK_CONNECT, GTK_ICON_SIZE_BUTTON);
        gtk_button_set_image (GTK_BUTTON (widget), image);

        gtk_widget_show (widget);
        gtk_dialog_add_action_widget (GTK_DIALOG (self), widget, GTK_RESPONSE_OK);
    } else
        widget = gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_CONNECT, GTK_RESPONSE_OK);

    gtk_box_set_child_packing (GTK_BOX (GTK_DIALOG (self)->action_area), widget,
                               FALSE, TRUE, 0, GTK_PACK_END);
    g_object_set (G_OBJECT (widget), "can-default", TRUE, NULL);
    gtk_widget_grab_default (widget);

    widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "hbox1"));
    if (!widget) {
        nm_warning ("Couldn't find UI wireless_dialog widget.");
        return FALSE;
    }

    gtk_widget_reparent (widget, gtk_bin_get_child (GTK_BIN (self)));

    /* If given a valid connection, hide the SSID bits and connection combo */
    if (specific_connection) {
        widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_label"));
        gtk_widget_hide (widget);

        widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_entry"));
        gtk_widget_hide (widget);

        security_combo_focus = TRUE;
    } else {
        widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_entry"));
        g_signal_connect (G_OBJECT (widget), "changed", (GCallback) ssid_entry_changed, self);
        gtk_widget_grab_focus (widget);
    }

    gtk_dialog_set_response_sensitive (GTK_DIALOG (self), GTK_RESPONSE_OK, FALSE);

    if (!device_combo_init (self, specific_device)) {
        g_warning ("No wireless devices available.");
        return FALSE;
    }

    if (!connection_combo_init (self, specific_connection)) {
        g_warning ("Couldn't set up connection combo box.");
        return FALSE;
    }

    if (!security_combo_init (self)) {
        g_warning ("Couldn't set up wireless security combo box.");
        return FALSE;
    }

    if (security_combo_focus)
        gtk_widget_grab_focus (priv->sec_combo);

    security_combo_changed (priv->sec_combo, self);
    g_signal_connect (G_OBJECT (priv->sec_combo), "changed", G_CALLBACK (security_combo_changed), self);

    if (priv->connection) {
        char *tmp;
        char *esc_ssid = NULL;
        NMSettingWireless *s_wireless;
        const GByteArray *ssid;

        s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (priv->connection, NM_TYPE_SETTING_WIRELESS));
        ssid = s_wireless ? nm_setting_wireless_get_ssid (s_wireless) : NULL;
        if (ssid)
            esc_ssid = nm_utils_ssid_to_utf8 ((const char *) ssid->data, ssid->len);

        tmp = g_strdup_printf (_("Passwords or encryption keys are required to access the wireless network '%s'."),
                               esc_ssid ? esc_ssid : "<unknown>");
        gtk_window_set_title (GTK_WINDOW (self), _("Wireless Network Authentication Required"));
        label = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s",
                                 _("Authentication required by wireless network"),
                                 tmp);
        g_free (esc_ssid);
        g_free (tmp);
    } else if (priv->adhoc_create) {
        gtk_window_set_title (GTK_WINDOW (self), _("Create New Wireless Network"));
        label = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s",
                                 _("New wireless network"),
                                 _("Enter a name for the wireless network you wish to create."));
    } else {
        gtk_window_set_title (GTK_WINDOW (self), _("Connect to Hidden Wireless Network"));
        label = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s",
                                 _("Hidden wireless network"),
                                 _("Enter the name and security details of the hidden wireless network you wish to connect to."));
    }

    widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "caption_label"));
    gtk_label_set_markup (GTK_LABEL (widget), label);
    g_free (label);

    /* Re-validate from an idle handler so that widgets like file choosers
     * have had time to find their files.
     */
    g_idle_add (revalidate, self);

    return TRUE;
}