Say all, move caret per word instead of per line/sentence, taken over after abandoned 9937

source/config/configSpec.py

@@ -43,6 +43,7 @@
 		sayCapForCapitals = boolean(default=false)
 		beepForCapitals = boolean(default=false)
 		useSpellingFunctionality = boolean(default=true)
+		increaseSayAllCaretUpdates = boolean(default=false)
 
 # Audio settings
 [audio]

source/gui/settingsDialogs.py

@@ -1468,6 +1468,16 @@ def makeSettings(self, settingsSizer):
 			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.SetValue(
+			config.conf["speech"][self.driver.name]["increaseSayAllCaretUpdates"]
+		)
+
 	def onSave(self):
 		AutoSettingsMixin.onSave(self)
 
@@ -1484,6 +1494,10 @@ 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"][self.driver.name]["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,7 @@
 import api
 import textInfos
 import queueHandler
+import time
 import winKernel
 
 CURSOR_CARET = 0
@@ -101,6 +103,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
@@ -167,6 +171,12 @@ def _onLineReached(obj=self.reader.obj, state=state):
 			self.reader,
 			unit=textInfos.UNIT_READINGCHUNK,
 			reason=controlTypes.REASON_SAYALL,
+			_prefixSpeechCommand=cb,
+			_whiteSpaceReachedCallback=(
+				self.endOfWhiteSpaceReached
+				if config.conf["speech"][synthDriverHandler.getSynth().name]["increaseSayAllCaretUpdates"]
+				else None
+			),
 			useCache=state
 		)
 		seq = list(speech._flattenNestedSequences(speechGen))
@@ -198,15 +208,27 @@ def _onLineReached(obj=self.reader.obj, state=state):
 				# 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)
+
 		winKernel.SetThreadExecutionState(winKernel.ES_SYSTEM_REQUIRED | winKernel.ES_DISPLAY_REQUIRED)
+
 		if self.numBufferedLines == 0:
 			# This was the last line spoken, so move on.
 			self.nextLine()

source/speech/__init__.py

@@ -50,7 +50,7 @@
 	WaveFileCommand,
 	ConfigProfileTriggerCommand,
 )
-
+from . import types
 from .types import (
 	SpeechSequence,
 	SequenceItemT,
@@ -1042,13 +1042,21 @@ def _extendSpeechSequence_addMathForTextInfo(
 		return
 
 
+re_white_space = re.compile(r"(\s+|$)", re.DOTALL)
+
+
+class _TextChunk(str):
+	"""str subclass to distinguish normal text from field text when processing text info speech."""
+
+
 def speakTextInfo(
 		info: textInfos.TextInfo,
 		useCache: Union[bool, SpeakTextInfoState] = True,
 		formatConfig: Dict[str, bool] = None,
 		unit: Optional[str] = None,
 		reason: OutputReason = controlTypes.REASON_QUERY,
 		_prefixSpeechCommand: Optional[SpeechCommand] = None,
+		_whiteSpaceReachedCallback: Optional[Callable[[Any], None]] = None,
 		onlyInitialFields: bool = False,
 		suppressBlanks: bool = False,
 		priority: Optional[Spri] = None
@@ -1060,6 +1068,7 @@ def speakTextInfo(
 		unit,
 		reason,
 		_prefixSpeechCommand,
+		_whiteSpaceReachedCallback,
 		onlyInitialFields,
 		suppressBlanks
 	)
@@ -1088,10 +1097,12 @@ def getTextInfoSpeech(  # noqa: C901
 		unit: Optional[str] = None,
 		reason: OutputReason = controlTypes.REASON_QUERY,
 		_prefixSpeechCommand: Optional[SpeechCommand] = None,
+		_whiteSpaceReachedCallback: Optional[Callable[[Any], None]] = None,
 		onlyInitialFields: bool = False,
 		suppressBlanks: bool = False
 ) -> Generator[SpeechSequence, None, bool]:
 	onlyCache=reason==controlTypes.REASON_ONLYCACHE
+	processWhiteSpace: bool = _whiteSpaceReachedCallback is not None
 	if isinstance(useCache,SpeakTextInfoState):
 		speakTextInfoState=useCache
 	elif useCache:
@@ -1313,9 +1324,9 @@ def isControlEndFieldCommand(x):
 					indentationDone=True
 			if command:
 				if inTextChunk:
-					relativeSpeechSequence[-1]+=command
+					relativeSpeechSequence[-1] = _TextChunk(relativeSpeechSequence[-1] + command)
 				else:
-					relativeSpeechSequence.append(command)
+					relativeSpeechSequence.append(_TextChunk(command))
 					inTextChunk=True
 		elif isinstance(command,textInfos.FieldCommand):
 			newLanguage=None
@@ -1397,16 +1408,49 @@ def isControlEndFieldCommand(x):
 		else:
 			speechSequence.extend(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:
 		shouldConsiderTextInfoBlank = 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, _TextChunk):
+					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
 
+					def _onWhiteSpaceReached(bookmark=bookmark):
+						return _whiteSpaceReachedCallback(bookmark=bookmark)
+
+					curCommandSequence.append(
+						CallbackCommand(_onWhiteSpaceReached, name="getTextInfoSpeech:whiteSpaceReached")
+					)
+					# 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(
@@ -2382,6 +2426,9 @@ def getTableInfoSpeech(
 	return textList
 
 
+re_last_pause = re.compile(r"^(.*?(?<=[^\s.!?])[.!?][\"'”’)]?(?:\s+|$))(.*$)", re.DOTALL)
+
+
 def _yieldIfNonEmpty(seq: SpeechSequence):
 	"""Helper method to yield the sequence if it is not None or empty."""
 	if seq:

source/speech/commands.py

@@ -1,16 +1,21 @@
 # -*- coding: UTF-8 -*-
-#A part of NonVisual Desktop Access (NVDA)
-#This file is covered by the GNU General Public License.
-#See the file COPYING for more details.
-#Copyright (C) 2006-2019 NV Access Limited
+# speech/commands.py
+# A part of NonVisual Desktop Access (NVDA)
+# This file is covered by the GNU General Public License.
+# See the file COPYING for more details.
+# Copyright (C) 2017-2019 NV Access Limited, Babbage B.V.
 
 """Commands that can be embedded in a speech sequence for changing synth parameters, playing sounds or running other callbacks."""
- 
+
 from abc import ABCMeta, abstractmethod
 from typing import Optional
 
 import config
 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.
@@ -32,12 +37,12 @@ class IndexCommand(SynthCommand):
 	NVDA handles the indexing and dispatches callbacks as appropriate.
 	"""
 
-	def __init__(self,index):
+	def __init__(self, index: int):
 		"""
 		@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(f"index must be int, not {type(index)}")
 		self.index=index
 
 	def __repr__(self):
@@ -245,6 +250,10 @@ 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,18 +262,31 @@ class CallbackCommand(BaseCallbackCommand):
 		otherwise it will block production of further speech and or other functionality in NVDA.
 	"""
 
-	def __init__(self, callback, name: Optional[str] = None):
+	def __init__(self, callback: Union[SUPPORTED_CALLBACK_TYPES], name: Optional[str] = None):
+		if not isinstance(callback, SUPPORTED_CALLBACK_TYPES):
+			raise TypeError(
+				"callback must be one of %s, not %s"
+				% (", ".join(str(t) for t in SUPPORTED_CALLBACK_TYPES), type(callback))
+			)
 		self._callback = callback
-		self._name = name if name else repr(callback)
+		if name:
+			self._name = name
+		elif isinstance(callback, partial):
+			self._name = "partial[{}]".format(callback.func.__qualname__)
+		else:
+			self.name = callback.__qualname__
+		self._signature = str(signature(callback))
 
 	def run(self,*args, **kwargs):
 		return self._callback(*args,**kwargs)
 
 	def __repr__(self):
-		return "CallbackCommand(name={name})".format(
-			name=self._name
+		return "CallbackCommand({name}{signature})".format(
+			name=self._name,
+			signature=self._signature
 		)
 
+
 class BeepCommand(BaseCallbackCommand):
 	"""Produce a beep.
 	"""

tests/unit/test_SpeechWithoutPauses.py

@@ -128,7 +128,7 @@ class TestOldImplVsNew(unittest.TestCase):
 	"""A test that verifies that the new implementation of SpeechWithoutPauses matches the old behavior.
 	"""
 	def test_stopsSpeakingCase(self):
-		callbackCommand = CallbackCommand(name="dummy", callback=None)
+		callbackCommand = CallbackCommand(name="dummy", callback=lambda: None)
 		lang_en = LangChangeCommand('en')
 		lang_default = LangChangeCommand(None)