static void
pg_enabled (CEPageDcb *self, gboolean enabled)
{
CEPageDcbPrivate *priv = CE_PAGE_DCB_GET_PRIVATE (self);
guint i;
gboolean set_default = TRUE;
if (!enabled)
return;
/* If the connection did not previously have DCB enabled, and the user
* just enabled DCB, set a valid priority group bandwidth so that the
* user doesn't have to go mess with the PG options dialog.
*/
for (i = 0; i < 8; i++) {
if (nm_setting_dcb_get_priority_group_bandwidth (priv->options, i)) {
set_default = FALSE;
break;
}
}
if (set_default)
nm_setting_dcb_set_priority_group_bandwidth (priv->options, 0, 100);
ce_page_changed (CE_PAGE (self));
}
static void
switch_toggled (GObject *object,
GParamSpec *pspec,
CEPage *page)
{
ce_page_changed (page);
}
static void
cell_editing_canceled (GtkCellRenderer *renderer, gpointer user_data)
{
CEPageIP4 *self;
CEPageIP4Private *priv;
GtkTreeModel *model = NULL;
GtkTreeSelection *selection;
GtkTreeIter iter;
guint32 column;
/* user_data disposed? */
if (GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (renderer), "ce-page-not-valid")))
return;
self = CE_PAGE_IP4 (user_data);
priv = CE_PAGE_IP4_GET_PRIVATE (self);
if (priv->last_edited) {
selection = gtk_tree_view_get_selection (priv->addr_list);
if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
column = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (renderer), "column"));
gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, priv->last_edited, -1);
}
g_free (priv->last_edited);
priv->last_edited = NULL;
ce_page_changed (CE_PAGE (self));
}
g_free (priv->last_path);
priv->last_path = NULL;
priv->last_column = -1;
}
static void
cell_edited (GtkCellRendererText *cell,
const gchar *path_string,
const gchar *new_text,
gpointer user_data)
{
CEPageIP4 *self = CE_PAGE_IP4 (user_data);
CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self);
GtkListStore *store = GTK_LIST_STORE (gtk_tree_view_get_model (priv->addr_list));
GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
GtkTreeIter iter;
guint32 column;
GtkTreeViewColumn *next_col;
column = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (cell), "column"));
gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path);
gtk_list_store_set (store, &iter, column, new_text, -1);
/* Move focus to the next column */
column = (column >= COL_LAST) ? 0 : column + 1;
next_col = gtk_tree_view_get_column (priv->addr_list, column);
gtk_tree_view_set_cursor_on_cell (priv->addr_list, path, next_col, priv->addr_cells[column], TRUE);
gtk_widget_grab_focus (GTK_WIDGET (priv->addr_list));
gtk_tree_path_free (path);
ce_page_changed (CE_PAGE (self));
}
static void
enable_toggled (GtkToggleButton *button, gpointer user_data)
{
CEPageDcbPrivate *priv = CE_PAGE_DCB_GET_PRIVATE (user_data);
gtk_widget_set_sensitive (GTK_WIDGET (priv->box), gtk_toggle_button_get_active (button));
ce_page_changed (CE_PAGE (user_data));
}
static void
id_changed (GtkWidget *w, gpointer user_data)
{
CEPageVlan *self = user_data;
CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);
sync_iface (self, GTK_ENTRY (priv->id_entry));
ce_page_changed (CE_PAGE (self));
}
static void
mode_combo_changed_cb (GtkComboBox *combo,
gpointer user_data)
{
CEPageWifi *self = CE_PAGE_WIFI (user_data);
CEPageWifiPrivate *priv = CE_PAGE_WIFI_GET_PRIVATE (self);
CEPage *parent = CE_PAGE (self);
GtkWidget *widget_band_label, *widget_chan_label, *widget_bssid_label;
gboolean adhoc;
switch (gtk_combo_box_get_active (GTK_COMBO_BOX (combo))) {
case 1: /* adhoc */
adhoc = TRUE;
break;
default: /* infrastructure */
adhoc = FALSE;
break;
}
widget_band_label = GTK_WIDGET (gtk_builder_get_object (parent->builder, "wifi_band_label"));
widget_chan_label = GTK_WIDGET (gtk_builder_get_object (parent->builder, "wifi_channel_label"));
widget_bssid_label = GTK_WIDGET (gtk_builder_get_object (parent->builder, "wifi_bssid_label"));
if (adhoc) {
/* For Ad-Hoc show Band and Channel */
gtk_widget_show (widget_band_label);
gtk_widget_show (GTK_WIDGET (priv->band));
gtk_widget_show (widget_chan_label);
gtk_widget_show (GTK_WIDGET (priv->channel));
/* and hide BSSID
* BSSID is random and is created by kernel for Ad-Hoc networks
* http://lxr.linux.no/linux+v3.7.6/net/mac80211/ibss.c#L685
*/
gtk_widget_hide (widget_bssid_label);
gtk_widget_hide (GTK_WIDGET (priv->bssid));
} else {
/* Do opposite for Infrastructure mode */
gtk_widget_hide (widget_band_label);
gtk_widget_hide (GTK_WIDGET (priv->band));
gtk_widget_hide (widget_chan_label);
gtk_widget_hide (GTK_WIDGET (priv->channel));
gtk_widget_show (widget_bssid_label);
gtk_widget_show (GTK_WIDGET (priv->bssid));
}
gtk_widget_set_sensitive (widget_band_label, adhoc);
gtk_widget_set_sensitive (GTK_WIDGET (priv->band), adhoc);
gtk_widget_set_sensitive (widget_chan_label, adhoc);
gtk_widget_set_sensitive (GTK_WIDGET (priv->channel), adhoc);
gtk_widget_set_sensitive (widget_bssid_label, !adhoc);
gtk_widget_set_sensitive (GTK_WIDGET (priv->bssid), !adhoc);
ce_page_changed (CE_PAGE (self));
}
static void
mode_combo_changed_cb (GtkComboBox *combo,
gpointer user_data)
{
CEPageWifi *self = CE_PAGE_WIFI (user_data);
CEPageWifiPrivate *priv = CE_PAGE_WIFI_GET_PRIVATE (self);
CEPage *parent = CE_PAGE (self);
GtkWidget *widget_band_label, *widget_chan_label, *widget_bssid_label;
gboolean show_freq = FALSE;
gboolean show_bssid = TRUE;
gboolean hotspot = FALSE;
switch (gtk_combo_box_get_active (GTK_COMBO_BOX (combo))) {
case 1: /* hotspot */
hotspot = TRUE;
/* fallthrough */
case 2: /* adhoc */
/* BSSID is random and is created by kernel for Ad-Hoc networks
* http://lxr.linux.no/linux+v3.7.6/net/mac80211/ibss.c#L685
* For AP-mode, the BSSID is the MAC address of the device.
*/
show_bssid = FALSE;
show_freq = TRUE;
break;
default: /* infrastructure */
show_freq = FALSE;
break;
}
nm_connection_editor_inter_page_set_value (parent->editor,
INTER_PAGE_CHANGE_WIFI_MODE,
GUINT_TO_POINTER (hotspot));
widget_band_label = GTK_WIDGET (gtk_builder_get_object (parent->builder, "wifi_band_label"));
widget_chan_label = GTK_WIDGET (gtk_builder_get_object (parent->builder, "wifi_channel_label"));
widget_bssid_label = GTK_WIDGET (gtk_builder_get_object (parent->builder, "wifi_bssid_label"));
gtk_widget_set_visible (widget_band_label, show_freq);
gtk_widget_set_sensitive (widget_band_label, show_freq);
gtk_widget_set_visible (GTK_WIDGET (priv->band), show_freq);
gtk_widget_set_sensitive (GTK_WIDGET (priv->band), show_freq);
gtk_widget_set_visible (widget_chan_label, show_freq);
gtk_widget_set_sensitive (widget_chan_label, show_freq);
gtk_widget_set_visible (GTK_WIDGET (priv->channel), show_freq);
gtk_widget_set_sensitive (GTK_WIDGET (priv->channel), show_freq);
gtk_widget_set_visible (widget_bssid_label, show_bssid);
gtk_widget_set_sensitive (widget_bssid_label, show_bssid);
gtk_widget_set_visible (GTK_WIDGET (priv->bssid), show_bssid);
gtk_widget_set_sensitive (GTK_WIDGET (priv->bssid), show_bssid);
ce_page_changed (CE_PAGE (self));
}
static void
remove_row (GtkButton *button, CEPageIP6 *page)
{
GtkWidget *row;
GtkWidget *row_box;
GtkWidget *list;
row_box = gtk_widget_get_parent (GTK_WIDGET (button));
row = gtk_widget_get_parent (row_box);
list = gtk_widget_get_parent (row);
gtk_container_remove (GTK_CONTAINER (list), row);
ce_page_changed (CE_PAGE (page));
update_row_sensitivity (page, list);
}
static void
use_mppe_toggled_cb (GtkToggleButton *widget, CEPagePpp *self)
{
CEPagePppPrivate *priv = CE_PAGE_PPP_GET_PRIVATE (self);
if (gtk_toggle_button_get_active (widget)) {
gtk_widget_set_sensitive (GTK_WIDGET (priv->mppe_require_128), TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (priv->use_mppe_stateful), TRUE);
} else {
gtk_widget_set_sensitive (GTK_WIDGET (priv->mppe_require_128), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->mppe_require_128), FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (priv->use_mppe_stateful), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->use_mppe_stateful), FALSE);
}
ce_page_changed (CE_PAGE (self));
}
static void
pfc_dialog_show (CEPageDcb *self)
{
CEPageDcbPrivate *priv = CE_PAGE_DCB_GET_PRIVATE (self);
CEPage *parent = CE_PAGE (self);
GtkWidget *dialog, *toplevel;
GtkToggleButton *check;
gint result;
guint i;
gboolean active;
char *tmp;
dialog = GTK_WIDGET (gtk_builder_get_object (parent->builder, "pfc_dialog"));
g_assert (dialog);
toplevel = gtk_widget_get_toplevel (parent->page);
if (gtk_widget_is_toplevel (toplevel))
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (toplevel));
/* Set the initial value */
for (i = 0; i < 8; i++ ) {
tmp = g_strdup_printf ("pfc_prio%u_checkbutton", i);
check = GTK_TOGGLE_BUTTON (gtk_builder_get_object (parent->builder, tmp));
g_free (tmp);
g_assert (check);
gtk_toggle_button_set_active (check, nm_setting_dcb_get_priority_flow_control (priv->options, i));
}
/* Run the dialog */
result = gtk_dialog_run (GTK_DIALOG (dialog));
if (result == GTK_RESPONSE_OK) {
for (i = 0; i < 8; i++ ) {
tmp = g_strdup_printf ("pfc_prio%u_checkbutton", i);
check = GTK_TOGGLE_BUTTON (gtk_builder_get_object (parent->builder, tmp));
g_free (tmp);
g_assert (check);
active = gtk_toggle_button_get_active (check);
nm_setting_dcb_set_priority_flow_control (priv->options, i, active);
}
}
gtk_widget_hide (dialog);
ce_page_changed (CE_PAGE (self));
}
static void
auth_methods_dialog_response_cb (GtkWidget *dialog, gint response, gpointer user_data)
{
CEPagePpp *self = CE_PAGE_PPP (user_data);
CEPagePppPrivate *priv = CE_PAGE_PPP_GET_PRIVATE (self);
if (response == GTK_RESPONSE_OK) {
ppp_auth_methods_dialog_get_methods (dialog,
&priv->refuse_eap,
&priv->refuse_pap,
&priv->refuse_chap,
&priv->refuse_mschap,
&priv->refuse_mschapv2);
ce_page_changed (CE_PAGE (self));
update_auth_methods_list (self);
}
auth_methods_dialog_close_cb (dialog, NULL);
}
static void
parent_changed (GtkWidget *widget, gpointer user_data)
{
CEPageVlan *self = user_data;
CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);
int parent_id;
parent_id = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->parent));
if (parent_id > -1 && priv->parents[parent_id]->device != NULL) {
gtk_widget_set_sensitive (GTK_WIDGET (priv->cloned_mac), TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (priv->mtu), TRUE);
} else {
gtk_widget_set_sensitive (GTK_WIDGET (priv->cloned_mac), FALSE);
gtk_entry_set_text (priv->cloned_mac, "");
gtk_widget_set_sensitive (GTK_WIDGET (priv->mtu), FALSE);
gtk_spin_button_set_value (priv->mtu, 1500);
}
sync_iface (self, priv->parent_entry);
ce_page_changed (CE_PAGE (self));
}
static void
wireless_security_combo_changed (GtkComboBox *combo,
gpointer user_data)
{
CEPageWirelessSecurity *self = CE_PAGE_WIRELESS_SECURITY (user_data);
GtkWidget *vbox;
GList *elt, *children;
WirelessSecurity *sec;
vbox = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (self)->builder, "wireless_security_vbox"));
g_assert (vbox);
wsec_size_group_clear (self->group);
/* Remove any previous wireless security widgets */
children = gtk_container_get_children (GTK_CONTAINER (vbox));
for (elt = children; elt; elt = g_list_next (elt))
gtk_container_remove (GTK_CONTAINER (vbox), GTK_WIDGET (elt->data));
sec = wireless_security_combo_get_active (self);
if (sec) {
GtkWidget *sec_widget;
GtkWidget *widget, *parent;
sec_widget = wireless_security_get_widget (sec);
g_assert (sec_widget);
parent = gtk_widget_get_parent (sec_widget);
if (parent)
gtk_container_remove (GTK_CONTAINER (parent), sec_widget);
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (self)->builder, "wireless_security_combo_label"));
gtk_size_group_add_widget (self->group, widget);
wireless_security_add_to_size_group (sec, self->group);
gtk_container_add (GTK_CONTAINER (vbox), sec_widget);
wireless_security_unref (sec);
}
ce_page_changed (CE_PAGE (self));
}
static void
method_changed (GtkComboBox *combo, CEPageIP6 *page)
{
gboolean addr_enabled;
gboolean dns_enabled;
gboolean routes_enabled;
guint method;
GtkWidget *widget;
method = gtk_combo_box_get_active (combo);
switch (method) {
case IP6_METHOD_AUTO:
case IP6_METHOD_DHCP:
addr_enabled = FALSE;
dns_enabled = TRUE;
routes_enabled = TRUE;
break;
case IP6_METHOD_MANUAL:
addr_enabled = TRUE;
dns_enabled = TRUE;
routes_enabled = TRUE;
break;
case IP6_METHOD_LINK_LOCAL:
default:
addr_enabled = FALSE;
dns_enabled = FALSE;
routes_enabled = FALSE;
break;
}
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "address_section"));
gtk_widget_set_visible (widget, addr_enabled);
gtk_widget_set_sensitive (page->dns_list, dns_enabled);
gtk_widget_set_sensitive (page->routes_list, routes_enabled);
gtk_widget_set_sensitive (page->never_default, routes_enabled);
ce_page_changed (CE_PAGE (page));
}
static void
enable_toggled_cb (GtkToggleButton *button, EnableInfo *info)
{
gboolean enabled = gtk_toggle_button_get_active (button);
GtkWidget *widget;
/* Set other feature widgets sensitive or not depending on enabled */
widget = get_widget (info->page->builder, info->f->prefix, "_advertise_checkbutton");
gtk_widget_set_sensitive (widget, enabled);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
widget = get_widget (info->page->builder, info->f->prefix, "_willing_checkbutton");
gtk_widget_set_sensitive (widget, enabled);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
if (info->f->priority_prop) {
widget = get_widget (info->page->builder, info->f->prefix, "_priority_combo");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_set_sensitive (widget, enabled);
}
if (info->f->options_func) {
widget = get_widget (info->page->builder, info->f->prefix, "_options_button");
gtk_widget_set_sensitive (widget, enabled);
}
/* FCoE mode combo */
if (!strcmp (info->f->prefix, "fcoe")) {
widget = get_widget (info->page->builder, info->f->prefix, "_mode_combo");
gtk_widget_set_sensitive (widget, enabled);
}
if (info->f->enabled_func)
info->f->enabled_func (CE_PAGE_DCB (info->page), gtk_toggle_button_get_active (button));
ce_page_changed (info->page);
}
static void
security_combo_changed (GtkComboBox *combo,
gpointer user_data)
{
CEPageSecurity *page = CE_PAGE_SECURITY (user_data);
GtkWidget *vbox;
GList *l, *children;
WirelessSecurity *sec;
wsec_size_group_clear (page->group);
vbox = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "vbox"));
children = gtk_container_get_children (GTK_CONTAINER (vbox));
for (l = children; l; l = l->next) {
gtk_container_remove (GTK_CONTAINER (vbox), GTK_WIDGET (l->data));
}
sec = security_combo_get_active (page);
if (sec) {
GtkWidget *sec_widget;
GtkWidget *parent;
sec_widget = wireless_security_get_widget (sec);
g_assert (sec_widget);
parent = gtk_widget_get_parent (sec_widget);
if (parent)
gtk_container_remove (GTK_CONTAINER (parent), sec_widget);
gtk_size_group_add_widget (page->group, page->security_heading);
gtk_size_group_add_widget (page->group, page->firewall_heading);
wireless_security_add_to_size_group (sec, page->group);
gtk_container_add (GTK_CONTAINER (vbox), sec_widget);
wireless_security_unref (sec);
}
ce_page_changed (CE_PAGE (page));
}
static void
band_value_changed_cb (GtkComboBox *box, gpointer user_data)
{
CEPageWifi *self = CE_PAGE_WIFI (user_data);
CEPageWifiPrivate *priv = CE_PAGE_WIFI_GET_PRIVATE (self);
gboolean sensitive;
priv->last_channel = 0;
gtk_spin_button_set_value (priv->channel, 0);
switch (gtk_combo_box_get_active (GTK_COMBO_BOX (box))) {
case 1: /* A */
case 2: /* B/G */
sensitive = TRUE;
break;
default:
sensitive = FALSE;
break;
}
gtk_widget_set_sensitive (GTK_WIDGET (priv->channel), sensitive);
ce_page_changed (CE_PAGE (self));
}
static void
stuff_changed_cb (WirelessSecurity *sec, gpointer user_data)
{
ce_page_changed (CE_PAGE (user_data));
}
static void
cell_edited (GtkCellRendererText *cell,
const gchar *path_string,
const gchar *new_text,
gpointer user_data)
{
CEPageIP4 *self = CE_PAGE_IP4 (user_data);
CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self);
GtkListStore *store = GTK_LIST_STORE (gtk_tree_view_get_model (priv->addr_list));
GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
GtkTreeIter iter;
guint32 column;
GtkTreeViewColumn *next_col;
GtkCellRenderer *next_cell;
gboolean can_cycle;
int direction, tmp;
/* Free auxiliary stuff */
g_free (priv->last_edited);
priv->last_edited = NULL;
g_free (priv->last_path);
priv->last_path = NULL;
priv->last_column = -1;
column = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (cell), "column"));
gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path);
gtk_list_store_set (store, &iter, column, new_text, -1);
/* Try to autodetect the prefix from the given address if we can */
if (column == COL_ADDRESS && new_text && strlen (new_text)) {
char *prefix = NULL;
const char *guess_prefix = NULL;
gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &iter, path_string);
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, COL_PREFIX, &prefix, -1);
if (!prefix || !strlen (prefix)) {
if (!strncmp ("10.", new_text, 3))
guess_prefix = "8";
else if (!strncmp ("172.16.", new_text, 7))
guess_prefix = "16";
else if (!strncmp ("192.168.", new_text, 8))
guess_prefix = "24";
if (guess_prefix)
gtk_list_store_set (store, &iter, COL_PREFIX, guess_prefix, -1);
}
g_free (prefix);
}
/* Move focus to the next/previous column */
can_cycle = g_object_get_data (G_OBJECT (cell), DO_NOT_CYCLE_TAG) == NULL;
direction = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), DIRECTION_TAG));
g_object_set_data (G_OBJECT (cell), DIRECTION_TAG, NULL);
g_object_set_data (G_OBJECT (cell), DO_NOT_CYCLE_TAG, NULL);
if (direction == 0) /* Move forward by default */
direction = 1;
tmp = column + direction;
if (can_cycle)
column = tmp < 0 ? COL_LAST : tmp > COL_LAST ? 0 : tmp;
else
column = tmp;
next_col = gtk_tree_view_get_column (priv->addr_list, column);
next_cell = column <= COL_LAST ? priv->addr_cells[column] : NULL;
gtk_tree_view_set_cursor_on_cell (priv->addr_list, path, next_col, next_cell, TRUE);
gtk_tree_path_free (path);
ce_page_changed (CE_PAGE (self));
}
static void
vpn_plugin_changed_cb (NMVpnPluginUiInterface *plugin, CEPageVpn *self)
{
ce_page_changed (CE_PAGE (self));
}
static void
method_changed (GtkComboBox *combo, gpointer user_data)
{
CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (user_data);
guint32 method = IP4_METHOD_AUTO;
gboolean addr_enabled = FALSE;
gboolean dns_enabled = FALSE;
gboolean dhcp_enabled = FALSE;
gboolean routes_enabled = FALSE;
gboolean ip4_required_enabled = TRUE;
gboolean method_auto = FALSE;
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter (priv->method, &iter)) {
gtk_tree_model_get (GTK_TREE_MODEL (priv->method_store), &iter,
METHOD_COL_NUM, &method, -1);
}
switch (method) {
case IP4_METHOD_AUTO:
addr_enabled = FALSE;
dhcp_enabled = routes_enabled = TRUE;
dns_enabled = TRUE;
method_auto = TRUE;
break;
case IP4_METHOD_AUTO_ADDRESSES:
addr_enabled = FALSE;
dns_enabled = dhcp_enabled = routes_enabled = TRUE;
break;
case IP4_METHOD_MANUAL:
addr_enabled = dns_enabled = routes_enabled = TRUE;
break;
case IP4_METHOD_DISABLED:
addr_enabled = dns_enabled = dhcp_enabled = routes_enabled = ip4_required_enabled = FALSE;
default:
break;
}
/* Disable DHCP stuff for VPNs (though in the future we should support
* DHCP over tap interfaces for OpenVPN and vpnc).
*/
if ( priv->connection_type == NM_TYPE_SETTING_VPN
|| priv->connection_type == NM_TYPE_SETTING_GSM
|| priv->connection_type == NM_TYPE_SETTING_CDMA
|| priv->connection_type == NM_TYPE_SETTING_PPPOE)
dhcp_enabled = FALSE;
gtk_widget_set_sensitive (priv->addr_label, addr_enabled);
gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_add), addr_enabled);
gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_delete), addr_enabled);
gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_list), addr_enabled);
if (!addr_enabled) {
GtkListStore *store;
store = GTK_LIST_STORE (gtk_tree_view_get_model (priv->addr_list));
gtk_list_store_clear (store);
}
gtk_widget_set_sensitive (priv->dns_servers_label, dns_enabled);
if (method_auto)
gtk_label_set_text_with_mnemonic (GTK_LABEL (priv->dns_servers_label), _("Additional DNS ser_vers:"));
else
gtk_label_set_text_with_mnemonic (GTK_LABEL (priv->dns_servers_label), _("DNS ser_vers:"));
gtk_widget_set_sensitive (GTK_WIDGET (priv->dns_servers), dns_enabled);
if (!dns_enabled)
gtk_entry_set_text (priv->dns_servers, "");
gtk_widget_set_sensitive (priv->dns_searches_label, dns_enabled);
if (method_auto)
gtk_label_set_text_with_mnemonic (GTK_LABEL (priv->dns_searches_label), _("Additional s_earch domains:"));
else
gtk_label_set_text_with_mnemonic (GTK_LABEL (priv->dns_searches_label), _("S_earch domains:"));
gtk_widget_set_sensitive (GTK_WIDGET (priv->dns_searches), dns_enabled);
if (!dns_enabled)
gtk_entry_set_text (priv->dns_searches, "");
gtk_widget_set_sensitive (priv->dhcp_client_id_label, dhcp_enabled);
gtk_widget_set_sensitive (GTK_WIDGET (priv->dhcp_client_id), dhcp_enabled);
if (!dhcp_enabled)
gtk_entry_set_text (priv->dhcp_client_id, "");
gtk_widget_set_sensitive (GTK_WIDGET (priv->ip4_required), ip4_required_enabled);
gtk_widget_set_sensitive (GTK_WIDGET (priv->routes_button), routes_enabled);
ce_page_changed (CE_PAGE (user_data));
}
static void
vpn_plugin_changed_cb (NMVpnEditorPlugin *plugin, CEPageVpn *self)
{
ce_page_changed (CE_PAGE (self));
}
static void
pg_dialog_show (CEPageDcb *self)
{
CEPageDcbPrivate *priv = CE_PAGE_DCB_GET_PRIVATE (self);
CEPage *parent = CE_PAGE (self);
GtkWidget *dialog, *toplevel;
gint result;
dialog = GTK_WIDGET (gtk_builder_get_object (parent->builder, "pg_dialog"));
g_assert (dialog);
toplevel = gtk_widget_get_toplevel (parent->page);
if (gtk_widget_is_toplevel (toplevel))
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (toplevel));
combos_handle (parent->builder,
priv->options,
"pg_pgid%u_combo",
7,
8,
15,
nm_setting_dcb_get_priority_group_id,
NULL);
uint_entries_handle (parent->builder,
priv->options,
"pg_pgpct%u_entry",
nm_setting_dcb_get_priority_group_bandwidth,
NULL);
uint_entries_handle (parent->builder,
priv->options,
"pg_uppct%u_entry",
nm_setting_dcb_get_priority_bandwidth,
NULL);
bool_entries_handle (parent->builder,
priv->options,
"pg_strict%u_checkbutton",
nm_setting_dcb_get_priority_strict_bandwidth,
NULL);
combos_handle (parent->builder,
priv->options,
"pg_up2tc%u_combo",
7,
0,
0,
nm_setting_dcb_get_priority_traffic_class,
NULL);
pg_dialog_valid_func (parent->builder);
/* Run the dialog */
result = gtk_dialog_run (GTK_DIALOG (dialog));
if (result == GTK_RESPONSE_OK) {
combos_handle (parent->builder,
priv->options,
"pg_pgid%u_combo",
7,
8,
15,
NULL,
nm_setting_dcb_set_priority_group_id);
uint_entries_handle (parent->builder,
priv->options,
"pg_pgpct%u_entry",
NULL,
nm_setting_dcb_set_priority_group_bandwidth);
uint_entries_handle (parent->builder,
priv->options,
"pg_uppct%u_entry",
NULL,
nm_setting_dcb_set_priority_bandwidth);
bool_entries_handle (parent->builder,
priv->options,
"pg_strict%u_checkbutton",
NULL,
nm_setting_dcb_set_priority_strict_bandwidth);
combos_handle (parent->builder,
priv->options,
"pg_up2tc%u_combo",
7,
0,
0,
NULL,
nm_setting_dcb_set_priority_traffic_class);
}
gtk_widget_hide (dialog);
ce_page_changed (CE_PAGE (self));
}
static void
stuff_changed (GtkWidget *w, gpointer user_data)
{
ce_page_changed (CE_PAGE (user_data));
}
static void
stuff_changed (GtkEditable *editable, gpointer user_data)
{
ce_page_changed (CE_PAGE (user_data));
}
