Add a graphical user interface for the vision framework

source/driverHandler.py

@@ -11,6 +11,8 @@
 import config
 from copy import deepcopy
 from logHandler import log
+from typing import List, Tuple, Dict, Union
+
 
 class Driver(AutoPropertyObject):
 	"""
@@ -44,41 +46,59 @@ def __init__(self):
 		super(Driver, self).__init__()
 		config.pre_configSave.register(self.saveSettings)
 
-	def initSettings(self):
-		"""
-		Initializes the configuration for this driver.
-		This method is called when initializing the driver.
-		"""
-		firstLoad = not config.conf[self._configSection].isSet(self.name)
+	@classmethod
+	def _initSpecificSettings(cls, clsOrInst, settings: List):
+		firstLoad = not config.conf[cls._configSection].isSet(cls.name)
 		if firstLoad:
 			# Create the new section.
-			config.conf[self._configSection][self.name] = {}
+			config.conf[cls._configSection][cls.name] = {}
 		# Make sure the config spec is up to date, so the config validator does its work.
-		config.conf[self._configSection][self.name].spec.update(self.getConfigSpec())
-		# Make sure the instance has attributes for every setting
-		for setting in self.supportedSettings:
-			if not hasattr(self, setting.id):
-				setattr(self, setting.id, setting.defaultVal)
+		config.conf[cls._configSection][cls.name].spec.update(
+			cls._getConfigSPecForSettings(settings)
+		)
+		# Make sure the clsOrInst has attributes for every setting
+		for setting in settings:
+			if not hasattr(clsOrInst, setting.id):
+				setattr(clsOrInst, setting.id, setting.defaultVal)
 		if firstLoad:
-			self.saveSettings() #save defaults
+			cls._saveSpecificSettings(clsOrInst, settings)  # save defaults
 		else:
-			self.loadSettings()
+			cls._loadSpecificSettings(clsOrInst, settings)
+
+	def initSettings(self):
+		"""
+		Initializes the configuration for this driver.
+		This method is called when initializing the driver.
+		"""
+		self._initSpecificSettings(self, self.supportedSettings)
 
-	def terminate(self):
+	def terminate(self, saveSettings: bool = True):
 		"""Terminate this driver.
 		This should be used for any required clean up.
+		@param saveSettings: Whether settings should be saved on termination.
 		@precondition: L{initialize} has been called.
 		@postcondition: This driver can no longer be used.
 		"""
-		self.saveSettings()
+		if saveSettings:
+			self.saveSettings()
 		config.pre_configSave.unregister(self.saveSettings)
 
+	@classmethod
+	def _get_preInitSettings(self) -> Union[List, Tuple]:
+		"""The settings supported by the driver at pre initialisation time.
+		@rtype: list or tuple of L{DriverSetting}
+		"""
+		return ()
+
 	_abstract_supportedSettings = True
-	def _get_supportedSettings(self):
+
+	def _get_supportedSettings(self) -> Union[List, Tuple]:
 		"""The settings supported by the driver.
+		When overriding this property, subclasses are encouraged to extend the getter method
+		to ensure that L{preInitSettings} is part of the list of supported settings.
 		@rtype: list or tuple of L{DriverSetting}
 		"""
-		return ()
+		return self.preInitSettings
 
 	@classmethod
 	def check(cls):
@@ -98,60 +118,88 @@ def isSupported(self,settingID):
 			if s.id == settingID: return True
 		return False
 
-	def getConfigSpec(self):
-		spec=deepcopy(config.confspec[self._configSection]["__many__"])
-		for setting in self.supportedSettings:
+	@classmethod
+	def _getConfigSPecForSettings(
+			cls,
+			settings: Union[List, Tuple]
+	) -> Dict:
+		spec = deepcopy(config.confspec[cls._configSection]["__many__"])
+		for setting in settings:
 			if not setting.useConfig:
 				continue
 			spec[setting.id]=setting.configSpec
 		return spec
 
+	def getConfigSpec(self):
+		return self._getConfigSPecForSettings(self.supportedSettings)
+
+	@classmethod
+	def _saveSpecificSettings(
+			cls,
+			clsOrInst,
+			settings: Union[List, Tuple]
+	):
+		conf = config.conf[cls._configSection][cls.name]
+		for setting in settings:
+			if not setting.useConfig:
+				continue
+			try:
+				conf[setting.id] = getattr(clsOrInst, setting.id)
+			except UnsupportedConfigParameterError:
+				log.debugWarning(
+					f"Unsupported setting {setting.id!r}; ignoring",
+					exc_info=True
+				)
+				continue
+		if settings:
+			log.debug(f"Saved settings for {cls.__qualname__}")
+
 	def saveSettings(self):
 		"""
 		Saves the current settings for the driver to the configuration.
 		This method is also executed when the driver is loaded for the first time,
 		in order to populate the configuration with the initial settings..
 		"""
-		conf=config.conf[self._configSection][self.name]
-		for setting in self.supportedSettings:
-			if not setting.useConfig:
+		self._saveSpecificSettings(self, self.supportedSettings)
+
+	@classmethod
+	def _loadSpecificSettings(
+			cls,
+			clsOrInst,
+			settings: Union[List, Tuple],
+			onlyChanged: bool = False
+	):
+		conf = config.conf[cls._configSection][cls.name]
+		for setting in settings:
+			if not setting.useConfig or conf.get(setting.id) is None:
+				continue
+			val = conf[setting.id]
+			if onlyChanged and getattr(clsOrInst, setting.id) == val:
 				continue
 			try:
-				conf[setting.id] = getattr(self,setting.id)
+				setattr(clsOrInst, setting.id, val)
 			except UnsupportedConfigParameterError:
-				log.debugWarning("Unsupported setting %s; ignoring"%s.id, exc_info=True)
+				log.debugWarning(
+					f"Unsupported setting {setting.name!r}; ignoring",
+					exc_info=True
+				)
 				continue
-		if self.supportedSettings:
-			log.debug("Saved settings for {} {}".format(self.__class__.__name__, self.name))
+		if settings:
+			log.debug(
+				f"Loaded changed settings for {cls.__qualname__}"
+				if onlyChanged else
+				f"Loaded settings for {cls.__qualname__}"
+			)
 
-	def loadSettings(self, onlyChanged=False):
+	def loadSettings(self, onlyChanged: bool = False):
 		"""
 		Loads settings for this driver from the configuration.
 		This method assumes that the instance has attributes o/properties
 		corresponding with the name of every setting in L{supportedSettings}.
 		@param onlyChanged: When loading settings, only apply those for which
 			the value in the configuration differs from the current value.
-		@type onlyChanged: bool
 		"""
-		conf=config.conf[self._configSection][self.name]
-		for setting in self.supportedSettings:
-			if not setting.useConfig or conf.get(setting.id) is None:
-				continue
-			val=conf[setting.id]
-			if onlyChanged and getattr(self,setting.id) == val:
-				continue
-			try:
-				setattr(self,setting.id, val)
-			except UnsupportedConfigParameterError:
-				log.debugWarning("Unsupported setting %s; ignoring"%setting.name, exc_info=True)
-				continue
-		if self.supportedSettings:
-			log.debug(
-				(
-					"Loaded changed settings for {} {}"
-					if onlyChanged else
-					"Loaded settings for {} {}"
-				).format(self.__class__.__name__, self.name))
+		self._loadSpecificSettings(self, self.supportedSettings, onlyChanged)
 
 	@classmethod
 	def _paramToPercent(cls, current, min, max):

source/globalCommands.py

@@ -2302,15 +2302,25 @@ def script_toggleScreenCurtain(self, gesture):
 				return
 			scriptCount = scriptHandler.getLastScriptRepeatCount()
 			if scriptCount == 0 and screenCurtainName in vision.handler.providers:
-				vision.handler.terminateProvider(screenCurtainName)
+				try:
+					vision.handler.terminateProvider(screenCurtainName)
+				except Exception:
+					# If the screen curtain was enabled, we do not expect exceptions.
+					log.error("Screen curtain termination error", exc_info=True)
+					# Translators: Reported when the screen curtain could not be enabled.
+					message = _("Could not disable screen curtain")
+					return
 				# Translators: Reported when the screen curtain is disabled.
 				message = _("Screen curtain disabled")
 			elif scriptCount in (0, 2):
 				temporary = scriptCount == 0
-				if not vision.handler.initializeProvider(
-					screenCurtainName,
-					temporary=temporary,
-				):
+				try:
+					vision.handler.initializeProvider(
+						screenCurtainName,
+						temporary=temporary,
+					)
+				except Exception:
+					log.error("Screen curtain initialization error", exc_info=True)
 					# Translators: Reported when the screen curtain could not be enabled.
 					message = _("Could not enable screen curtain")
 					return

source/gui/nvdaControls.py

@@ -3,14 +3,15 @@
 #Copyright (C) 2016-2018 NV Access Limited, Derek Riemer
 #This file is covered by the GNU General Public License.
 #See the file COPYING for more details.
+
 from ctypes.wintypes import BOOL
 from typing import Any, Tuple, Optional
-
 import wx
 from comtypes import GUID
 from wx.lib.mixins import listctrl as listmix
-from gui import accPropServer
-from gui.dpiScalingHelper import DpiScalingHelperMixin
+from . import accPropServer
+from .dpiScalingHelper import DpiScalingHelperMixin
+from . import guiHelper
 import oleacc
 import winUser
 import winsound
@@ -305,6 +306,11 @@ def _addButtons(self, buttonHelper):
 		)
 		cancel.Bind(wx.EVT_BUTTON, lambda evt: self.EndModal(wx.CANCEL))
 
+	def _addContents(self, contentsSizer: guiHelper.BoxSizerHelper):
+		"""Adds additional contents  to the dialog, before the buttons.
+		Subclasses may implement this method.
+		"""
+
 	def _setIcon(self, type):
 		try:
 			iconID = self._DIALOG_TYPE_ICON_ID_MAP[type]
@@ -333,12 +339,12 @@ def __init__(self, parent, title, message, dialogType=DIALOG_TYPE_STANDARD):
 		self.Bind(wx.EVT_SHOW, self._onShowEvt, source=self)
 
 		mainSizer = wx.BoxSizer(wx.VERTICAL)
-		from . import guiHelper
 		contentsSizer = guiHelper.BoxSizerHelper(parent=self, orientation=wx.VERTICAL)
 
 		text = wx.StaticText(self, label=message)
 		text.Wrap(self.scaleSize(self.GetSize().Width))
 		contentsSizer.addItem(text)
+		self._addContents(contentsSizer)
 
 		buttonHelper = guiHelper.ButtonHelper(wx.HORIZONTAL)
 		self._addButtons(buttonHelper)