Say all, move caret per word instead of per line/sentence

source/config/configSpec.py

@@ -37,6 +37,7 @@
 	outputDevice = string(default=default)
 	autoLanguageSwitching = boolean(default=true)
 	autoDialectSwitching = boolean(default=false)
+	increaseSayAllCaretUpdates = boolean(default=false)
 
 	[[__many__]]
 		capPitchChange = integer(default=30,min=-100,max=100)

source/gui/settingsDialogs.py

@@ -1248,6 +1248,12 @@ def makeSettings(self, settingsSizer):
 		self.useSpellingFunctionalityCheckBox = settingsSizerHelper.addItem(wx.CheckBox(self, label = useSpellingFunctionalityText))
 		self.useSpellingFunctionalityCheckBox.SetValue(config.conf["speech"][self.driver.name]["useSpellingFunctionality"])
 
+		# Translators: This is the label for a checkbox in the
+		# voice settings panel.
+		increaseSayAllCaretUpdatesText = _("Increase caret updates during say all")
+		self.increaseSayAllCaretUpdatesCheckBox = settingsSizerHelper.addItem(wx.CheckBox(self, label = increaseSayAllCaretUpdatesText))
+		self.increaseSayAllCaretUpdatesCheckBox.Value = config.conf["speech"]["increaseSayAllCaretUpdates"]
+
 	def onSave(self):
 		DriverSettingsMixin.onSave(self)
 
@@ -1264,6 +1270,7 @@ def onSave(self):
 		config.conf["speech"][self.driver.name]["sayCapForCapitals"]=self.sayCapForCapsCheckBox.IsChecked()
 		config.conf["speech"][self.driver.name]["beepForCapitals"]=self.beepForCapsCheckBox.IsChecked()
 		config.conf["speech"][self.driver.name]["useSpellingFunctionality"]=self.useSpellingFunctionalityCheckBox.IsChecked()
+		config.conf["speech"]["increaseSayAllCaretUpdates"] = self.increaseSayAllCaretUpdatesCheckBox.IsChecked()
 
 class KeyboardSettingsPanel(SettingsPanel):
 	# Translators: This is the label for the keyboard settings panel.

source/sayAllHandler.py

@@ -1,5 +1,6 @@
+# sayAllHandler.py
 # A part of NonVisual Desktop Access (NVDA)
-# Copyright (C) 2006-2017 NV Access Limited
+# Copyright (C) 2006-2019 NV Access Limited, Babbage B.V.
 # This file may be used under the terms of the GNU General Public License, version 2 or later.
 # For more details see: https://www.gnu.org/licenses/gpl-2.0.html
 
@@ -12,6 +13,8 @@
 import api
 import textInfos
 import queueHandler
+from functools import partial
+import time
 
 CURSOR_CARET = 0
 CURSOR_REVIEW = 1
@@ -99,6 +102,8 @@ class _TextReader(object):
 	11. If there is another page, L{turnPage} calls L{nextLine}.
 	"""
 	MAX_BUFFERED_LINES = 10
+	_lastEndOfWhiteSpaceReachedTime = 0
+	MIN_TIME_BETWEEN_WHITE_SPACE_UPDATES = 0.5
 
 	def __init__(self, cursor):
 		self.cursor = cursor
@@ -142,9 +147,19 @@ def nextLine(self):
 			return
 		# Call lineReached when we start speaking this line.
 		# lineReached will move the cursor and trigger reading of the next line.
-		cb = speech.CallbackCommand(lambda obj=self.reader.obj, state=self.speakTextInfoState.copy(): self.lineReached(obj,bookmark, state))
+		cb = speech.CallbackCommand(partial(
+			self.lineReached,
+			obj=self.reader.obj,
+			bookmark=bookmark,
+			state=self.speakTextInfoState.copy()
+		))
 		spoke = speech.speakTextInfo(self.reader, unit=textInfos.UNIT_READINGCHUNK,
 			reason=controlTypes.REASON_SAYALL, _prefixSpeechCommand=cb,
+			_whiteSpaceReachedCallback=(
+				self.endOfWhiteSpaceReached
+				if config.conf["speech"]["increaseSayAllCaretUpdates"]
+				else None
+			),
 			useCache=self.speakTextInfoState)
 		# Collapse to the end of this line, ready to read the next.
 		try:
@@ -168,14 +183,24 @@ def nextLine(self):
 				# The first buffered line has now started speaking.
 				self.numBufferedLines -= 1
 
-	def lineReached(self, obj, bookmark, state):
-		# We've just started speaking this line, so move the cursor there.
-		state.updateObj()
+	def _bookmarkReached(self, obj, bookmark):
 		updater = obj.makeTextInfo(bookmark)
 		if self.cursor == CURSOR_CARET:
-			updater.updateCaret()
+			obj.selection = updater
 		if self.cursor != CURSOR_CARET or config.conf["reviewCursor"]["followCaret"]:
 			api.setReviewPosition(updater, isCaret=self.cursor==CURSOR_CARET)
+
+	def endOfWhiteSpaceReached(self, bookmark):
+		curTime = time.time()
+		if (self._lastEndOfWhiteSpaceReachedTime + self.MIN_TIME_BETWEEN_WHITE_SPACE_UPDATES) > curTime:
+			return
+		self._lastEndOfWhiteSpaceReachedTime = curTime
+		self._bookmarkReached(self.reader.obj, bookmark)
+
+	def lineReached(self, obj, bookmark, state):
+		# We've just started speaking this line, so move the cursor there.
+		state.updateObj()
+		self._bookmarkReached(obj, bookmark)
 		if self.numBufferedLines == 0:
 			# This was the last line spoken, so move on.
 			self.nextLine()

source/speech/__init__.py

@@ -30,6 +30,9 @@
 import characterProcessing
 import languageHandler
 from .commands import *
+from typing import Optional, Callable, Any
+from functools import partial
+from types import GeneratorType
 
 speechMode_off=0
 speechMode_beeps=1
@@ -766,8 +769,25 @@ def _speakTextInfo_addMath(speechSequence, info, field):
 	except (NotImplementedError, LookupError):
 		return
 
-def speakTextInfo(info, useCache=True, formatConfig=None, unit=None, reason=controlTypes.REASON_QUERY, _prefixSpeechCommand=None, onlyInitialFields=False, suppressBlanks=False,priority=None):
+re_white_space = re.compile(r"(\s+|$)", re.DOTALL)
+
+class _TextCommand(str):
+	"""str subclass to distinguish normal text from field text when processing text info speech."""
+
+def speakTextInfo(
+	info,
+	useCache=True,
+	formatConfig=None,
+	unit=None,
+	reason=controlTypes.REASON_QUERY,
+	_prefixSpeechCommand=None,
+	_whiteSpaceReachedCallback: Optional[Callable[[Any], None]] = None,
+	onlyInitialFields=False,
+	suppressBlanks=False,
+	priority=None
+):
 	onlyCache=reason==controlTypes.REASON_ONLYCACHE
+	processWhiteSPace: bool = _whiteSpaceReachedCallback is not None
 	if isinstance(useCache,SpeakTextInfoState):
 		speakTextInfoState=useCache
 	elif useCache:
@@ -943,9 +963,9 @@ def speakTextInfo(info, useCache=True, formatConfig=None, unit=None, reason=cont
 					indentationDone=True
 			if command:
 				if inTextChunk:
-					relativeSpeechSequence[-1]+=command
+					relativeSpeechSequence[-1] = _TextCommand(relativeSpeechSequence[-1] + command)
 				else:
-					relativeSpeechSequence.append(command)
+					relativeSpeechSequence.append(_TextCommand(command))
 					inTextChunk=True
 		elif isinstance(command,textInfos.FieldCommand):
 			newLanguage=None
@@ -1007,16 +1027,44 @@ def speakTextInfo(info, useCache=True, formatConfig=None, unit=None, reason=cont
 		else:
 			speechSequence.append(indentationSpeech)
 		if speakTextInfoState: speakTextInfoState.indentationCache=allIndentation
-	# Don't add this text if it is blank.
-	relativeBlank=True
-	for x in relativeSpeechSequence:
-		if isinstance(x,str) and not isBlank(x):
-			relativeBlank=False
-			break
-	if not relativeBlank:
-		speechSequence.extend(relativeSpeechSequence)
+	# only add this text if it is not blank.
+	notBlank = any(
+		not isBlank(x) for x in relativeSpeechSequence
+		if isinstance(x,str)
+	)
+	if notBlank:
 		isTextBlank=False
-
+		if not processWhiteSPace:
+			speechSequence.extend(relativeSpeechSequence)
+		else:
+			# Add appropriate white space bookmarks
+			whiteSpaceTracker = info.copy()
+			whiteSpaceTracker.collapse()
+			for index, command in list(enumerate(relativeSpeechSequence)):
+				if not isinstance(command, _TextCommand):
+					continue
+				curCommandSequence = []
+				endOfWhiteSpaceIndexes = [m.end() for m in re_white_space.finditer(command)]
+				start = 0
+				for end in endOfWhiteSpaceIndexes:
+					text = command[start:end]
+					curCommandSequence.append(text)
+					whiteSpaceTracker.move(textInfos.UNIT_CHARACTER, len(text))
+					if whiteSpaceTracker.compareEndPoints(info, "startToEnd") > 0:
+						break
+					bookmark = whiteSpaceTracker.bookmark
+					cb = partial(_whiteSpaceReachedCallback, bookmark=bookmark)
+					curCommandSequence.append(CallbackCommand(cb))
+					# The whiteSpaceTracker shouldn't move past the end of the info we're speaking.
+					start = end
+				relativeSpeechSequence[index] = curCommandSequence
+			expandedRelativeSpeechSequence = []
+			for x in relativeSpeechSequence:
+				if isinstance(x, list):
+					expandedRelativeSpeechSequence.extend(x)
+				else:
+					expandedRelativeSpeechSequence.append(x)
+			speechSequence.extend(expandedRelativeSpeechSequence)
 	#Finally get speech text for any fields left in new controlFieldStack that are common with the old controlFieldStack (for closing), if extra detail is not requested
 	if autoLanguageSwitching and lastLanguage is not None:
 		speechSequence.append(LangChangeCommand(None))
@@ -1763,7 +1811,7 @@ def getTableInfoSpeech(tableInfo,oldTableInfo,extraDetail=False):
 		textList.append(_("row %s")%rowNumber)
 	return " ".join(textList)
 
-re_last_pause=re.compile(r"^(.*(?<=[^\s.!?])[.!?][\"'”’)]?(?:\s+|$))(.*$)",re.DOTALL|re.UNICODE)
+re_last_pause=re.compile(r"^(.*?(?<=[^\s.!?])[.!?][\"'”’)]?(?:\s+|$))(.*$)",re.DOTALL|re.UNICODE)
 
 def speakWithoutPauses(speechSequence,detectBreaks=True):
 	"""

source/speech/commands.py

@@ -5,11 +5,15 @@
 #Copyright (C) 2006-2019 NV Access Limited
 
 """Commands that can be embedded in a speech sequence for changing synth parameters, playing sounds or running other callbacks."""
- 
+
 from abc import ABCMeta, abstractmethod
 import config
 import languageHandler
 from synthDriverHandler import getSynth
+from inspect import signature
+from functools import partial
+from types import FunctionType, MethodType
+from typing import Union
 
 class SpeechCommand(object):
 	"""The base class for objects that can be inserted between strings of text to perform actions, change voice parameters, etc.
@@ -36,7 +40,8 @@ def __init__(self,index):
 		@param index: the value of this index
 		@type index: integer
 		"""
-		if not isinstance(index,int): raise ValueError("index must be int, not %s"%type(index))
+		if not isinstance(index,int):
+			raise TypeError("index must be int, not %s"%type(index))
 		self.index=index
 
 	def __repr__(self):
@@ -245,6 +250,8 @@ def run(self):
 		otherwise it will block production of further speech and or other functionality in NVDA.
 		"""
 
+SUPPORTED_CALLBACK_TYPES = (FunctionType, MethodType, partial)
+
 class CallbackCommand(BaseCallbackCommand):
 	"""
 	Call a function when speech reaches this point.
@@ -253,12 +260,27 @@ class CallbackCommand(BaseCallbackCommand):
 		otherwise it will block production of further speech and or other functionality in NVDA.
 	"""
 
-	def __init__(self, callback):
+	def __init__(self, callback: Union[SUPPORTED_CALLBACK_TYPES]):
+		if not isinstance(callback, SUPPORTED_CALLBACK_TYPES):
+			raise TypeError(
+				"callback must be one of %s, not %s"
+				% (", ".join(SUPPORTED_CALLBACK_TYPES), type(callback))
+			)
 		self._callback = callback
 
 	def run(self,*args, **kwargs):
 		return self._callback(*args,**kwargs)
 
+	def __repr__(self):
+		if isinstance(self._callback, partial):
+			callBackName = "partial[{}]".format(self._callback.func.__qualname__)
+		else:
+			callBackName = self._callback.__qualname__
+		return "CallbackCommand({name}{signature})".format(
+			name=callBackName,
+			signature=str(signature(self._callback))
+		)
+
 class BeepCommand(BaseCallbackCommand):
 	"""Produce a beep.
 	"""