Ticket #3070: proxy_gsettings.patch

extensions/cpsection/network/view.py

@@ -13 +13 @@
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+from gettext import gettext as _
+import logging
 
 from gi.repository import Gtk
 from gi.repository import Gdk
 from gi.repository import GObject
-from gettext import gettext as _
+from gi.repository import Gio
+from gi.repository import GLib
+from gi.repository import Pango
 
 from sugar3.graphics import style
 
@@ -32 +36 @@
 _APPLY_TIMEOUT = 3000
 
 
+class GSettingsMixin(object):
+    """
+    Mix-in class for GTK widgets backed by GSettings.
+    """
+    def __init__(self, setting_schema, setting_key, widget=None,
+                 signal='changed'):
+        self._timeout_id = None
+        self._gsettings = Gio.Settings.new(setting_schema)
+        self._setting_key = setting_key
+
+        # Get the GSettings type for the key in the format of the XML,
+        # for example 's' for string.
+        gvalue = self._gsettings.get_value(self._setting_key)
+        self._setting_key_type = gvalue.get_type_string()
+
+        self._gsettings.connect('changed', self.__settings_changed_cb)
+        initial_value = self._get_gsettings_value()
+        self._undo_value = initial_value
+        self.set_value_from_gsettings(initial_value)
+        widget = widget or self
+        widget.connect(signal, self.__changed_cb)
+
+    def undo(self):
+        """
+        Revert to original value.
+        """
+        self._set_gsettings_value(self._undo_value)
+
+    def get_value_for_gsettings(self):
+        """
+        Apply the current value of the widget to GSettings.
+
+        MUST be implemented by subclasses.
+        """
+        raise NotImplementedError()
+
+    def set_value_from_gsettings(self, value):
+        """
+        Set the current value of the widget from GSettings.
+
+        MUST be implemented by subclasses.
+        """
+        raise NotImplementedError()
+
+    def __settings_changed_cb(self, settings, key):
+        if key != self._setting_key:
+            return
+        value = self._get_gsettings_value()
+        self.set_value_from_gsettings(value)
+
+    def __changed_cb(self, widget):
+        if self._timeout_id is not None:
+            GLib.source_remove(self._timeout_id)
+
+        self._timeout_id = GLib.timeout_add(_APPLY_TIMEOUT, self._commit,
+                                            widget)
+
+    def _commit(self, widget):
+        new_value = self.get_value_for_gsettings()
+        logging.debug('Setting %r %r to %r', self._gsettings.props.path,
+                      self._setting_key, new_value)
+
+        widget.handler_block_by_func(self.__changed_cb)
+        try:
+            self._set_gsettings_value(new_value)
+        finally:
+            widget.handler_unblock_by_func(self.__changed_cb)
+
+    def _get_gsettings_value(self):
+        return self._gsettings.get_value(self._setting_key).unpack()
+
+    def _set_gsettings_value(self, value):
+        if self._setting_key_type == 's':
+            self._gsettings.set_string(self._setting_key, value)
+        elif self._setting_key_type == 'i':
+            self._gsettings.set_int(self._setting_key, value)
+        elif self._setting_key_type == 'b':
+            self._gsettings.set_boolean(self._setting_key, value)
+        else:
+            raise TypeError('Cannot set %r with type %r to GSettings' %
+                            (self._setting_key, self._setting_key_type))
+
+
+class GSettingsEntry(Gtk.Entry, GSettingsMixin):
+    """
+    Text entry backed by GSettings
+    """
+    def __init__(self, setting_schema, setting_key):
+        Gtk.Entry.__init__(self)
+        GSettingsMixin.__init__(self, setting_schema, setting_key)
+
+    def get_value_for_gsettings(self):
+        return self.props.text
+
+    def set_value_from_gsettings(self, value):
+        self.props.text = value
+
+
+class GSettingsIntegerSpinButton(Gtk.SpinButton, GSettingsMixin):
+    """
+    Integer SpinButton backed by GSettings
+    """
+    def __init__(self, setting_schema, setting_key, adjustment, climb_rate=0):
+        Gtk.SpinButton.__init__(self, adjustment=adjustment,
+                                climb_rate=climb_rate)
+        GSettingsMixin.__init__(self, setting_schema, setting_key)
+
+    def get_value_for_gsettings(self):
+        return self.get_value_as_int()
+
+    def set_value_from_gsettings(self, value):
+        self.set_value(value)
+
+
+class SettingBox(Gtk.HBox):
+    """
+    Base class for "lines" on the screen representing configuration
+    settings.
+    """
+    def __init__(self, name, size_group=None):
+        Gtk.HBox.__init__(self, spacing=style.DEFAULT_SPACING)
+        label = Gtk.Label(name)
+        label.modify_fg(Gtk.StateType.NORMAL,
+                        style.COLOR_SELECTION_GREY.get_gdk_color())
+        label.set_alignment(1, 0.5)
+        if size_group is not None:
+            size_group.add_widget(label)
+        self.pack_start(label, False, False, 0)
+        label.show()
+
+
+class ComboSettingBox(Gtk.VBox, GSettingsMixin):
+    """
+    Container for sets of different settings selected by a top-level
+    setting.
+
+    Renders the top level setting as a ComboBox.  Only the currently
+    active set is shown on screen.
+    """
+    def __init__(self, name, setting_schema, setting_key,
+                 option_sets, size_group=None):
+        Gtk.VBox.__init__(self, spacing=style.DEFAULT_SPACING)
+
+        setting_box = SettingBox(name, size_group)
+        self.pack_start(setting_box, False, False, 0)
+        setting_box.show()
+
+        display_sets = [(name, widget) for name, value, widget in option_sets]
+        self._options_mapping = dict([(name, value)
+                                      for name, value, widget in option_sets])
+
+        model = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_OBJECT)
+        self._combobox = Gtk.ComboBox(model=model)
+        self._combobox.connect('changed', self.__combo_changed_cb)
+        setting_box.pack_start(self._combobox, True, True, 0)
+        self._combobox.show()
+
+        cell_renderer = Gtk.CellRendererText()
+        cell_renderer.props.ellipsize = Pango.EllipsizeMode.MIDDLE
+        cell_renderer.props.ellipsize_set = True
+        self._combobox.pack_start(cell_renderer, True)
+        self._combobox.add_attribute(cell_renderer, 'text', 0)
+
+        self._settings_box = Gtk.VBox()
+        self._settings_box.show()
+        self.pack_start(self._settings_box, False, False, 0)
+
+        for name, box in display_sets:
+            model.append((name, box))
+
+        GSettingsMixin.__init__(self, setting_schema, setting_key,
+                                self._combobox)
+
+    def __combo_changed_cb(self, combobox):
+        giter = combobox.get_active_iter()
+        new_box = combobox.get_model().get(giter, 1)[0]
+        current_box = self._settings_box.get_children()
+        if current_box:
+            self._settings_box.remove(current_box[0])
+
+        self._settings_box.add(new_box)
+        new_box.show()
+
+    def get_value_for_gsettings(self):
+        giter = self._combobox.get_active_iter()
+        if giter is None:
+            return 'none'
+        name = self._combobox.get_model().get(giter, 0)[0]
+        return self._options_mapping[name]
+
+    def set_value_from_gsettings(self, value):
+        for idx, (name, widget_) in enumerate(self._combobox.get_model()):
+            if self._options_mapping[name] == value:
+                self._combobox.set_active(idx)
+                return
+
+        raise ValueError('Invalid value %r' % (value, ))
+
+
+class OptionalSettingsBox(Gtk.VBox, GSettingsMixin):
+    """
+    Container for settings (de)activated by a top-level setting.
+
+    Renders the top level setting as a CheckButton. The settings are only
+    shown on screen if the top-level setting is enabled.
+    """
+    def __init__(self, name, setting_schema, setting_key, contents_box):
+        Gtk.VBox.__init__(self, spacing=style.DEFAULT_SPACING)
+
+        self._contents_box = contents_box
+
+        self._check_button = Gtk.CheckButton()
+        self._check_button.props.label = name
+        self._check_button.connect('toggled', self.__button_changed_cb)
+        self._check_button.show()
+        self.pack_start(self._check_button, True, True, 0)
+
+        self.pack_start(contents_box, False, False, 0)
+
+        GSettingsMixin.__init__(self, setting_schema, setting_key,
+                                self._check_button, signal='toggled')
+
+    def __button_changed_cb(self, check_button):
+        self._contents_box.set_visible(check_button.get_active())
+
+    def get_value_for_gsettings(self):
+        return self._check_button.get_active()
+
+    def set_value_from_gsettings(self, value):
+        self._check_button.set_active(value)
+
+
+class HostPortSettingBox(SettingBox):
+    """
+    A configuration line for a combined host name and port setting.
+    """
+    def __init__(self, name, setting_schema, size_group=None):
+        SettingBox.__init__(self, name, size_group)
+
+        self._host_name_entry = GSettingsEntry(setting_schema, 'host')
+        self.pack_start(self._host_name_entry, True, True, 0)
+        self._host_name_entry.show()
+
+        # port number 0 means n/a
+        adjustment = Gtk.Adjustment(0, 0, 65535, 1, 10)
+        self._port_spin_button = GSettingsIntegerSpinButton(
+            setting_schema, 'port', adjustment=adjustment, climb_rate=0.1)
+        self.pack_start(self._port_spin_button, False, False, 0)
+        self._port_spin_button.show()
+
+    def undo(self):
+        self._host_name_entry.undo()
+        self._port_spin_button.undo()
+
+
+class StringSettingBox(SettingBox, GSettingsMixin):
+    """
+    A configuration line for a string setting.
+    """
+    def __init__(self, name, setting_schema, setting_key, size_group=None):
+        SettingBox.__init__(self, name, size_group)
+
+        self._string_entry = Gtk.Entry()
+        self.pack_start(self._string_entry, True, True, 0)
+        self._string_entry.show()
+
+        GSettingsMixin.__init__(self, setting_schema, setting_key,
+                                self._string_entry)
+
+    def get_value_for_gsettings(self):
+        return self._string_entry.props.text
+
+    def set_value_from_gsettings(self, value):
+        self._string_entry.props.text = value
+
+
 class Network(SectionView):
     def __init__(self, model, alerts):
         SectionView.__init__(self)
@@ -44 +324 @@
         self._jabber_change_handler = None
         self._radio_change_handler = None
         self._network_configuration_reset_handler = None
+        self._undo_settings = []
 
         self.set_border_width(style.DEFAULT_SPACING * 2)
         self.set_spacing(style.DEFAULT_SPACING)
@@ -174 +455 @@
         workspace.pack_start(box_mesh, False, True, 0)
         box_mesh.show()
 
+        separator_proxy = Gtk.HSeparator()
+        workspace.pack_start(separator_proxy, False, False, 0)
+        separator_proxy.show()
+
+        self._add_proxy_section(workspace)
+
         self.setup()
 
+    def _add_proxy_section(self, workspace):
+        label_proxy = Gtk.Label(_('Proxy'))
+        label_proxy.set_alignment(0, 0)
+        workspace.pack_start(label_proxy, False, True, 0)
+        label_proxy.show()
+
+        box_proxy = Gtk.VBox()
+        box_proxy.set_border_width(style.DEFAULT_SPACING * 2)
+        box_proxy.set_spacing(style.DEFAULT_SPACING)
+        workspace.pack_start(box_proxy, False, True, 0)
+        box_proxy.show()
+
+        size_group = Gtk.SizeGroup(Gtk.SizeGroupMode.HORIZONTAL)
+
+        automatic_proxy_box = Gtk.VBox(spacing=style.DEFAULT_SPACING)
+        manual_proxy_box = Gtk.VBox(spacing=style.DEFAULT_SPACING)
+
+        option_sets = [('None', 'none', Gtk.VBox()),
+                        ('Automatic', 'auto', automatic_proxy_box),
+                        ('Manual', 'manual', manual_proxy_box)]
+
+        box_mode = ComboSettingBox(_('Method:'), 'org.gnome.system.proxy',
+                                   'mode', option_sets, size_group)
+        self._undo_settings.append(box_mode)
+        box_proxy.pack_start(box_mode, False, False, 0)
+        box_mode.show()
+
+        url_box = StringSettingBox(_('Configuration URL:'),
+                                   'org.gnome.system.proxy', 'autoconfig-url',
+                                   size_group)
+        self._undo_settings.append(url_box)
+        automatic_proxy_box.pack_start(url_box, True, True, 0)
+        url_box.show()
+
+        wpad_help_text = _('Web Proxy Autodiscovery (WPAD) is used when a'
+                           ' Configuration URL is not provided. This is not'
+                           ' recommended for untrusted public networks.')
+        automatic_proxy_help = Gtk.Label(wpad_help_text)
+        automatic_proxy_help.set_alignment(0, 0)
+        automatic_proxy_help.set_line_wrap(True)
+        automatic_proxy_help.show()
+        automatic_proxy_box.pack_start(automatic_proxy_help, True, True, 0)
+
+        box_http = HostPortSettingBox(_('HTTP Proxy:'),
+                                      'org.gnome.system.proxy.http',
+                                      size_group)
+        self._undo_settings.append(box_http)
+        manual_proxy_box.pack_start(box_http, False, False, 0)
+        box_http.show()
+
+        auth_contents_box = Gtk.VBox(spacing=style.DEFAULT_SPACING)
+
+        auth_box = OptionalSettingsBox(_('Use authentication'),
+                                       'org.gnome.system.proxy.http',
+                                       'use-authentication',
+                                       auth_contents_box)
+        self._undo_settings.append(auth_box)
+        manual_proxy_box.pack_start(auth_box, False, False, 0)
+        auth_box.show()
+
+        box_username = StringSettingBox(_('Username:'),
+                                        'org.gnome.system.proxy.http',
+                                        'authentication-user',
+                                        size_group)
+        self._undo_settings.append(box_username)
+        auth_contents_box.pack_start(box_username, False, False, 0)
+        box_username.show()
+
+        box_password = StringSettingBox(_('Password:'),
+                                        'org.gnome.system.proxy.http',
+                                        'authentication-password',
+                                        size_group)
+        self._undo_settings.append(box_password)
+        auth_contents_box.pack_start(box_password, False, False, 0)
+        box_password.show()
+
+        box_https = HostPortSettingBox(_('HTTPS Proxy:'),
+                                      'org.gnome.system.proxy.https',
+                                       size_group)
+        self._undo_settings.append(box_https)
+        manual_proxy_box.pack_start(box_https, False, False, 0)
+        box_https.show()
+
+        box_ftp = HostPortSettingBox(_('FTP Proxy:'),
+                                     'org.gnome.system.proxy.ftp',
+                                     size_group)
+        self._undo_settings.append(box_ftp)
+        manual_proxy_box.pack_start(box_ftp, False, False, 0)
+        box_ftp.show()
+
+        box_socks = HostPortSettingBox(_('SOCKS Proxy:'),
+                                      'org.gnome.system.proxy.socks',
+                                       size_group)
+        self._undo_settings.append(box_socks)
+        manual_proxy_box.pack_start(box_socks, False, False, 0)
+        box_socks.show()
+
     def setup(self):
         self._entry.set_text(self._model.get_jabber())
         try:
@@ -203 +587 @@
         self._model.undo()
         self._jabber_alert.hide()
         self._radio_alert.hide()
+        for setting in self._undo_settings:
+            setting.undo()
 
     def _validate(self):
         if self._jabber_valid and self._radio_valid: