GitLab

at 2020-09-05T00:32:08+02:00

Remove print statement

Settings: Bind sensitive state to setting signal

             for handler in list(handlers):

                 func = handler()

                 if func is None or func.__self__ is object_:

-                    print('remove handler', handler)

                     handlers.remove(handler)

 

     def _notify(self, value, setting, account=None, jid=None):

                     desc=_('Recognize your account by color')),

 

             Setting(SettingKind.LOGIN, _('Login'), SettingType.DIALOG,

+                    bind='anonymous_auth',

+                    inverted=True,

                     props={'dialog': LoginDialog}),

 

             Setting(SettingKind.ACTION, _('Import Contacts'),

 

         settings = [

             Setting(SettingKind.SWITCH, _('Adjust to status'),

-                    SettingType.ACCOUNT_CONFIG, 'adjust_priority_with_status',

-                    'adjust'),

+                    SettingType.ACCOUNT_CONFIG,

+                    'adjust_priority_with_status'),

 

             Setting(SettingKind.SPIN, _('Priority'),

-                    SettingType.ACCOUNT_CONFIG, 'priority',

-                    enabledif=('adjust', False), props={'range_': range_}),

+                    SettingType.ACCOUNT_CONFIG,

+                    'priority',

+                    bind='adjust_priority_with_status',

+                    inverted=True,

+                    props={'range_': range_}),

             ]

 

         SettingsDialog.__init__(self, parent, _('Priority'),

         settings = [

             Setting(SettingKind.SWITCH, _('Enable'),

                     SettingType.ACCOUNT_CONFIG,

-                    'use_custom_host', name='custom'),

+                    'use_custom_host'),

 

             Setting(SettingKind.ENTRY, _('Hostname'),

                     SettingType.ACCOUNT_CONFIG, 'custom_host',

-                    enabledif=('custom', True)),

+                    bind='use_custom_host'),

 

             Setting(SettingKind.ENTRY, _('Port'),

                     SettingType.ACCOUNT_CONFIG, 'custom_port',

-                    enabledif=('custom', True)),

+                    bind='use_custom_host'),

 

             Setting(SettingKind.COMBO, _('Type'),

                     SettingType.ACCOUNT_CONFIG, 'custom_type',

-                    enabledif=('custom', True),

+                    bind='use_custom_host',

                     props={'combo_items': type_values}),

             ]

 

 

         settings = [

             Setting(SettingKind.ENTRY, _('Password'),

-                    SettingType.ACCOUNT_CONFIG, 'password', name='password',

-                    enabledif=('savepass', True)),

+                    SettingType.ACCOUNT_CONFIG, 'password',

+                    bind='savepass'),

 

             Setting(SettingKind.SWITCH, _('Save Password'),

-                    SettingType.ACCOUNT_CONFIG, 'savepass', name='savepass'),

+                    SettingType.ACCOUNT_CONFIG, 'savepass'),

 

             Setting(SettingKind.CHANGEPASSWORD, _('Change Password'),

                     SettingType.DIALOG, callback=self.on_password_change,

 Filter = namedtuple('Filter', 'name pattern default')

 

 Setting = namedtuple('Setting', 'kind label type value name callback data desc '

-                                'enabledif enabled_func props')

+                                'bind inverted enabled_func props')

 Setting.__new__.__defaults__ = (None,) * len(Setting._fields)  # type: ignore

 

 @unique

 from gi.repository import Gtk

 from gi.repository import GLib

 from gi.repository import Gdk

-from gi.repository import GObject

 from gi.repository import Pango

 

 from gajim.common import app

                     self.account, *setting[1:-1], **setting.props)

             else:

                 listitem = self.map[setting.kind](self.account, *setting[1:-1])

-        listitem.connect('notify::setting-value', self.on_setting_changed)

+

         if setting.name is not None:

             self.named_settings[setting.name] = listitem

         self.add(listitem)

         return self.named_settings[name]

 

     def update_states(self):

-        values = []

-        values.append((None, None))

-        for row in self.get_children():

-            name = row.name

-            if name is None:

-                continue

-            value = row.get_property('setting-value')

-            values.append((name, value))

-

-        for name, value in values:

-            for row in self.get_children():

-                row.update_activatable(name, value)

-

-    def on_setting_changed(self, widget, *args):

-        value = widget.get_property('setting-value')

         for row in self.get_children():

-            row.update_activatable(widget.name, value)

+            row.update_activatable()

 

 

 class GenericSetting(Gtk.ListBoxRow):

-    def __init__(self, account, label, type_, value,

-                 name, callback, data, desc, enabledif, enabled_func):

+    def __init__(self,

+                 account,

+                 label,

+                 type_,

+                 value,

+                 name,

+                 callback,

+                 data,

+                 desc,

+                 bind,

+                 inverted,

+                 enabled_func):

         Gtk.ListBoxRow.__init__(self)

         self._grid = Gtk.Grid()

         self._grid.set_size_request(-1, 30)

         self.label = label

         self.account = account

         self.name = name

-        self.enabledif = enabledif

+        self.bind = bind

+        self.inverted = inverted

         self.enabled_func = enabled_func

         self.setting_value = self.get_value()

 

         self._grid.add(self.setting_box)

         self.add(self._grid)

 

-    def do_get_property(self, prop):

-        if prop.name == 'setting-value':

-            return self.setting_value

-        raise AttributeError('unknown property %s' % prop.name)

+        self.connect('destroy', self._on_destroy)

+        self._bind_sensitive_state()

 

-    def do_set_property(self, prop, value):

-        if prop.name == 'setting-value':

-            self.setting_value = value

-        else:

-            raise AttributeError('unknown property %s' % prop.name)

+    def _bind_sensitive_state(self):

+        if self.bind is None:

+            return

+

+        app.settings.connect_signal(self.bind,

+                                    self._on_setting_changed,

+                                    account=self.account)

+

+        value = app.settings.get_account_setting(self.account, self.bind)

+        if self.inverted:

+            value = not value

+        self.set_sensitive(value)

+

+    def _on_setting_changed(self, value, *args):

+        if self.inverted:

+            value = not value

+        self.set_sensitive(value)

 

     def get_value(self):

         return self.__get_value(self.type_, self.value, self.account)

         if self.callback is not None:

             self.callback(state, self.data)

 

-        self.set_property('setting-value', state)

-

     @staticmethod

     def set_no_log_for(account, state):

         no_log = app.settings.get_account_setting(account, 'no_log_for').split()

     def on_row_activated(self):

         raise NotImplementedError

 

-    def update_activatable(self, name, value):

-        enabled_func_value = True

-        if self.enabled_func is not None:

-            enabled_func_value = self.enabled_func()

+    def update_activatable(self):

+        if self.enabled_func is None:

+            return

 

-        enabledif_value = True

-        if self.enabledif is not None and self.enabledif[0] == name:

-            enabledif_value = (name, value) == self.enabledif

+        enabled_func_value = self.enabled_func()

+        self.set_activatable(enabled_func_value)

+        self.set_sensitive(enabled_func_value)

 

-        self.set_activatable(enabled_func_value and enabledif_value)

-        self.set_sensitive(enabled_func_value and enabledif_value)

+    def _on_destroy(self, *args):

+        if self.bind is not None:

+            app.settings.disconnect_signals(self)

 

 

 class SwitchSetting(GenericSetting):

-

-    __gproperties__ = {

-        "setting-value": (bool, 'Switch Value', '', False,

-                          GObject.ParamFlags.READWRITE),}

-

     def __init__(self, *args):

         GenericSetting.__init__(self, *args)

 

 

 

 class EntrySetting(GenericSetting):

-

-    __gproperties__ = {

-        "setting-value": (str, 'Entry Value', '', '',

-                          GObject.ParamFlags.READWRITE),}

-

     def __init__(self, *args):

         GenericSetting.__init__(self, *args)

 

 

 

 class ColorSetting(GenericSetting):

-

-    __gproperties__ = {

-        "setting-value": (str, 'Color Value', '', '',

-                          GObject.ParamFlags.READWRITE),

-    }

-

     def __init__(self, *args):

         GenericSetting.__init__(self, *args)

 

 

 

 class DialogSetting(GenericSetting):

-

-    __gproperties__ = {

-        "setting-value": (str, 'Dummy', '', '',

-                          GObject.ParamFlags.READWRITE),}

-

     def __init__(self, *args, dialog):

         GenericSetting.__init__(self, *args)

         self.dialog = dialog

 

 

 class SpinSetting(GenericSetting):

-

-    __gproperties__ = {

-        "setting-value": (int, 'Priority', '', -128, 127, 0,

-                          GObject.ParamFlags.READWRITE),}

-

     def __init__(self, *args, range_):

         GenericSetting.__init__(self, *args)

 

 

 

 class FileChooserSetting(GenericSetting):

-

-    __gproperties__ = {

-        "setting-value": (str, 'Certificate Path', '', '',

-                          GObject.ParamFlags.READWRITE),}

-

     def __init__(self, *args, filefilter):

         GenericSetting.__init__(self, *args)

 

 

 

 class CallbackSetting(GenericSetting):

-

-    __gproperties__ = {

-        "setting-value": (str, 'Dummy', '', '',

-                          GObject.ParamFlags.READWRITE),}

-

     def __init__(self, *args, callback):

         GenericSetting.__init__(self, *args)

         self.callback = callback

 

 

 class ActionSetting(GenericSetting):

-

-    __gproperties__ = {

-        "setting-value": (str, 'Dummy', '', '',

-                          GObject.ParamFlags.READWRITE),}

-

     def __init__(self, *args, account):

         GenericSetting.__init__(self, *args)

         action_name = '%s%s' % (account, self.value)

         jid = app.get_jid_from_account(self.account)

         return jid

 

-    def update_activatable(self, name, value):

-        super().update_activatable(name, value)

-        anonym = app.settings.get_account_setting(self.account, 'anonymous_auth')

-        self.set_activatable(not anonym)

-

 

 class PopoverSetting(GenericSetting):

-

-    __gproperties__ = {

-        "setting-value": (str, 'Dummy', '', '',

-                          GObject.ParamFlags.READWRITE),}

-

     def __init__(self, *args, entries):

         GenericSetting.__init__(self, *args)

 

 

 

 class ComboSetting(GenericSetting):

-

-    __gproperties__ = {

-        "setting-value": (str, 'Proxy', '', '',

-                          GObject.ParamFlags.READWRITE),}

-

     def __init__(self, *args, combo_items):

         GenericSetting.__init__(self, *args)

 

 

 

 class ProxyComboSetting(GenericSetting):

-

-    __gproperties__ = {

-        "setting-value": (str, 'Proxy', '', '',

-                          GObject.ParamFlags.READWRITE),}

-

     def __init__(self, *args):

         GenericSetting.__init__(self, *args)

 

         DialogSetting.__init__(self, *args, **kwargs)

 

     def get_setting_value(self):

-        custom = app.settings.get_account_setting(self.account, 'use_custom_host')

+        custom = app.settings.get_account_setting(self.account,

+                                                  'use_custom_host')

         return Q_('?switch:On') if custom else Q_('?switch:Off')

 

 

         parent.destroy()

         open_window('ChangePassword', account=self.account)

 

-    def update_activatable(self, name, value):

+    def update_activatable(self):

         activatable = False

         if self.account in app.connections:

             con = app.connections[self.account]

Philipp Hörist pushed to branch master at gajim / gajim

Commits:

4 changed files:

Changes: