def __init__(self, account, parent=None):

        options = [
            Option(OptionKind.DIALOG,
                   _('Profile'),
                   OptionType.DIALOG,
                   props={'dialog': ZeroconfProfileDialog}),
            Option(OptionKind.SWITCH,
                   _('Connect on startup'),
                   OptionType.ACCOUNT_CONFIG,
                   'autoconnect',
                   desc=_('Use environment variable')),
            Option(OptionKind.SWITCH,
                   _('Save conversations for all contacts'),
                   OptionType.ACCOUNT_CONFIG,
                   'no_log_for',
                   desc=_('Store conversations on the harddrive')),
            Option(OptionKind.SWITCH,
                   _('Global Status'),
                   OptionType.ACCOUNT_CONFIG,
                   'sync_with_global_status',
                   desc=_('Synchronize the status of all accounts')),
            Option(OptionKind.GPG,
                   _('OpenPGP Key'),
                   OptionType.DIALOG,
                   props={'dialog': None}),
        ]

        GenericOptionPage.__init__(self, account, parent, options)
        self._add_top_buttons(None)
    def __init__(self, account, parent):

        options = [
            Option(OptionKind.ENTRY,
                   _('Password'),
                   OptionType.ACCOUNT_CONFIG,
                   'password',
                   name='password',
                   enabledif=('savepass', True)),
            Option(OptionKind.SWITCH,
                   _('Save Password'),
                   OptionType.ACCOUNT_CONFIG,
                   'savepass',
                   name='savepass'),
            Option(OptionKind.CHANGEPASSWORD,
                   _('Change Password'),
                   OptionType.DIALOG,
                   callback=self.on_password_change,
                   props={'dialog': None}),
        ]

        OptionsDialog.__init__(self, parent, _('Login Options'),
                               Gtk.DialogFlags.MODAL, options, account)

        self.connect('destroy', self.on_destroy)
    def __init__(self):

        options = [
            Option(OptionKind.SWITCH, _('Merge Accounts'), OptionType.ACTION,
                   'merge'),
            Option(OptionKind.SWITCH, _('Use PGP Agent'), OptionType.ACTION,
                   'agent'),
        ]

        GenericOptionPage.__init__(self, None, None, options)
    def __init__(self, account, parent):

        options = [
            Option(OptionKind.FILECHOOSER,
                   _('Client Certificate'),
                   OptionType.ACCOUNT_CONFIG,
                   'client_cert',
                   props={'filefilter': (_('PKCS12 Files'), '*.p12')}),
            Option(OptionKind.SWITCH, _('Encrypted Certificate'),
                   OptionType.ACCOUNT_CONFIG, 'client_cert_encrypted'),
        ]

        OptionsDialog.__init__(self, parent, _('Certificate Options'),
                               Gtk.DialogFlags.MODAL, options, account)
    def __init__(self, account, parent):

        options = [
            Option(OptionKind.ENTRY, _('First Name'),
                   OptionType.ACCOUNT_CONFIG, 'zeroconf_first_name'),
            Option(OptionKind.ENTRY, _('Last Name'), OptionType.ACCOUNT_CONFIG,
                   'zeroconf_last_name'),
            Option(OptionKind.ENTRY, _('Jabber ID'), OptionType.ACCOUNT_CONFIG,
                   'zeroconf_jabber_id'),
            Option(OptionKind.ENTRY, _('Email'), OptionType.ACCOUNT_CONFIG,
                   'zeroconf_email'),
        ]

        OptionsDialog.__init__(self, parent, _('Profile'),
                               Gtk.DialogFlags.MODAL, options, account)
    def __init__(self, account, parent=None):

        options = [
            Option(OptionKind.SWITCH,
                   'HTTP_PROXY',
                   OptionType.ACCOUNT_CONFIG,
                   'use_env_http_proxy',
                   desc=_('Use environment variable')),
            Option(OptionKind.PROXY,
                   _('Proxy'),
                   OptionType.ACCOUNT_CONFIG,
                   'proxy',
                   name='proxy'),
            Option(OptionKind.SWITCH, _('Warn on insecure connection'),
                   OptionType.ACCOUNT_CONFIG,
                   'warn_when_insecure_ssl_connection'),
            Option(OptionKind.SWITCH, _('Send keep-alive packets'),
                   OptionType.ACCOUNT_CONFIG, 'keep_alives_enabled'),
            Option(OptionKind.HOSTNAME,
                   _('Hostname'),
                   OptionType.DIALOG,
                   desc=_('Manually set the hostname for the server'),
                   props={'dialog': CutstomHostnameDialog}),
            Option(OptionKind.ENTRY, _('Resource'), OptionType.ACCOUNT_CONFIG,
                   'resource'),
            Option(OptionKind.PRIORITY,
                   _('Priority'),
                   OptionType.DIALOG,
                   props={'dialog': PriorityDialog}),
        ]

        GenericOptionPage.__init__(self, account, parent, options)
    def __init__(self, account, parent):

        options = [
            Option(OptionKind.SWITCH,
                   _('Enable'),
                   OptionType.ACCOUNT_CONFIG,
                   'use_custom_host',
                   name='custom'),
            Option(OptionKind.ENTRY,
                   _('Hostname'),
                   OptionType.ACCOUNT_CONFIG,
                   'custom_host',
                   enabledif=('custom', True)),
            Option(OptionKind.ENTRY,
                   _('Port'),
                   OptionType.ACCOUNT_CONFIG,
                   'custom_port',
                   enabledif=('custom', True)),
        ]

        OptionsDialog.__init__(self, parent, _('Connection Options'),
                               Gtk.DialogFlags.MODAL, options, account)
    def __init__(self, account, parent):

        neg_priority = app.config.get('enable_negative_priority')
        if neg_priority:
            range_ = (-128, 127)
        else:
            range_ = (0, 127)

        options = [
            Option(OptionKind.SWITCH, _('Adjust to status'),
                   OptionType.ACCOUNT_CONFIG, 'adjust_priority_with_status',
                   'adjust'),
            Option(OptionKind.SPIN,
                   _('Priority'),
                   OptionType.ACCOUNT_CONFIG,
                   'priority',
                   enabledif=('adjust', False),
                   props={'range_': range_}),
        ]

        OptionsDialog.__init__(self, parent, _('Priority'),
                               Gtk.DialogFlags.MODAL, options, account)

        self.connect('destroy', self.on_destroy)
    def __init__(self, account, parent=None):

        general = partial(self.set_page, GeneralPage(account, self), 'general')
        connection = partial(self.set_page, ConnectionPage(account, self),
                             'connection')

        options = [
            Option(OptionKind.ENTRY,
                   _('Label'),
                   OptionType.ACCOUNT_CONFIG,
                   'account_label',
                   callback=self._on_account_name_change),
            Option(OptionKind.LOGIN,
                   _('Login'),
                   OptionType.DIALOG,
                   props={'dialog': LoginDialog}),
            Option(OptionKind.ACTION,
                   _('Profile'),
                   OptionType.ACTION,
                   '-profile',
                   props={'action_args': account}),
            Option(OptionKind.CALLBACK,
                   _('General'),
                   name='general',
                   props={'callback': general}),
            Option(OptionKind.CALLBACK,
                   _('Connection'),
                   name='connection',
                   props={'callback': connection}),
            Option(OptionKind.ACTION,
                   _('Import Contacts'),
                   OptionType.ACTION,
                   '-import-contacts',
                   props={'action_args': account}),
            Option(OptionKind.DIALOG,
                   _('Client Certificate'),
                   OptionType.DIALOG,
                   props={'dialog': CertificateDialog}),
            Option(OptionKind.GPG,
                   _('OpenPGP Key'),
                   OptionType.DIALOG,
                   props={'dialog': None}),
        ]

        GenericOptionPage.__init__(self, account, parent, options)
        self._add_top_buttons(parent)
Beispiel #10
0
    def on_filter_options(self, *args):
        if self.filter_dialog:
            self.filter_dialog.present()
            return
        options = [
            Option(OptionKind.SWITCH,
                   'Presence',
                   OptionType.VALUE,
                   self.presence,
                   callback=self.on_option,
                   data='presence'),
            Option(OptionKind.SWITCH,
                   'Message',
                   OptionType.VALUE,
                   self.message,
                   callback=self.on_option,
                   data='message'),
            Option(OptionKind.SWITCH,
                   'Iq',
                   OptionType.VALUE,
                   self.iq,
                   callback=self.on_option,
                   data='iq'),
            Option(OptionKind.SWITCH,
                   'Stream\nManagement',
                   OptionType.VALUE,
                   self.stream,
                   callback=self.on_option,
                   data='stream'),
            Option(OptionKind.SWITCH,
                   'In',
                   OptionType.VALUE,
                   self.incoming,
                   callback=self.on_option,
                   data='incoming'),
            Option(OptionKind.SWITCH,
                   'Out',
                   OptionType.VALUE,
                   self.outgoing,
                   callback=self.on_option,
                   data='outgoing'),
        ]

        self.filter_dialog = OptionsDialog(self, 'Filter',
                                           Gtk.DialogFlags.DESTROY_WITH_PARENT,
                                           options, self.account)
        self.filter_dialog.connect('destroy', self.on_filter_destroyed)
    def __init__(self, account, parent=None):

        options = [
            Option(OptionKind.SWITCH, _('Connect on startup'),
                   OptionType.ACCOUNT_CONFIG, 'autoconnect'),
            Option(OptionKind.SWITCH, _('Reconnect when connection is lost'),
                   OptionType.ACCOUNT_CONFIG, 'autoreconnect'),
            Option(OptionKind.SWITCH,
                   _('Save conversations for all contacts'),
                   OptionType.ACCOUNT_CONFIG,
                   'no_log_for',
                   desc=_('Store conversations on the harddrive')),
            Option(OptionKind.SWITCH,
                   _('Server Message Archive'),
                   OptionType.ACCOUNT_CONFIG,
                   'sync_logs_with_server',
                   desc=_('Messages get stored on the server.\n'
                          'The archive is used to sync messages\n'
                          'between multiple devices.\n'
                          'XEP-0313')),
            Option(OptionKind.SWITCH,
                   _('Global Status'),
                   OptionType.ACCOUNT_CONFIG,
                   'sync_with_global_status',
                   desc=_('Synchronise the status of all accounts')),
            Option(OptionKind.SWITCH,
                   _('Message Carbons'),
                   OptionType.ACCOUNT_CONFIG,
                   'enable_message_carbons',
                   desc=_('All your other online devices get copies\n'
                          'of sent and received messages.\n'
                          'XEP-0280')),
            Option(OptionKind.SWITCH, _('Use file transfer proxies'),
                   OptionType.ACCOUNT_CONFIG, 'use_ft_proxies'),
        ]
        GenericOptionPage.__init__(self, account, parent, options)
    def __init__(self, plugin, parent):

        sizes = [('256 KiB', '262144'), ('512 KiB', '524288'),
                 ('1 MiB', '1048576'), ('5 MiB', '5242880'),
                 ('10 MiB', '10485760')]
        actions = [
            (_('Open'), 'open_menuitem'), (_('Save as'), 'save_as_menuitem'),
            (_('Copy Link Location'), 'copy_link_location_menuitem'),
            (_('Open Link in Browser'), 'open_link_in_browser_menuitem'),
            (_('Open File in Browser'), 'open_file_in_browser_menuitem')
        ]

        geo_providers = [(_('No map preview'), 'no_preview'),
                         ('Google Maps', 'Google'), ('OpenStreetMap', 'OSM')]

        self.plugin = plugin
        options = [
            Option('PreviewSizeSpinOption',
                   _('Preview size'),
                   OptionType.VALUE,
                   self.plugin.config['PREVIEW_SIZE'],
                   callback=self.on_option,
                   data='PREVIEW_SIZE',
                   props={'range_': (100, 1000)}),
            Option('PreviewComboOption',
                   _('Accepted filesize'),
                   OptionType.VALUE,
                   self.plugin.config['MAX_FILE_SIZE'],
                   callback=self.on_option,
                   data='MAX_FILE_SIZE',
                   props={
                       'items': sizes,
                       'plugin': self.plugin
                   }),
            Option(OptionKind.SWITCH,
                   _('Preview all Image URLs'),
                   OptionType.VALUE,
                   self.plugin.config['ALLOW_ALL_IMAGES'],
                   callback=self.on_option,
                   data='ALLOW_ALL_IMAGES'),
            Option('PreviewComboOption',
                   _('Left click action'),
                   OptionType.VALUE,
                   self.plugin.config['LEFTCLICK_ACTION'],
                   callback=self.on_option,
                   data='LEFTCLICK_ACTION',
                   props={
                       'items': actions,
                       'plugin': self.plugin
                   }),
            Option('PreviewComboOption',
                   _('Map service for preview'),
                   OptionType.VALUE,
                   self.plugin.config['GEO_PREVIEW_PROVIDER'],
                   callback=self.on_option,
                   data='GEO_PREVIEW_PROVIDER',
                   props={
                       'items': geo_providers,
                       'plugin': self.plugin
                   }),
            Option(OptionKind.SWITCH,
                   _('Enable HTTPS Verification'),
                   OptionType.VALUE,
                   self.plugin.config['VERIFY'],
                   callback=self.on_option,
                   data='VERIFY'),
        ]

        OptionsDialog.__init__(self,
                               parent,
                               _('UrlImagePreview Options'),
                               Gtk.DialogFlags.MODAL,
                               options,
                               None,
                               extend=[('PreviewComboOption', ComboOption),
                                       ('PreviewSizeSpinOption',
                                        SizeSpinOption)])