PreferencesController.py

# Copyright (C) 2009-2011 AG Projects. See LICENSE for details.
#

import re
import os
import platform
import json

from AppKit import (NSAccessibilityTitleAttribute,
                    NSAlertDefaultReturn,
                    NSApp,
                    NSEventTrackingRunLoopMode,
                    NSDragOperationGeneric,
                    NSNoTabsBezelBorder,
                    NSNoTabsNoBorder,
                    NSOnState,
                    NSOffState,
                    NSRunAlertPanel,
                    NSTableViewDropAbove,
                    NSTableViewDropOn,
                    NSTopTabsBezelBorder,
                    NSViewHeightSizable,
                    NSViewMaxXMargin,
                    NSViewMinXMargin,
                    NSViewWidthSizable)

from Foundation import (NSArray,
                        NSBezierPath,
                        NSBundle,
                        NSColor,
                        NSImage,
                        NSIndexSet,
                        NSMakeRect,
                        NSMakeSize,
                        NSNotificationCenter,
                        NSScrollView,
                        NSString,
                        NSLocalizedString,
                        NSTabViewItem,
                        NSTabView,
                        NSURL,
                        NSUserDefaults,
                        NSWindowController,
                        NSRunLoop,
                        NSRunLoopCommonModes,
                        NSTimer,
                        NSWorkspace)
import objc

from application.notification import NotificationCenter, IObserver
from application.python import Null
from application.system import unlink
from gnutls.errors import GNUTLSError
from gnutls.crypto import X509Certificate, X509PrivateKey
from sipsimple.account import AccountManager, Account, BonjourAccount
from sipsimple.application import SIPApplication
from sipsimple.configuration import Setting, SettingsGroupMeta
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.threading import run_in_thread
from zope.interface import implementer

from BlinkLogger import BlinkLogger, FileLogger

from EnrollmentController import EnrollmentController
# Settings a SylkServer account cannot change: forced by SylkDiscovery (OpenPGP, CPIM, XCAP, no
# xcap-diff), or given by the server with the history token (the history URL and the token)
SYLKSERVER_HIDDEN_OPTIONS = {'sms.enable_pgp', 'xcap.enabled', 'xcap.xcap_diff'}
SYLKSERVER_LOCKED_OPTIONS = {'sms.enable_cpim', 'sms.history_url', 'sms.history_token'}

from PreferenceOptions import AccountSectionOrder, AccountSettingsOrder, AecSliderOption, AdvancedGeneralSectionOrder, BonjourAccountSectionOrder, DisabledAccountPreferenceSections, DisabledPreferenceSections, GeneralSettingsOrder, HiddenOption, PreferenceOptionTypes, SampleRateOption, SettingDescription, StaticPreferenceSections, SectionNames, ToolTips, Placeholders, formatName
from SIPManager import SIPManager
from VerticalBoxView import VerticalBoxView
from resources import ApplicationData
from util import log_gui_exception, run_in_gui_thread, AccountInfo, osx_version, trusted_cas


@implementer(IObserver)
class PreferencesController(NSWindowController, object):

    toolbar = objc.IBOutlet()
    mainTabView = objc.IBOutlet()
    sectionDescription = objc.IBOutlet()

    accountTable = objc.IBOutlet()
    displayNameText = objc.IBOutlet()
    addressText = objc.IBOutlet()
    passwordText = objc.IBOutlet()
    registration_status = objc.IBOutlet()
    registration_tls_icon = objc.IBOutlet()
    sync_with_icloud_checkbox = objc.IBOutlet()
    selected_proxy_radio_button = objc.IBOutlet()
    sectionHelpPlaceholder = objc.IBOutlet()
    purgeLogsButton = objc.IBOutlet()
    openLogsFolderButton = objc.IBOutlet()

    addButton = objc.IBOutlet()
    removeButton = objc.IBOutlet()

    # account elements
    advancedToggle = objc.IBOutlet()
    advancedPop = objc.IBOutlet()
    advancedTabView = objc.IBOutlet()

    # general settings
    generalTabView = objc.IBOutlet()

    settingViews = {}
    accounts = []

    updating = False
    saving = False
    logsize_timer = None

    def init(self):
        self = objc.super(PreferencesController, self).init()
        if self:
            notification_center = NotificationCenter()
            notification_center.add_observer(self, name="BlinkShouldTerminate")
            notification_center.add_observer(self, name="BlinkTransportFailed")
            notification_center.add_observer(self, name="BonjourAccountWillRegister")
            notification_center.add_observer(self, name="BonjourAccountRegistrationDidSucceed")
            notification_center.add_observer(self, name="BonjourAccountRegistrationDidFail")
            notification_center.add_observer(self, name="BonjourAccountRegistrationDidEnd")
            notification_center.add_observer(self, name="SIPAccountDidDeactivate")
            notification_center.add_observer(self, name="SIPAccountRegistrationDidSucceed")
            notification_center.add_observer(self, name="SIPAccountRegistrationDidFail")
            notification_center.add_observer(self, name="SIPAccountRegistrationDidEnd")
            notification_center.add_observer(self, name="SIPAccountRegistrationGotAnswer")
            notification_center.add_observer(self, name="SIPAccountWillRegister")
            notification_center.add_observer(self, name="SIPAccountChangedByICloud")
            notification_center.add_observer(self, sender=AccountManager())

            return self

    @objc.python_method
    def _NH_BlinkShouldTerminate(self, notification):
        if self.window():
            self.window().orderOut_(self)

    def showWindow_(self, sender):
        if not self.window():
            NSBundle.loadNibNamed_owner_("PreferencesWindow", self)
            self.addButton.setEnabled_(SIPManager().validateAddAccountAction())
            self.buttonClicked_(self.advancedToggle)
            self.window().setTitle_(NSLocalizedString("Accounts", "Window Title"))

        self.accountTable.reloadData()

        default_account = AccountManager().default_account
        if default_account:
            try:
                row = self.accounts.index(default_account)
                self.accountTable.selectRowIndexes_byExtendingSelection_(NSIndexSet.indexSetWithIndex_(row), False)
            except ValueError:
                pass

        for view in list(self.settingViews.values()):
            view.restore()

        self.validateAddAccountButton()
        NSApp.activateIgnoringOtherApps_(True)
        NSWindowController.showWindow_(self, sender)

    @objc.python_method
    def validateAddAccountButton(self):
        if self.addButton:
            self.addButton.setEnabled_(SIPManager().validateAddAccountAction())

    def close_(self, sender):
        self.window().close()

    def awakeFromNib(self):
        if not self.accountTable:
            return
        NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(self, "userDefaultsDidChange:", "NSUserDefaultsDidChangeNotification", NSUserDefaults.standardUserDefaults())

        dotPath = NSBezierPath.bezierPathWithOvalInRect_(NSMakeRect(2, 2, 8, 8))
        self.dots = {}
        for i, color in [("red", NSColor.redColor()), ("yellow", NSColor.yellowColor()), ("green", NSColor.greenColor())]:
          dot = NSImage.alloc().initWithSize_(NSMakeSize(12,12))
          dot.lockFocus()
          color.set()
          dotPath.fill()
          dot.unlockFocus()
          self.dots[i] = dot

        if self.advancedTabView is not None:
            self.tableViewSelectionDidChange_(None)

        if self.accountTable:
            self.accountTable.setDraggingSourceOperationMask_forLocal_(NSDragOperationGeneric, True)
            self.accountTable.registerForDraggedTypes_(NSArray.arrayWithObject_("dragged-account"))

        notification_center = NotificationCenter()
        notification_center.add_observer(self, name="CFGSettingsObjectDidChange")
        notification_center.add_observer(self, name="AudioDevicesDidChange")
        notification_center.add_observer(self, name="BlinkBuiltinMicrophoneAvailabilityDidChange")
        notification_center.add_observer(self, name="VideoDevicesDidChange")
        # So the in-preferences video preview re-binds to the new camera
        # whenever pjsip actually switches devices (which may lag the
        # CFGSettingsObjectDidChange that triggered the switch).
        notification_center.add_observer(self, name="VideoDeviceDidChangeCamera")

        applicationName = NSApp.delegate().applicationNamePrint
        self.window().setTitle_(NSLocalizedString("%s Preferences", "Window title") % applicationName)

        self.toolbar.setSelectedItemIdentifier_('accounts')

        if not NSApp.delegate().icloud_enabled:
            self.sync_with_icloud_checkbox.setHidden_(True)
        else:
            major, minor = platform.mac_ver()[0].split('.')[0:2]
            self.sync_with_icloud_checkbox.setHidden_(False if ((int(major) == 10 and int(minor) >= 7) or int(major) > 10) else True)

        if not NSApp.delegate().recording_enabled:
            PreferenceOptionTypes['audio.directory'] = HiddenOption
            PreferenceOptionTypes['audio.auto_recording'] = HiddenOption

        if not NSApp.delegate().file_logging_enabled:
            PreferenceOptionTypes['logs.directory'] = HiddenOption

        if not NSApp.delegate().history_enabled:
            PreferenceOptionTypes['contacts.enable_incoming_calls_group'] = HiddenOption
            PreferenceOptionTypes['contacts.enable_outgoing_calls_group'] = HiddenOption
            PreferenceOptionTypes['contacts.enable_missed_calls_group'] = HiddenOption

        if not NSApp.delegate().contactsWindowController.sessionControllersManager.isMediaTypeSupported('video'):
            try:
                item = next((item for item in self.toolbar.visibleItems() if item.itemIdentifier() == 'video'))
                self.toolbar.removeItemAtIndex_(self.toolbar.visibleItems().index(item))
            except StopIteration:
                pass

        # Always drop the H.264 Codec toolbar tab.  Its only control was
        # the profile picker (baseline / main / high); profile is now
        # pinned to "baseline" at startup
        # (BlinkAppDelegate._NH_SIPApplicationDidStart) to keep WebRTC
        # peers (Sylk Mobile, browsers) decoding our H.264 cleanly, and
        # level is auto-derived from the pinned resolution.  Nothing on
        # that tab is user-editable any more, so it's pure UI clutter.
        try:
            item = next((item for item in self.toolbar.visibleItems() if item.itemIdentifier() == 'h264'))
            self.toolbar.removeItemAtIndex_(self.toolbar.visibleItems().index(item))
        except StopIteration:
            pass

        if not NSApp.delegate().advanced_options_enabled:
            for identifier in ('answering_machine', 'advanced'):
                try:
                    item = next((item for item in self.toolbar.visibleItems() if item.itemIdentifier() == identifier))
                    self.toolbar.removeItemAtIndex_(self.toolbar.visibleItems().index(item))
                except StopIteration:
                    pass

        if not NSApp.delegate().answering_machine_enabled:
            for identifier in ('answering_machine'):
                try:
                    item = next((item for item in self.toolbar.visibleItems() if item.itemIdentifier() == identifier))
                    self.toolbar.removeItemAtIndex_(self.toolbar.visibleItems().index(item))
                except StopIteration:
                    pass

        self._fixup_toolbar_overflow_menu()

        self.userDefaultsDidChange_(None)

    @objc.python_method
    def _fixup_toolbar_overflow_menu(self):
        # When the window is too narrow to show every tab, NSToolbar hides
        # the extras behind a ">>" overflow button and auto-generates a menu
        # for them. That auto-generated menu draws each item's image at its
        # NATIVE size -- and several of our tab icons are large source assets
        # (answering_machine is 177x150, help is 128x128, audio 240x240,
        # video 520x520, ...). NSToolbar scales them down for the visible
        # toolbar but not for the overflow menu, so any tab that overflows
        # shows a giant icon (the 'advanced' tab looked fine only because it
        # uses the 32x32 system NSAdvanced image).
        #
        # Rather than supply a custom menuFormRepresentation -- which replaces
        # NSToolbar's built-in overflow-menu routing and breaks the click --
        # just normalise each icon to 32x32. NSToolbar already scales images
        # to its icon area, so the visible toolbar is unchanged, while the
        # auto-generated overflow menu (whose clicks keep working) now draws
        # every icon at a sane size.
        icon_size = NSMakeSize(32, 32)
        for item in self.toolbar.items():
            identifier = item.itemIdentifier()
            if not identifier or identifier.startswith('NSToolbar'):
                # separators, flexible/standard space, etc.
                continue
            image = item.image()
            if image is None:
                continue
            size = image.size()
            if size.width <= 32 and size.height <= 32:
                continue
            icon = image.copy()
            icon.setSize_(icon_size)
            item.setImage_(icon)

    @run_in_gui_thread
    def userDefaultsDidChange_(self, notification):
        icloud_sync_enabled = NSUserDefaults.standardUserDefaults().stringForKey_("iCloudSyncEnabled")
        self.sync_with_icloud_checkbox.setState_(NSOnState if icloud_sync_enabled == 'Enabled' else NSOffState)

    @objc.IBAction
    def userClickedSelectedProxyRadioButton_(self, sender):
        account_info = self.selectedAccount()
        if account_info:
            account = account_info.account
            if sender.selectedCell().tag() == 0:
                account.sip.outbound_proxy = account.sip.primary_proxy
                account.sip.selected_proxy = 0
                account.save()
            elif sender.selectedCell().tag() == 1:
                account.sip.outbound_proxy = account.sip.alternative_proxy
                account.sip.selected_proxy = 1
                account.save()

    @objc.IBAction
    @run_in_thread('file-io')
    def userClickedPurgeLogsButton_(self, sender):
        log_manager = FileLogger()
        log_manager.stop()

        for path, dirs, files in os.walk(os.path.join(ApplicationData.directory, 'logs'), topdown=False):
            for name in files:
                try:
                    os.remove(os.path.join(path, name))
                except (OSError, IOError):
                    pass
            for name in dirs:
                try:
                    os.rmdir(os.path.join(path, name))
                except (OSError, IOError):
                    pass

        log_manager.start()
        self._update_logs_size_label()

    @objc.IBAction
    def userClickedToolbarButton_(self, sender):
        section_name = sender.itemIdentifier()

        # Release the in-prefs video preview's camera handle whenever
        # the user leaves the Video section. Without this the
        # AVCaptureSession stays alive (camera LED on, GPU busy)
        # until the entire preferences window is dismissed — even if
        # the user only briefly visited Video on their way to
        # somewhere else. The Video branch below re-binds the
        # producer if the user lands back on Video later.
        if section_name != 'video':
            preview = getattr(self, '_video_preview_widget', None)
            if preview is not None:
                try:
                    preview.setProducer(None)
                except Exception as e:
                    BlinkLogger().log_debug(
                        "Preferences preview release on tab change "
                        "ignored: %s" % e)

        if section_name == 'advanced':
            self.generalTabView.setTabViewType_(NSTopTabsBezelBorder)
            self.createGeneralOptionsUI('advanced')
            self.sectionHelpPlaceholder.setHidden_(False)
        elif section_name != 'help':
            self.createGeneralOptionsUI('basic')
            self.generalTabView.setTabViewType_(NSNoTabsBezelBorder)

        if section_name == 'accounts':
            self.mainTabView.selectTabViewItemWithIdentifier_("accounts")
            self.window().setTitle_(NSLocalizedString("Accounts", "Window title"))
            self.sectionHelpPlaceholder.setHidden_(True)
        elif section_name == 'audio':
            self.mainTabView.selectTabViewItemWithIdentifier_("settings")
            self.generalTabView.selectTabViewItemWithIdentifier_("audio")
            self.sectionDescription.setStringValue_(NSLocalizedString("Audio Settings", "Label"))
            self.sectionHelpPlaceholder.setHidden_(False)
            settings = SIPSimpleSettings()
            settings.audio.echo_canceller.enabled = settings.audio.enable_aec
            settings.audio.sample_rate = 32000 if settings.audio.echo_canceller.enabled and settings.audio.sample_rate not in ('16000', '32000') else 48000
            spectrum = settings.audio.sample_rate/1000/2 if settings.audio.sample_rate/1000/2 < 20 else 20
            rate = settings.audio.sample_rate/1000
            help_line = NSLocalizedString("Audio sample rate is set to %dkHz", "Preferences text label") % rate + NSLocalizedString(" covering 0-%dkHz spectrum", "Preferences text label") % spectrum
            if spectrum >=20:
                help_line += NSLocalizedString(".\nFor studio quality, disable the option 'Use ambient noise reduction' in System Preferences > Sound > Input section. ", "Preferences text label")
            self.sectionHelpPlaceholder.setStringValue_(help_line)
            self.window().setTitle_(NSLocalizedString("Audio", "Window title"))
        elif section_name == 'video':
            self.generalTabView.setTabViewType_(NSNoTabsNoBorder)
            self.mainTabView.selectTabViewItemWithIdentifier_("settings")
            self.generalTabView.selectTabViewItemWithIdentifier_("video")
            self.sectionDescription.setStringValue_(NSLocalizedString("Video Settings", "Label"))
            self.sectionHelpPlaceholder.setHidden_(False)
            self.window().setTitle_(NSLocalizedString("Video", "Window title"))
            # (Re-)bind the live preview to the local camera. We release
            # the producer in windowWillClose_ so the camera turns off
            # when the panel is dismissed; landing back on the Video
            # section reconnects it here.
            preview = getattr(self, '_video_preview_widget', None)
            if preview is not None:
                try:
                    preview.setProducer(SIPApplication.video_device.producer)
                except Exception as e:
                    BlinkLogger().log_info(
                        "Could not start preferences preview: %s" % e)
        elif section_name == 'answering_machine':
            self.mainTabView.selectTabViewItemWithIdentifier_("settings")
            self.generalTabView.selectTabViewItemWithIdentifier_("answering_machine")
            self.sectionDescription.setStringValue_(NSLocalizedString("Answering Machine Settings", "Label"))
            self.window().setTitle_(NSLocalizedString("Answering Machine", "Window title"))
            self.sectionHelpPlaceholder.setStringValue_(NSLocalizedString("When enabled, Answering Machine will auto answer the call after the predefined delay", "Preferences placeholder text"))
        elif section_name == 'chat':
            self.mainTabView.selectTabViewItemWithIdentifier_("settings")
            self.generalTabView.selectTabViewItemWithIdentifier_("chat")
            self.sectionDescription.setStringValue_(NSLocalizedString("Chat Settings", "Label"))
            self.window().setTitle_(NSLocalizedString("Chat", "Window title"))
            self.sectionHelpPlaceholder.setStringValue_('')
        elif section_name == 'file-transfer':
            self.mainTabView.selectTabViewItemWithIdentifier_("settings")
            self.generalTabView.selectTabViewItemWithIdentifier_("file_transfer")
            self.sectionDescription.setStringValue_(NSLocalizedString("File Transfer Settings", "Label"))
            self.window().setTitle_(NSLocalizedString("File Transfer", "Window title"))
            self.sectionHelpPlaceholder.setStringValue_('')
        elif section_name == 'screen-sharing':
            self.mainTabView.selectTabViewItemWithIdentifier_("settings")
            self.generalTabView.selectTabViewItemWithIdentifier_("screen_sharing_server")
            self.sectionDescription.setStringValue_(NSLocalizedString("Screen Sharing Settings", "Label"))
            self.window().setTitle_(NSLocalizedString("Screen Sharing", "Window title"))
            self.sectionHelpPlaceholder.setHidden_(False)
            self.sectionHelpPlaceholder.setStringValue_(NSLocalizedString("Enable Screen Sharing in System Preferences > Sharing section.\nClick on the 'Computer Settings...' button and check the option 'Anyone may request permission to control screen'", "Preferences help label"))
        elif section_name == 'alerts':
            self.mainTabView.selectTabViewItemWithIdentifier_("settings")
            self.generalTabView.selectTabViewItemWithIdentifier_("sounds")
            self.sectionDescription.setStringValue_(NSLocalizedString("Sound Alerts", "Label"))
            self.window().setTitle_(NSLocalizedString("Alerts", "Window title"))
            self.sectionHelpPlaceholder.setStringValue_('')
        elif section_name == 'contacts':
            self.mainTabView.selectTabViewItemWithIdentifier_("settings")
            self.generalTabView.selectTabViewItemWithIdentifier_("contacts")
            self.sectionDescription.setStringValue_(NSLocalizedString("Contacts Settings", "Label"))
            self.window().setTitle_(NSLocalizedString("Contacts", "Window title"))
            self.sectionHelpPlaceholder.setStringValue_('')
        elif section_name == 'advanced':
            self.sectionDescription.setStringValue_(NSLocalizedString("Advanced Settings", "Label"))
            self.mainTabView.selectTabViewItemWithIdentifier_("settings")
            self.window().setTitle_(NSLocalizedString("Advanced", "Window title"))

        elif section_name == 'help':
            self.window().setTitle_(NSLocalizedString("Help", "Window title"))
            NSApp.delegate().contactsWindowController.showHelp('#preferences')

    @objc.python_method
    def createGeneralOptionsUI(self, type='basic'):
        for i in range(self.generalTabView.numberOfTabViewItems()):
            self.generalTabView.removeTabViewItem_(self.generalTabView.tabViewItemAtIndex_(0))

        settings = SIPSimpleSettings()
        sections = [section_name for section_name in dir(SIPSimpleSettings) if isinstance(getattr(SIPSimpleSettings, section_name, None), SettingsGroupMeta)]
        frame = self.generalTabView.frame()
        frame.origin.x = 0
        frame.origin.y = 0

        if type == 'advanced':
            for section_name in AdvancedGeneralSectionOrder:
                view = self.createViewForSection(settings, frame, section_name, getattr(SIPSimpleSettings, section_name))
                tabItem = NSTabViewItem.alloc().initWithIdentifier_(section_name)

                try:
                    label = SectionNames[section_name]
                except KeyError:
                    label = formatName(section_name)

                tabItem.setLabel_(label)
                tabItem.setIdentifier_(section_name)
                tabItem.setView_(view)
                if section_name not in StaticPreferenceSections:
                    self.generalTabView.addTabViewItem_(tabItem)

        elif type == 'basic':
            for section in (section for section in sections if section not in DisabledPreferenceSections):
                section_object = getattr(settings, section, None)
                section_names = [section_name for section_name in dir(section_object.__class__) if isinstance(getattr(section_object.__class__, section_name, None), SettingsGroupMeta) and section_name not in DisabledPreferenceSections]
                view = self.createViewForSection(settings, frame, section, getattr(SIPSimpleSettings, section))
                tabItem = NSTabViewItem.alloc().initWithIdentifier_(section)

                if section_names:
                    subsectionsTabView = NSTabView.alloc().init()
                    subsectionsTabView.setDelegate_(self)
                    tabItem.setView_(subsectionsTabView)
                    self.generalTabView.addTabViewItem_(tabItem)
                    tabItem = NSTabViewItem.alloc().initWithIdentifier_('General')
                    tabItem.setLabel_(NSLocalizedString("General", "Label"))
                    tabItem.setView_(view)
                    subsectionsTabView.addTabViewItem_(tabItem)
                    for section_name in section_names:
                        view = self.createViewForSection(settings, frame, section_name, getattr(section_object.__class__, section_name), section_object=getattr(section_object, section_name))
                        tabItem = NSTabViewItem.alloc().initWithIdentifier_(section_name)
                        try:
                            label = SectionNames[section_name]
                        except KeyError:
                            label = formatName(section_name)

                        tabItem.setLabel_(label)
                        tabItem.setView_(view)
                        subsectionsTabView.addTabViewItem_(tabItem)
                elif section in StaticPreferenceSections:
                    try:
                        label = SectionNames[section]
                    except KeyError:
                        label = formatName(section)

                    tabItem.setLabel_(label)
                    tabItem.setView_(view)
                    self.generalTabView.addTabViewItem_(tabItem)

    @objc.python_method
    def createAccountOptionsUI(self, account):
        self.advancedPop.removeAllItems()
        for i in range(self.advancedTabView.numberOfTabViewItems()):
            self.advancedTabView.removeTabViewItem_(self.advancedTabView.tabViewItemAtIndex_(0))

        #sections = [section_name for section_name in dir(account.__class__) if isinstance(getattr(account.__class__, section_name, None), SettingsGroupMeta)]
        sections = BonjourAccountSectionOrder if account is BonjourAccount() else AccountSectionOrder

        frame = self.advancedTabView.frame()
        for section_name in (section_name for section_name in sections if section_name not in DisabledAccountPreferenceSections):
            if section_name in NSApp.delegate().hidden_account_preferences_sections:
                continue

            if not NSApp.delegate().icloud_enabled:
                PreferenceOptionTypes['gui.sync_with_icloud'] = HiddenOption

            try:
                view = self.createViewForSection(account, frame, section_name, getattr(account.__class__, section_name))
            except Exception:
                import traceback
                traceback.print_exc()

            tabItem = NSTabViewItem.alloc().initWithIdentifier_(section_name)
            try:
                label = SectionNames[section_name]
            except KeyError:
                label = formatName(section_name)

            self.advancedPop.addItemWithTitle_(label)
            self.advancedPop.lastItem().setRepresentedObject_(section_name)

            tabItem.setLabel_(label)
            tabItem.setView_(view)

            self.advancedTabView.addTabViewItem_(tabItem)

    @objc.python_method
    def createViewForSection(self, storage_object, frame, section_name, section_class, section_object=None):
        if section_object is None:
            section_object = getattr(storage_object, section_name)

        forAccount = isinstance(storage_object, (Account, BonjourAccount))
        section_view = NSScrollView.alloc().initWithFrame_(frame)
        section_view.setDrawsBackground_(False)
        section_view.setAutohidesScrollers_(True)
        # we will need a scrollbar if the number of settings cause the box to become to high
        e = True if section_name in ('rtp') else False
        section_view.setHasVerticalScroller_(e)
        section_view.setAutoresizingMask_(NSViewWidthSizable|NSViewHeightSizable)

        settings_box_view = VerticalBoxView.alloc().initWithFrame_(frame)
        settings_box_view.setAutoresizingMask_(NSViewWidthSizable|NSViewHeightSizable)
        settings_box_view.setSpacing_(8)
        settings_box_view.setBorderWidth_(8)

        section_view.setDocumentView_(settings_box_view)

        unordered_options = [opt for opt in dir(section_class) if isinstance(getattr(section_class, opt, None), Setting)]
        #assert not [opt for opt in dir(section_class) if isinstance(getattr(section_class, opt, None), SettingsGroupMeta)]
        try:
            options = AccountSettingsOrder[section_name] if forAccount else GeneralSettingsOrder[section_name]
            remaining_options = [opt for opt in unordered_options if opt not in options]
            options.extend(remaining_options)
        except KeyError:
            options = unordered_options

        if not NSApp.delegate().external_alert_enabled:
            PreferenceOptionTypes['web_alert.alert_url'] = HiddenOption

        if not NSApp.delegate().debug:
            PreferenceOptionTypes['audio.sound_card_delay'] = HiddenOption
            PreferenceOptionTypes['audio.sample_rate'] = HiddenOption
            PreferenceOptionTypes['rtp.no_mediaproxy'] = HiddenOption
        else:
            PreferenceOptionTypes['audio.sound_card_delay'] = AecSliderOption
            PreferenceOptionTypes['audio.sample_rate'] = SampleRateOption
            PreferenceOptionTypes.pop('rtp.no_mediaproxy', None)

        # For the general Video section, prepend a live camera preview
        # ABOVE the device / codec / resolution rows. Half the previous
        # footprint (160 px wide, centered) and aspect-aware: the
        # PreviewVideoWidget resizes its own height to match the camera
        # so the picture fills the view with no letterbox bars.
        if section_name == 'video' and not forAccount:
            try:
                from VideoMirrorController import (
                    PreviewVideoWidget, CenteredPreviewContainer)
                # Release the producer held by any PREVIOUSLY-created
                # PreviewVideoWidget before we overwrite
                # self._video_preview_widget below. Each call to
                # createViewForSection allocates a brand-new preview
                # widget and binds the camera producer to it; if we
                # don't explicitly release the old one first, it
                # stays holding the producer (PyObjC keeps the Cocoa
                # view alive as a subview reference) and the
                # AVCaptureSession's refcount never drops to zero,
                # leaving the camera LED on indefinitely. The next
                # time the user enters the Video section another
                # leak gets added on top. The on-tab-change release
                # in userClickedToolbarButton_ only covers the
                # widget pointer currently in self._video_preview_widget;
                # this covers the orphaned predecessors during a
                # full UI rebuild.
                old_preview = getattr(self, '_video_preview_widget', None)
                if old_preview is not None:
                    try:
                        old_preview.setProducer(None)
                    except Exception as e:
                        BlinkLogger().log_debug(
                            "Old preferences preview release on "
                            "rebuild ignored: %s" % e)
                # Truly fixed-size preview box, 320x240, regardless of
                # the configured capture resolution.  The widget never
                # resizes; only the IMAGE inside scales to fill the box
                # (via kCAGravityResizeAspectFill on the layer; see
                # PreviewVideoWidget._setup_video_layer).  This keeps
                # the surrounding layout absolutely stable - no shift,
                # no re-flow, no jitter - when the user changes
                # resolution.  16:9 sources are cropped left/right by
                # the compositor to fit the 4:3 box (the standard
                # FaceTime / Photo Booth approach); 4:3 sources fill
                # exactly.
                preview_width = 320.0
                preview_height = 240.0
                container = CenteredPreviewContainer.alloc().\
                    initWithFrame_(NSMakeRect(0, 0, preview_width,
                                              preview_height))
                preview = PreviewVideoWidget.alloc().\
                    initWithFrame_(NSMakeRect(0, 0, preview_width,
                                              preview_height))
                # Stay fixed-width and centered while the parent's width
                # changes via the VerticalBoxView's auto-stretch.
                preview.setAutoresizingMask_(
                    NSViewMinXMargin | NSViewMaxXMargin)
                container.setPreview(preview)
                self._video_preview_widget = preview
                # NOTE: do NOT call preview.setProducer() here.
                #
                # createViewForSection is invoked indirectly by
                # createGeneralOptionsUI('basic'), which iterates over
                # EVERY section (audio, video, chat, …) and rebuilds
                # the views for ALL of them — not just the one the
                # user clicked. createGeneralOptionsUI itself is
                # called from userClickedToolbarButton_ on every
                # non-help / non-advanced tab click. So binding the
                # camera producer here would turn the LED ON every
                # time the user clicked any tab, even tabs that have
                # nothing to do with video. The producer is bound by
                # userClickedToolbarButton_ when the user actually
                # navigates to the Video section.
                settings_box_view.addSubview_(container)
            except Exception as e:
                BlinkLogger().log_info(
                    "Could not create video preview in preferences: %s" % e)

        # A SylkServer account always uses OpenPGP, XCAP storage and no xcap-diff, and always
        # sends CPIM (SylkDiscovery forces them): those are not shown for it, and the CPIM
        # checkbox is shown ticked and locked. As Blink Qt does.
        # The conference server address is locked too when the domain publishes one
        # (conference.sipBridge, which SylkDiscovery writes into the account).
        sylkserver = False
        locked_options = SYLKSERVER_LOCKED_OPTIONS
        if forAccount and storage_object is not BonjourAccount():
            try:
                from SylkDiscovery import has_sylkserver, conference_server
                sylkserver = bool(has_sylkserver(storage_object))
                if sylkserver and conference_server(storage_object):
                    locked_options = SYLKSERVER_LOCKED_OPTIONS | {'conference.server_address'}
            except Exception:
                sylkserver = False

        for option_name in options:
            if section_name == 'auth' and option_name == 'password':
                continue

            if sylkserver and section_name + '.' + option_name in SYLKSERVER_HIDDEN_OPTIONS:
                continue
        
            if option_name == 'video_codec_list' and not NSApp.delegate().contactsWindowController.sessionControllersManager.isMediaTypeSupported('video'):
                continue
            
            option = getattr(section_class, option_name, None)
            if option is None:
                continue

            controlFactory = PreferenceOptionTypes.get(section_name + "." + option_name, None)
            if not controlFactory:
                controlFactory = None
                if forAccount:
                    try:
                        controlFactory = PreferenceOptionTypes.get(option.type.__name__+":account", None)
                    except AttributeError:
                        pass
            if not controlFactory:
                try:
                    controlFactory = PreferenceOptionTypes.get(option.type.__name__, None)
                except AttributeError:
                    pass

            if not controlFactory:
                print("Error: Option %s is not supported (while reading %s)" % (option, option_name))
                controlFactory = PreferenceOptionTypes[str.__name__]

            if controlFactory is HiddenOption:
                continue

            description_key = '%s.%s' % (section_name, option_name)

            try:
                description = SettingDescription[description_key]
            except KeyError:
                description = None

            control = controlFactory(section_object, option_name, option, description)

            try:
                tooltip = ToolTips[description_key]
                control.setTooltip(tooltip)
            except KeyError:
                pass

            try:
                placeholder = Placeholders[description_key]
                control.setPlaceHolder(placeholder)
            except KeyError:
                pass

            self.settingViews[section_name+"."+option_name] = control

            settings_box_view.addSubview_(control)

            control.delegate = self
            control.owner = storage_object
            control.restore()

            if sylkserver and section_name + '.' + option_name in locked_options:
                # shown, read only: a checkbox disabled, a text field selectable but not editable
                tooltip = NSLocalizedString("Set by SylkServer", "Tooltip")
                if getattr(control, 'check', None) is not None:
                    control.check.setEnabled_(False)
                    control.check.setToolTip_(tooltip)
                elif getattr(control, 'text', None) is not None:
                    control.text.setEditable_(False)
                    control.text.setSelectable_(True)
                    control.text.setToolTip_(tooltip)

        # DNS Information, as Blink Qt has it: what DNS says about the domain of the account and its
        # servers (SIP Signaling), its MSRP relay and its STUN servers (NAT Traversal)
        if forAccount and storage_object is not BonjourAccount():
            from DNSInformationPanel import DNSInformationButton
            if section_name == 'sip':
                settings_box_view.addSubview_(DNSInformationButton(storage_object, NSLocalizedString("DNS Information...", "Button title")))
            elif section_name == 'nat_traversal':
                settings_box_view.addSubview_(DNSInformationButton(storage_object, NSLocalizedString("MSRP Relay DNS Information...", "Button title"), nat_traversal='msrp'))
                settings_box_view.addSubview_(DNSInformationButton(storage_object, NSLocalizedString("STUN DNS Information...", "Button title"), nat_traversal='stun'))

        return section_view

    @objc.python_method
    def optionDidChange(self, option):
        self.saving = True
        option.owner.save()
        self.saving = False

    @objc.python_method
    def showOptionsForAccount(self, account):
        from ContactMangler import mangled_account_label
        self.updating = True
        if account.display_name:
            self.displayNameText.setStringValue_(mangled_account_label(account.display_name))
        else:
            self.displayNameText.setStringValue_("")

        if account is not BonjourAccount():
            # Read-only field (setEditable_(False) below), so nothing can
            # carry the invented address back into the account.
            self.addressText.setStringValue_(mangled_account_label(str(account.id)))
            self.passwordText.setStringValue_(account.auth.password)

            userdef = NSUserDefaults.standardUserDefaults()
            section = userdef.integerForKey_("SelectedAdvancedSection")
        else:
            userdef = NSUserDefaults.standardUserDefaults()
            section = userdef.integerForKey_("SelectedAdvancedBonjourSection")

        self.createAccountOptionsUI(account)

        if section is not None and section >=0 and section < self.advancedPop.numberOfItems():
            self.advancedPop.selectItemAtIndex_(section)
            self.advancedTabView.selectTabViewItemAtIndex_(section)

        self.updating = False

    @objc.python_method
    def addAccount(self):
        enroll = EnrollmentController.alloc().init()
        enroll.setupForAdditionalAccounts()
        enroll.runModal()

    @objc.python_method
    def removeSelectedAccount(self):
        account_info = self.selectedAccount()
        if account_info:
            account = account_info.account
            text = NSLocalizedString("Permanently remove account %s?", "Label") % account_info.name
            text = re.sub("%", "%%", text)
            # http://stackoverflow.com/questions/4498709/problem-in-displaying-in-nsrunalertpanel
            if NSRunAlertPanel(NSLocalizedString("Remove Account", "Button title"), text, NSLocalizedString("Remove", "Button title"), NSLocalizedString("Cancel", "Button title"), None) != NSAlertDefaultReturn:
                return

            account_manager = AccountManager()
            if account_manager.default_account is account:
                try:
                    account_manager.default_account = next((acc for acc in account_manager.iter_accounts() if acc is not account and acc.enabled))
                except StopIteration:
                    account_manager.default_account = None

            account.delete()

    def controlTextDidEndEditing_(self, notification):
        account_info = self.selectedAccount()
        if account_info:
            account = account_info.account
            if notification.object() == self.displayNameText:
                from ContactMangler import mangling_enabled, mangled_account_label
                name = str(self.displayNameText.stringValue())
                # The field is showing an invented name and the user did
                # not retype it; committing would make the invention
                # permanent.
                if mangling_enabled() and name == str(mangled_account_label(account.display_name) or ''):
                    return
                account.display_name = name
                account.save()
            elif notification.object() == self.passwordText:
                account.auth.password = self.passwordText.stringValue()
                account.save()

    @objc.python_method
    def selectedAccount(self):
        if not self.accountTable:
            return None
        selected = self.accountTable.selectedRow()
        if selected < 0:
            return None
        return self.getAccountForRow(selected)

    @objc.python_method
    def getAccountForRow(self, row):
        try:
            return self.accounts[row]
        except IndexError:
            # The table draws from the row count it was last given, so it
            # can ask for a row that removing an account has already taken
            # away. Callers below handle the absence; raising here would
            # reach AppKit, which ends the process.
            return None

    @objc.python_method
    def refresh_account_table(self):
        if self.accountTable:
            self.accountTable.reloadData()

    @objc.python_method
    def updateRegistrationStatus(self):
        if self.registration_status:
            selected_account = self.selectedAccount()
            frame = self.registration_status.frame()
            frame.origin.x = 330
            self.registration_status.setFrame_(frame)

            self.registration_status.setHidden_(True)
            self.registration_tls_icon.setHidden_(True)

            if selected_account:
                if selected_account.register_failure_code and selected_account.register_failure_reason:
                    self.registration_status.setStringValue_(NSLocalizedString("Registration failed:", "Label") + " %s (%s)" % (selected_account.register_failure_reason, selected_account.register_failure_code))
                    self.registration_status.setHidden_(False)
                elif selected_account.register_failure_reason:
                    self.registration_status.setStringValue_(NSLocalizedString("Registration failed:", "Label") + " " + selected_account.register_failure_reason)
                    self.registration_status.setHidden_(False)
                else:
                    if selected_account.register_state and selected_account.register_state != NSLocalizedString("ended", "Label"):
                        if selected_account.registrar and selected_account.register_state == NSLocalizedString("succeeded", "Label"):
                            label = NSLocalizedString("Registration succeeded", "Label") + NSLocalizedString(" at %s", "Network address follows") % selected_account.registrar
                            self.registration_status.setStringValue_(label)
                            self.registration_tls_icon.setHidden_(False if selected_account.registrar.startswith('tls:') else True)
                            if selected_account.registrar.startswith('tls:'):
                                frame.origin.x = 312
                                self.registration_status.setFrame_(frame)
                        else:
                            self.registration_status.setStringValue_(NSLocalizedString("Registration %s", "Label") % selected_account.register_state)
                        self.registration_status.setHidden_(False)

    @objc.python_method
    @run_in_gui_thread
    def handle_notification(self, notification):
        handler = getattr(self, '_NH_%s' % notification.name, Null)
        handler(notification)

    @objc.python_method
    def _NH_SIPAccountChangedByICloud(self, notification):
        self.refresh_account_table()
        if self.accountTable:
            self.tableViewSelectionDidChange_(None)
        self.validateAddAccountButton()
        self.updateRegistrationStatus()

    @objc.python_method
    def _NH_SIPAccountManagerDidAddAccount(self, notification):
        account = notification.data.account
        self.accounts.insert(account.order, AccountInfo(account))
        self.refresh_account_table()
        if self.accountTable:
            self.tableViewSelectionDidChange_(None)
        self.validateAddAccountButton()
        self.updateRegistrationStatus()

    @objc.python_method
    def _NH_SIPAccountManagerDidRemoveAccount(self, notification):
        position = self.accounts.index(notification.data.account)
        del self.accounts[position]
        self.refresh_account_table()
        if self.accountTable:
            self.tableViewSelectionDidChange_(None)
        self.validateAddAccountButton()
        self.updateRegistrationStatus()

    @objc.python_method
    def _NH_SIPAccountDidDeactivate(self, notification):
        try:
            position = self.accounts.index(notification.sender)
        except ValueError:
            return

        self.accounts[position].register_state = ''
        self.accounts[position].register_failure_code = None
        self.accounts[position].register_failure_reason = None
        self.updateRegistrationStatus()

    @objc.python_method
    def _NH_SIPAccountWillRegister(self, notification):
        try:
            position = self.accounts.index(notification.sender)
        except ValueError:
            return
        self.accounts[position].register_state = NSLocalizedString("started", "Label")
        self.refresh_account_table()
        self.updateRegistrationStatus()

    @objc.python_method
    def _NH_SIPAccountRegistrationDidSucceed(self, notification):
        try:
            position = self.accounts.index(notification.sender)
        except ValueError:
            return
        self.accounts[position].register_state = NSLocalizedString("succeeded", "Label")
        self.accounts[position].register_failure_code = None
        self.accounts[position].register_failure_reason = None

        self.refresh_account_table()
        self.updateRegistrationStatus()

    @objc.python_method
    def _NH_SIPAccountRegistrationGotAnswer(self, notification):
        try:
            position = self.accounts.index(notification.sender)
        except ValueError:
            return

        if notification.data.code > 200:
            self.accounts[position].register_failure_code = notification.data.code
            self.accounts[position].register_failure_reason = NSLocalizedString("Connection failed", "Error label") if notification.data.reason == 'Unknown error 61' else notification.data.reason.decode() if isinstance(notification.data.reason, bytes) else notification.data.reason
        else:
            self.accounts[position].register_failure_code = None
            self.accounts[position].register_failure_reason = None
            self.accounts[position].registrar = '%s:%s:%d' % (notification.data.registrar.transport, notification.data.registrar.address, notification.data.registrar.port)

        self.updateRegistrationStatus()

    @objc.python_method
    def _NH_SIPAccountRegistrationDidFail(self, notification):
        try:
            position = self.accounts.index(notification.sender)
        except ValueError:
            return
        self.accounts[position].register_state = NSLocalizedString("failed", "Label")
        self.accounts[position].registrar = None

        if self.accounts[position].register_failure_reason is None and hasattr(notification.data, 'error'):
            self.accounts[position].register_failure_reason = NSLocalizedString("Connection failed", "Error label") if notification.data.error == 'Unknown error 61' else notification.data.error.decode() if isinstance(notification.data.error, bytes) else notification.data.error

        self.refresh_account_table()
        self.updateRegistrationStatus()

    @objc.python_method
    def _NH_SIPAccountRegistrationDidEnd(self, notification):
        try:
            position = self.accounts.index(notification.sender)
        except ValueError:
            return
        self.accounts[position].register_state = NSLocalizedString("ended", "Label")
        self.refresh_account_table()
        self.updateRegistrationStatus()

    _NH_BonjourAccountWillRegister = _NH_SIPAccountWillRegister
    _NH_BonjourAccountRegistrationDidSucceed = _NH_SIPAccountRegistrationDidSucceed
    _NH_BonjourAccountRegistrationDidFail = _NH_SIPAccountRegistrationDidFail
    _NH_BonjourAccountRegistrationDidEnd = _NH_SIPAccountRegistrationDidEnd

    # Resolution -> H.264 level mapping.  The H.264 level the peer
    # decoder uses to size its frame buffers comes from the SDP fmtp;
    # if we offer a lower level than the resolution we send, some
    # WebRTC peers cap the decoded picture.  This map gets the level
    # right automatically when the user picks a resolution from the
    # Preferences dropdown.  Patch 48 in deps/patches/2.17 makes
    # pjsip's backend default to profile-level-id=42e01f (Level 3.1);
    # this override keeps the level in step with whatever resolution
    # the user actually picked.
    _H264_LEVEL_BY_RESOLUTION = {
        (320, 240):   "2.0",  # QVGA
        (640, 360):   "3.0",  # nHD
        (640, 480):   "3.0",  # VGA
        (960, 540):   "3.1",  # qHD
        (1280, 720):  "3.1",  # 720p HD
        (1920, 1080): "4.0",  # 1080p Full HD
    }


    @objc.python_method
    def _NH_CFGSettingsObjectDidChange(self, notification):
        sender = notification.sender

        settings = SIPSimpleSettings()
        if sender is settings and 'gui.mangle_contacts' in notification.data.modified:
            try:
                from ContactMangler import invalidate
                invalidate()
                if self.accountTable:
                    self.accountTable.reloadData()
                account_info = self.selectedAccount()
                if account_info is not None:
                    self.showOptionsForAccount(account_info.account)
            except Exception as e:
                BlinkLogger().log_error('Cannot redraw the accounts pane after the contact mangling changed: %s' % e)

        if sender is settings:
            if 'video.resolution' in notification.data.modified:
                # The preview thumbnail is deliberately NOT resized
                # when the user picks a different resolution - the
                # widget stays at a fixed 320x240 box and the layer's
                # kCAGravityResizeAspectFill (see PreviewVideoWidget._setup_video_layer)
                # scales the incoming bitmap to fill the box,
                # cropping any aspect mismatch.  This keeps the
                # surrounding Preferences layout from shifting when
                # the dropdown changes value.
                # Auto-derive the H.264 level from the chosen resolution
                # so the user doesn't have to think about it (the level
                # picker is hidden).  Falls back to whatever the user
                # had previously if they pick an exotic resolution we
                # don't have a mapping for.
                resolution_key = tuple(settings.video.resolution)
                level = self._H264_LEVEL_BY_RESOLUTION.get(resolution_key)
                if level is not None and settings.video.h264.level != level:
                    settings.video.h264.level = level
                    settings.save()

            # Last-line-of-defence H.264 profile guard.  The Profile
            # picker in the H.264 toolbar tab is hidden / pinned at
            # startup to "baseline" (see PreferenceOptions.py and
            # BlinkAppDelegate._NH_SIPApplicationDidStart), so in normal
            # use this branch never fires.  Kept here as a belt-and-
            # braces defence in case a future code path, a settings.cfg
            # import, or an external config-edit drift sets the profile
            # to Main or High - both silently break WebRTC peer interop
            # (libwebrtc / Sylk Mobile / browsers register Constrained
            # Baseline only).  See
            # deps/patches/2.17/48_h264_sylk_mobile_interop.patch.
            if 'video.h264.profile' in notification.data.modified:
                if settings.video.h264.profile != 'baseline':
                    BlinkLogger().log_info(
                        "Forcing H.264 profile back to 'baseline' "
                        "(Main/High break WebRTC peer interop)")
                    settings.video.h264.profile = 'baseline'
                    settings.save()

            # Camera-affecting setting changes: detach the preview from
            # the about-to-be-torn-down camera so the renderer doesn't
            # spam errors while pjsip is mid-reconfigure. The re-bind
            # happens either via _NH_VideoDeviceDidChangeCamera (which
            # fires once pjsip has swapped in the new camera) or via the
            # delayed retry below — whichever wins first.
            camera_settings = {'video.resolution', 'video.device',
                               'video.framerate'}
            if camera_settings & set(notification.data.modified):
                preview = getattr(self, '_video_preview_widget', None)
                if preview is not None:
                    try:
                        preview.setProducer(None)
                    except Exception as e:
                        BlinkLogger().log_debug(
                            "Pre-emptive preview detach ignored: %s" % e)
                    # Safety net: schedule a delayed re-bind in case
                    # VideoDeviceDidChangeCamera doesn't fire (it doesn't
                    # always, e.g. for pure resolution changes that don't
                    # swap the camera object itself). 1.5 s is enough for
                    # pjsip to settle into the new configuration.
                    from util import call_later

                    def _delayed_rebind():
                        p = getattr(self, '_video_preview_widget', None)
                        if p is None:
                            return
                        try:
                            p.setProducer(
                                SIPApplication.video_device.producer)
                        except Exception as exc:
                            BlinkLogger().log_info(
                                "Delayed preview rebind failed: %s" % exc)
                    call_later(1.5, _delayed_rebind)

        if not self.saving and sender in (settings, self.selectedAccount()):
            for option in (o for o in notification.data.modified if o in self.settingViews):
                self.settingViews[option].restore()
            if 'display_name' in notification.data.modified:
                from ContactMangler import mangled_account_label
                self.displayNameText.setStringValue_(mangled_account_label(sender.display_name) or '')

        if 'logs.trace_pjsip_to_file' in notification.data.modified:
            if settings.logs.trace_pjsip_to_file:
                if not settings.logs.trace_pjsip:
                    settings.logs.trace_pjsip = True
                    settings.save()
            else:
                if settings.logs.trace_pjsip != settings.logs.trace_pjsip_in_gui:
                    settings.logs.trace_pjsip = settings.logs.trace_pjsip_in_gui
                    settings.save()

        if 'audio.silent' in notification.data.modified:
            try:
                self.settingViews['audio.silent'].restore()
            except KeyError:
                pass

        if 'ldap.transport' in notification.data.modified:
            sender.ldap.port = 389 if sender.ldap.transport == 'tcp' else 636
            sender.save()

        if 'sip.primary_proxy' in notification.data.modified:
            if not sender.sip.selected_proxy:
                sender.sip.outbound_proxy = sender.sip.primary_proxy
                sender.save()

        if 'sip.register' in notification.data.modified and sender.sip.register is False:
            try:
                position = self.accounts.index(sender)
            except ValueError:
                pass
            else:
                self.accounts[position].register_state = ''
                self.accounts[position].register_failure_code = None
                self.accounts[position].register_failure_reason = None

        if 'sip.alternative_proxy' in notification.data.modified:
            account_info = self.selectedAccount()
            if account_info:
                account = account_info.account
                if account == sender:
                    self.selected_proxy_radio_button.setEnabled_(True if account.sip.always_use_my_proxy and account.sip.alternative_proxy is not None else False)

            if sender.sip.selected_proxy:
                sender.sip.outbound_proxy = sender.sip.alternative_proxy
                sender.save()

        if 'ldap.port' in notification.data.modified:
            if sender.ldap.port ==  389 and sender.ldap.transport != 'tcp':
                sender.ldap.transport = 'tcp'
                sender.save()
            elif sender.ldap.port ==  636 and sender.ldap.transport != 'tls':
                sender.ldap.transport = 'tls'
                sender.save()

        if 'rtp.encryption_type' in notification.data.modified:
            if sender.rtp.encryption_type == '':
                sender.rtp.encryption.enabled = False
            elif sender.rtp.encryption_type == 'opportunistic':
                sender.rtp.encryption.enabled = True
                sender.rtp.encryption.key_negotiation = 'opportunistic'
            elif sender.rtp.encryption_type == 'sdes_optional':
                sender.rtp.encryption.enabled = True
                sender.rtp.encryption.key_negotiation = 'sdes_optional'
            elif sender.rtp.encryption_type == 'sdes_mandatory':
                sender.rtp.encryption.enabled = True
                sender.rtp.encryption.key_negotiation = 'sdes_mandatory'
            elif sender.rtp.encryption_type == 'zrtp':
                sender.rtp.encryption.enabled = True
                sender.rtp.encryption.key_negotiation = 'zrtp'
            sender.save()

        if 'sip.always_use_my_proxy' in notification.data.modified:
            account_info = self.selectedAccount()
            if account_info:
                account = account_info.account
                if account == sender:
                    self.selected_proxy_radio_button.setEnabled_(True if account.sip.always_use_my_proxy and account.sip.alternative_proxy is not None else False)

        if 'sip.selected_proxy' in notification.data.modified:
            account_info = self.selectedAccount()
            if account_info:
                account = account_info.account
                if account == sender:
                    self.selected_proxy_radio_button.selectCellWithTag_(sender.sip.selected_proxy)

        if 'audio.sound_card_delay' in notification.data.modified:
            settings = SIPSimpleSettings()
            settings.audio.echo_canceller.tail_length = settings.audio.sound_card_delay
            settings.save()

        if 'audio.sample_rate' in notification.data.modified:
            settings = SIPSimpleSettings()
            spectrum = settings.audio.sample_rate/1000/2 if int(settings.audio.sample_rate)/1000/2 < 20 else 20
            rate = settings.audio.sample_rate/1000
            help_line = NSLocalizedString("Audio sample rate is set to %dkHz", "Preferences text label") % rate + NSLocalizedString(" covering 0-%dkHz spectrum", "Preferences text label") % spectrum
            if spectrum >=20:
                help_line += ".\n" + NSLocalizedString("For studio quality, disable the option 'Use ambient noise reduction' in System Preferences > Sound > Input section. ", "Label")
            self.sectionHelpPlaceholder.setStringValue_(help_line)

        if "audio.input_device" in notification.data.modified:
            self.update_per_device_aec()

        if "audio.output_device" in notification.data.modified:
            self.update_per_device_aec()

        if 'audio.enable_aec' in notification.data.modified:
            settings = SIPSimpleSettings()
            settings.audio.echo_canceller.enabled = settings.audio.enable_aec
            new_sample_rate = 32000 if settings.audio.echo_canceller.enabled and settings.audio.sample_rate not in ('16000', '32000') else 48000
            if not NSApp.delegate().contactsWindowController.has_audio:
                settings.audio.sample_rate = new_sample_rate
                settings.save()
            else:
                NSApp.delegate().contactsWindowController.new_audio_sample_rate = new_sample_rate

            combined_audio_device = (settings.audio.input_device or "") + " " + (settings.audio.output_device or "")

            data = {}
            if settings.audio.per_device_aec is not None:
                try:
                    data = json.loads(settings.audio.per_device_aec)
                except (TypeError, json.decoder.JSONDecodeError) as e:
                    pass

            data[combined_audio_device] = settings.audio.enable_aec

            try:
                encoded_data = json.dumps(data)
            except (TypeError, ValueError) as e:
                pass
            else:
                settings.audio.per_device_aec = encoded_data
                settings.save()

        if isinstance(sender, Account):
            self.refresh_account_table()
            self.updateRegistrationStatus()

    @objc.python_method
    def update_per_device_aec(self):
        settings = SIPSimpleSettings()
        combined_audio_device = (settings.audio.input_device or "") + " " + (settings.audio.output_device or "")
        data = {}
        if settings.audio.per_device_aec is not None:
            try:
                data = json.loads(settings.audio.per_device_aec)
            except (TypeError, ValueError) as e:
                pass

        try:
            per_device_aec = data[combined_audio_device]
        except KeyError:
            data[combined_audio_device] = settings.audio.enable_aec
            try:
                encoded_data = json.dumps(data)
            except (TypeError, ValueError) as e:
                pass
            else:
                settings.audio.per_device_aec = encoded_data
                settings.save()

        else:
            if per_device_aec != settings.audio.enable_aec:
                print("Changing AEC to %s" % per_device_aec)
                settings.audio.enable_aec = per_device_aec
                settings.save()

    @objc.python_method
    def _NH_BlinkTransportFailed(self, notification):
        self.refresh_account_table()
        self.updateRegistrationStatus()

    @objc.python_method
    def _NH_VideoDeviceDidChangeCamera(self, notification):
        # pjsip has actually rebuilt the local camera. Re-bind the
        # preferences-panel preview to it so the picture comes back.
        preview = getattr(self, '_video_preview_widget', None)
        if preview is None:
            return
        try:
            new_producer = getattr(notification.data, 'new_camera', None) or \
                SIPApplication.video_device.producer
            preview.setProducer(None)
            preview.setProducer(new_producer)
        except Exception as e:
            BlinkLogger().log_info(
                "Could not rebind preferences video preview: %s" % e)

    @objc.python_method
    def _NH_AudioDevicesDidChange(self, notification):
        self.updateAudioDevices_(None)

    @objc.python_method
    def _NH_BlinkBuiltinMicrophoneAvailabilityDidChange(self, notification):
        self.updateAudioDevices_(None)

    @objc.python_method
    def _NH_VideoDevicesDidChange(self, notification):
        self.updateVideoDevices_(None)

    @objc.python_method
    def updateVideoDevices_(self, object):
        pass

    @objc.python_method
    def updateAudioDevices_(self, object):
        audio_device_option_types = (PreferenceOptionTypes["audio.input_device"], PreferenceOptionTypes["audio.output_device"])
        for view in (v for v in self.settingViews.values() if isinstance(v, audio_device_option_types)):
            view.refresh()
            view.restore()

    def numberOfRowsInTableView_(self, table):
        try:
            return len(self.accounts)
        except Exception:
            log_gui_exception('the accounts row count')
            return 0

    def tableView_objectValueForTableColumn_row_(self, table, column, row):
        try:
            if column.identifier() == "enable":
                account_info = self.getAccountForRow(row)
                return NSOnState if account_info and account_info.account.enabled else NSOffState
            elif column.identifier() == "name":
                from ContactMangler import mangled_account_label
                account_info = self.getAccountForRow(row)
                return account_info and mangled_account_label(account_info.name)
        except Exception:
            log_gui_exception('the accounts data source (row %s)' % row)
            return None

    def tableView_willDisplayCell_forTableColumn_row_(self, table, cell, column, row):
        if column.identifier() == "status":
            account_info = self.getAccountForRow(row)
            if account_info is None:
                cell.setImage_(None)
                return
            if not account_info.account.enabled:
                cell.setImage_(None)
                cell.accessibilitySetOverrideValue_forAttribute_(NSLocalizedString("Registration disabled", "Accesibility text"), NSAccessibilityTitleAttribute)
            elif account_info.register_state == NSLocalizedString("succeeded", "Label"):
                cell.setImage_(self.dots["green"])
                cell.accessibilitySetOverrideValue_forAttribute_(NSLocalizedString("Registration succeeded", "Accesibility text"), NSAccessibilityTitleAttribute)
            elif account_info.register_state == NSLocalizedString("started", "Label"):
                cell.setImage_(self.dots["yellow"])
                cell.accessibilitySetOverrideValue_forAttribute_(NSLocalizedString("Registration started", "Accesibility text"), NSAccessibilityTitleAttribute)
            elif account_info.register_state == NSLocalizedString("failed", "Label"):
                cell.setImage_(self.dots["red"])
                cell.accessibilitySetOverrideValue_forAttribute_(NSLocalizedString("Registration failed", "Accesibility text"), NSAccessibilityTitleAttribute)
            else:
                cell.setImage_(None)
                cell.accessibilitySetOverrideValue_forAttribute_(NSLocalizedString("Registration disabled", "Accesibility text"), NSAccessibilityTitleAttribute)

    @objc.python_method
    def display_outbound_proxy_radio_if_needed(self, account):
        tab = self.advancedTabView.selectedTabViewItem()
        if account is not BonjourAccount():
            self.selected_proxy_radio_button.setHidden_(False if tab.identifier() == 'sip' and self.advancedToggle.state() == NSOnState else True)
            self.selected_proxy_radio_button.setEnabled_(True if account.sip.always_use_my_proxy and account.sip.alternative_proxy is not None else False)
            self.selected_proxy_radio_button.selectCellWithTag_(account.sip.selected_proxy)
        else:
            self.selected_proxy_radio_button.setHidden_(True)

    def tabView_didSelectTabViewItem_(self, tabView, item):
        if not self.updating:
            account_info = self.selectedAccount()
            account = account_info.account

            userdef = NSUserDefaults.standardUserDefaults()
            section = self.advancedPop.indexOfSelectedItem()

            if account is not BonjourAccount():
                userdef.setInteger_forKey_(section, "SelectedAdvancedSection")
                if tabView == self.advancedTabView:
                    self.display_outbound_proxy_radio_if_needed(account)
            else:
                userdef.setInteger_forKey_(section, "SelectedAdvancedBonjourSection")

        if item.identifier() == 'logs':
            if self.logsize_timer is None:
                self.logsize_timer = NSTimer.timerWithTimeInterval_target_selector_userInfo_repeats_(10.0, self, "updateLogSize:", None, True)
                NSRunLoop.currentRunLoop().addTimer_forMode_(self.logsize_timer, NSRunLoopCommonModes)
                NSRunLoop.currentRunLoop().addTimer_forMode_(self.logsize_timer, NSEventTrackingRunLoopMode)
        else:
            if self.logsize_timer is not None:
                if self.logsize_timer.isValid():
                    self.logsize_timer.invalidate()
                self.logsize_timer = None

        self.purgeLogsButton.setHidden_(True)
        self.openLogsFolderButton.setHidden_(True)
        if item.identifier() == 'logs':
            self._update_logs_size_label()
            self.purgeLogsButton.setHidden_(False)
            self.openLogsFolderButton.setHidden_(False)
        elif item.identifier() == 'sip':
            self.sectionHelpPlaceholder.setStringValue_(NSLocalizedString("Set port to 0 for automatic allocation", "Label"))
        elif item.identifier() == 'video':
            # Video section help: surfaces what "Auto" (unset) means for
            # max bitrate and that the H.264 level is auto-derived from
            # the chosen resolution (see _NH_CFGSettingsObjectDidChange).
            # With pjsip 2.17 + patch 44/45, the libvpx encoder targets
            # 1.5 Mbps VBR for VP8 / VP9; libx264 / VideoToolbox H.264
            # encode at the resolution's natural bitrate budget.  Setting
            # a manual max bitrate overrides those defaults and clamps
            # the encoder regardless of available uplink.
            self.sectionHelpPlaceholder.setStringValue_(NSLocalizedString(
                "Resolution sets the H.264 level automatically. "
                "Leave \"Max bitrate\" unset for the codec's auto target "
                "(1.5 Mbps for VP8/VP9, VideoToolbox-managed for H.264). "
                "Codec order: drag to reorder; first matching codec in the "
                "peer's offer wins SDP negotiation.",
                "Label"))
        elif item.identifier() == 'tls':
            label = ''
            settings = SIPSimpleSettings()
            cert_path = settings.tls.ca_list
            
            if cert_path:
                contents = None
                if os.path.isabs(cert_path) or cert_path.startswith('~/'):
                    contents = open(os.path.expanduser(cert_path), 'rb').read()
                else:
                    contents = open(ApplicationData.get(cert_path), 'rb').read()

                cas = trusted_cas(contents)
                BlinkLogger().log_info("Loaded %d TLS certificate authorities from %s" % (len(cas), cert_path))
                label += NSLocalizedString("Loaded %d certificate authorities\n", "Label") % len(cas)

            cert_path = settings.tls.certificate
            if cert_path is not None:
                if os.path.isabs(cert_path) or cert_path.startswith('~/'):
                    contents = open(os.path.expanduser(cert_path), 'rb').read()
                else:
                    contents = open(ApplicationData.get(cert_path), 'rb').read()

                try:
                    certificate = X509Certificate(contents) # validate the certificate
                except GNUTLSError as e:
                    pass
                else:
                    label += NSLocalizedString("My certificate: %s", "Label") % certificate.subject
                    BlinkLogger().log_info("My certificate subject: %s" % certificate.subject)

            self.sectionHelpPlaceholder.setStringValue_(label)
        elif item.identifier() == 'h264':
            # H.264 fmtp behaviour as of pjsip 2.17 + patch 48:
            # Constrained Baseline Level 3.1 (profile-level-id=42e01f) is
            # always proposed.  This matches Sylk Mobile / WebRTC /
            # libwebrtc, which only register Constrained Baseline as a
            # receive capability.  The Profile dropdown is locked to
            # "baseline" via _NH_CFGSettingsObjectDidChange — Main and
            # High silently break interop with WebRTC peers because
            # their libwebrtc decoder binds PT 96 to baseline and may
            # drop High-profile NALs.
            self.sectionHelpPlaceholder.setStringValue_(NSLocalizedString(
                "Constrained Baseline Level 3.1 is proposed - matches WebRTC, "
                "Sylk Mobile and browsers. Level is set automatically from the "
                "video resolution. Main and High profiles work only with "
                "traditional SIP peers and may break video with WebRTC endpoints.",
                "Label"))
        else:
            self.sectionHelpPlaceholder.setStringValue_('')

    @objc.IBAction
    def goToLogsFolderClicked_(self, sender):
        NSWorkspace.sharedWorkspace().openFile_(ApplicationData.get('logs'))

    def updateLogSize_(self, timer):
        self._update_logs_size_label()

    @objc.python_method
    @run_in_gui_thread
    def _update_logs_size_label(self):
        def _normalize_binary_size(size):
            """Return a human friendly string representation of size as a power of 2"""
            infinite = float('infinity')
            boundaries = [(             1024, '%d bytes',               1),
                          (          10*1024, '%.2f KB',           1024.0),  (     1024*1024, '%.1f KB',           1024.0),
                          (     10*1024*1024, '%.2f MB',      1024*1024.0),  (1024*1024*1024, '%.1f MB',      1024*1024.0),
                          (10*1024*1024*1024, '%.2f GB', 1024*1024*1024.0),  (      infinite, '%.1f GB', 1024*1024*1024.0)]
            for boundary, format, divisor in boundaries:
                if size < boundary:
                    return format % (size/divisor,)
            else:
                return "%d bytes" % size

        logs_size = 0
        for path, dirs, files in os.walk(os.path.join(ApplicationData.directory, 'logs')):
            for name in dirs:
                try:
                    logs_size += os.stat(os.path.join(path, name)).st_size
                except (OSError, IOError):
                    pass
            for name in files:
                try:
                    logs_size += os.stat(os.path.join(path, name)).st_size
                except (OSError, IOError):
                    pass

        size = _normalize_binary_size(logs_size)
        self.purgeLogsButton.setEnabled_(bool(logs_size))
        self.purgeLogsButton.setHidden_(False)
        self.openLogsFolderButton.setHidden_(False)
        self.sectionHelpPlaceholder.setStringValue_(NSLocalizedString("There are currently %s of log files", "Label") % size)
        self.sectionHelpPlaceholder.setHidden_(not bool(logs_size))

    def tableViewSelectionDidChange_(self, notification):
        sv = self.passwordText.superview()
        account_info = self.selectedAccount()
        if account_info:
            account = account_info.account
            self.showOptionsForAccount(account)

            self.addressText.setEditable_(False)
            self.passwordText.setEditable_(True)
            self.displayNameText.setHidden_(False)

            self.advancedToggle.setEnabled_(True)
            self.advancedToggle.setState_(NSOnState)
            self.advancedPop.setHidden_(False)
            self.advancedTabView.setHidden_(False)

            if account is BonjourAccount():
                self.passwordText.setHidden_(True)
                self.addressText.setHidden_(True)
                sv.viewWithTag_(20).setHidden_(True)
                sv.viewWithTag_(21).setHidden_(True)
            else:
                self.passwordText.setHidden_(False)
                self.addressText.setHidden_(False)
                sv.viewWithTag_(20).setHidden_(False)
                sv.viewWithTag_(21).setHidden_(False)
            self.display_outbound_proxy_radio_if_needed(account)

        else:
            self.addressText.setStringValue_(NSLocalizedString("Please select an account", "Label"))
            self.selected_proxy_radio_button.setHidden_(True)
            self.addressText.setEditable_(False)
            self.addressText.setHidden_(False)
            self.passwordText.setHidden_(True)
            self.passwordText.setEditable_(False)
            self.displayNameText.setHidden_(True)

            self.advancedToggle.setEnabled_(False)
            self.advancedToggle.setState_(NSOffState)
            self.advancedPop.setHidden_(True)
            self.advancedTabView.setHidden_(True)

            sv.viewWithTag_(20).setHidden_(False)
            sv.viewWithTag_(21).setHidden_(False)

        self.removeButton.setEnabled_(account_info is not None and account_info.account is not BonjourAccount())
        self.updateRegistrationStatus()

    def tableView_setObjectValue_forTableColumn_row_(self, table, object, column, row):
        account_info = self.getAccountForRow(row)
        if account_info is None:
            return
        if not object:
            account_info.account.enabled = False
        else:
            account_info.account.enabled = True
        account_info.account.save()
        self.accountTable.reloadData()

    def tableView_validateDrop_proposedRow_proposedDropOperation_(self, table, info, row, oper):
        if oper == NSTableViewDropOn:
            table.setDropRow_dropOperation_(row, NSTableViewDropAbove)
        return NSDragOperationGeneric

    def tableView_acceptDrop_row_dropOperation_(self, table, info, row, oper):
        pboard = info.draggingPasteboard()
        draggedRow = int(pboard.stringForType_("dragged-account"))

        if draggedRow != row+1 or oper != 0:
            account_info = self.accounts.pop(draggedRow)
            if draggedRow < row:
                row -= 1
            self.accounts.insert(row, account_info)
            for i in range(len(self.accounts)):
                account_info = self.accounts[i]
                if account_info.account.order != i:
                    account_info.account.order = i
                    account_info.account.save()
            table.reloadData()
            return True
        return False

    def tableView_writeRowsWithIndexes_toPasteboard_(self, table, rows, pboard):
        index = rows[0]
        pboard.declareTypes_owner_(NSArray.arrayWithObject_("dragged-account"), self)
        pboard.setString_forType_(NSString.stringWithString_(str(index)), "dragged-account")
        return True

    def windowShouldClose_(self, sender):
        sender.makeFirstResponder_(None)
        return True

    def windowWillClose_(self, notification):
        # Release the camera held by the in-prefs video preview when
        # the panel is dismissed. Without this the AVCaptureSession
        # stays running (camera LED on, GPU busy) the entire time the
        # app is alive after the user has visited the Video section
        # even once. The next time the user comes back to the Video
        # section, createViewForSection's setProducer call (and the
        # one in toolbarSelectionDidChange_) re-binds the producer.
        preview = getattr(self, '_video_preview_widget', None)
        if preview is not None:
            try:
                preview.setProducer(None)
            except Exception as e:
                BlinkLogger().log_debug(
                    "Preferences preview cleanup ignored: %s" % e)

    @objc.IBAction
    def openSite_(self, sender):
        NSWorkspace.sharedWorkspace().openURL_(NSURL.URLWithString_("http://ag-projects.com"))

    @objc.IBAction
    def syncWithiCloudClicked_(self, sender):
        NSUserDefaults.standardUserDefaults().setObject_forKey_("Enabled" if sender.state() == NSOnState else "Disabled", "iCloudSyncEnabled")

    @objc.IBAction
    def buttonClicked_(self, sender):
        if sender == self.advancedToggle:
            if self.advancedToggle.state() == NSOnState:
                self.advancedPop.setHidden_(False)
                self.advancedTabView.setHidden_(False)
            else:
                self.advancedPop.setHidden_(True)
                self.advancedTabView.setHidden_(True)
            account_info = self.selectedAccount()
            if account_info:
                self.display_outbound_proxy_radio_if_needed(account_info.account)
        elif sender == self.addButton:
            self.addAccount()
        elif sender == self.removeButton:
            self.removeSelectedAccount()

    @objc.python_method
    def get_logs_size(self):
        logs_size = 0
        for path, dirs, files in os.walk(os.path.join(ApplicationData.directory, 'logs')):
            for name in dirs:
                try:
                    logs_size += os.stat(os.path.join(path, name)).st_size
                except (OSError, IOError):
                    pass
            for name in files:
                try:
                    logs_size += os.stat(os.path.join(path, name)).st_size
                except (OSError, IOError):
                    pass
        return logs_size