nvda-commits Mailing List for NonVisual Desktop Access (Page 681)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

The branch t3825 has been updated
  From 99d5c9a to cd3bc57

New revisions:

- Log -----------------------------------------------------------------
commit cd3bc578f4e8d20be9a93aef75c82c2bfc362b03
Author: James Teh <ja...@nv...>
Date:   Tue Feb 4 12:58:20 2014 +1000

    cancellableSendMessageTimeout: Rather than continually cancelling individual calls with an auto reset event, just set it once when cancellation starts and reset it when the core is alive.
    
    Previously, it was possible that the first message after the core recovered would be cancelled if there wasn't a message after the last recovery attempt.
    Also, this way, we don't bother to send any messages at all once cancellation begins, which is more efficient.

commit 7c383bf320b9ee11874fc3a4f967f7a39d869a91
Merge: 99d5c9a a59e007
Author: James Teh <ja...@nv...>
Date:   Tue Feb 4 14:41:40 2014 +1000

    Merge branch 't3801' into t3825

-----------------------------------------------------------------------

Summary of changes:
 nvdaHelper/local/nvdaHelperLocal.cpp |   14 ++---
 nvdaHelper/local/nvdaHelperLocal.def |    2 +-
 nvdaHelper/local/nvdaHelperLocal.h   |    1 -
 source/IAccessibleHandler.py         |   25 ++++----
 source/JABHandler.py                 |    2 +
 source/core.py                       |   61 +++++++++++++++++---
 source/mouseHandler.py               |    2 +
 source/pythonConsole.py              |    4 ++
 source/queueHandler.py               |    5 ++
 source/touchHandler.py               |   33 ++++++-----
 source/touchTracker.py               |    7 ++-
 source/watchdog.py                   |  105 ++++++++++++++++++++--------------
 12 files changed, 173 insertions(+), 88 deletions(-)

diff --git a/nvdaHelper/local/nvdaHelperLocal.cpp b/nvdaHelper/local/nvdaHelperLocal.cpp
index fba2d56..382ddb7 100644
--- a/nvdaHelper/local/nvdaHelperLocal.cpp
+++ b/nvdaHelper/local/nvdaHelperLocal.cpp
@@ -75,7 +75,7 @@ handle_t createRemoteBindingHandle(wchar_t* uuidString) {
 
 const UINT CANCELSENDMESSAGE_CHECK_INTERVAL = 1000;
 DWORD mainThreadId = 0;
-HANDLE cancelSendMessageEvent = NULL;
+HANDLE cancelCallEvent = NULL;
 void(__stdcall *_notifySendMessageCancelled)() = NULL;
 struct BgSendMessageData {
 	HANDLE completeEvent;
@@ -148,7 +148,7 @@ LRESULT cancellableSendMessageTimeout(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM
 		return 0;
 	}
 
-	if (WaitForSingleObject(cancelSendMessageEvent, 0) == WAIT_OBJECT_0) {
+	if (WaitForSingleObject(cancelCallEvent, 0) == WAIT_OBJECT_0) {
 		// Already cancelled, so don't bother going any further.
 		SetLastError(ERROR_CANCELLED);
 		return 0;
@@ -206,7 +206,7 @@ LRESULT cancellableSendMessageTimeout(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM
 		SetEvent(bgSendMessageData->execEvent);
 	}
 
-	HANDLE waitHandles[] = {bgSendMessageData->completeEvent, cancelSendMessageEvent};
+	HANDLE waitHandles[] = {bgSendMessageData->completeEvent, cancelCallEvent};
 	DWORD waitIndex = 0;
 	if (fuFlags & SMTO_BLOCK) {
 		waitIndex = WaitForMultipleObjects(2, waitHandles, FALSE, INFINITE);
@@ -239,10 +239,6 @@ LRESULT cancellableSendMessageTimeout(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM
 	return 1;
 }
 
-void cancelSendMessage() {
-	SetEvent(cancelSendMessageEvent);
-}
-
 LRESULT WINAPI fake_SendMessageW(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam) {
 	DWORD_PTR result = 0;
 	cancellableSendMessageTimeout(hwnd, Msg, wParam, lParam, 0, 60000, &result);
@@ -256,7 +252,7 @@ LRESULT WINAPI fake_SendMessageTimeoutW(HWND hwnd, UINT Msg, WPARAM wParam, LPAR
 void nvdaHelperLocal_initialize() {
 	startServer();
 	mainThreadId = GetCurrentThreadId();
-	cancelSendMessageEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+	cancelCallEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 	HMODULE oleacc = LoadLibraryA("oleacc.dll");
 	if (!oleacc)
 		return;
@@ -292,7 +288,7 @@ void nvdaHelperLocal_terminate() {
 		bgSendMessageData->hwnd = NULL;
 		SetEvent(bgSendMessageData->execEvent);
 	}
-	CloseHandle(cancelSendMessageEvent);
+	CloseHandle(cancelCallEvent);
 	stopServer();
 }
 
diff --git a/nvdaHelper/local/nvdaHelperLocal.def b/nvdaHelper/local/nvdaHelperLocal.def
index d6f99a1..9c67f3a 100644
--- a/nvdaHelper/local/nvdaHelperLocal.def
+++ b/nvdaHelper/local/nvdaHelperLocal.def
@@ -1,7 +1,7 @@
 EXPORTS
 	createRemoteBindingHandle
 	cancellableSendMessageTimeout
-	cancelSendMessage
+	cancelCallEvent
 	_notifySendMessageCancelled
 	nvdaHelperLocal_initialize
 	nvdaHelperLocal_terminate
diff --git a/nvdaHelper/local/nvdaHelperLocal.h b/nvdaHelper/local/nvdaHelperLocal.h
index a9ee2fc..175135b 100755
--- a/nvdaHelper/local/nvdaHelperLocal.h
+++ b/nvdaHelper/local/nvdaHelperLocal.h
@@ -18,7 +18,6 @@ http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 
 handle_t createRemoteBindingHandle(wchar_t* uuidString);
 LRESULT cancellableSendMessageTimeout(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT fuFlags, UINT uTimeout, PDWORD_PTR lpdwResult);
-void cancelSendMessage();
 void nvdaHelperLocal_initialize();
 void nvdaHelperLocal_terminate();
 
diff --git a/source/IAccessibleHandler.py b/source/IAccessibleHandler.py
index 200be58..21b391d 100644
--- a/source/IAccessibleHandler.py
+++ b/source/IAccessibleHandler.py
@@ -28,6 +28,7 @@ import appModuleHandler
 import mouseHandler
 import controlTypes
 import keyboardHandler
+import core
 
 MAX_WINEVENTS=500
 MAX_WINEVENTS_PER_THREAD=10
@@ -75,16 +76,18 @@ class OrderedWinEventLimiter(object):
 		@type childID: integer
 		@param threadID: the threadID of the winEvent
 		@type threadID: integer
+		@return: C{True} if the event was added, C{False} if it was discarded.
+		@rtype: bool
 		"""
 		if eventID==winUser.EVENT_OBJECT_FOCUS:
 			if objectID in (winUser.OBJID_SYSMENU,winUser.OBJID_MENU) and childID==0:
 				# This is a focus event on a menu bar itself, which is just silly. Ignore it.
-				return
+				return False
 			#We do not need a focus event on an object if we already got a foreground event for it
 			if (winUser.EVENT_SYSTEM_FOREGROUND,window,objectID,childID,threadID) in self._focusEventCache:
-				return
+				return False
 			self._focusEventCache[(eventID,window,objectID,childID,threadID)]=next(self._eventCounter)
-			return
+			return True
 		elif eventID==winUser.EVENT_SYSTEM_FOREGROUND:
 			self._focusEventCache.pop((winUser.EVENT_OBJECT_FOCUS,window,objectID,childID,threadID),None)
 			self._focusEventCache[(eventID,window,objectID,childID,threadID)]=next(self._eventCounter)
@@ -92,16 +95,17 @@ class OrderedWinEventLimiter(object):
 			k=(winUser.EVENT_OBJECT_HIDE,window,objectID,childID,threadID)
 			if k in self._genericEventCache:
 				del self._genericEventCache[k]
-				return
+				return True
 		elif eventID==winUser.EVENT_OBJECT_HIDE:
 			k=(winUser.EVENT_OBJECT_SHOW,window,objectID,childID,threadID)
 			if k in self._genericEventCache:
 				del self._genericEventCache[k]
-				return
+				return True
 		elif eventID in MENU_EVENTIDS:
 			self._lastMenuEvent=(next(self._eventCounter),eventID,window,objectID,childID,threadID)
-			return
+			return True
 		self._genericEventCache[(eventID,window,objectID,childID,threadID)]=next(self._eventCounter)
+		return True
 
 	def flushEvents(self):
 		"""Returns a list of winEvents (tuples of eventID,window,objectID,childID) that have been added, though due to limiting, it will not necessarily be all the winEvents that were originally added. They are definitely garenteed to be in the correct order though.
@@ -565,7 +569,8 @@ def winEventCallback(handle,eventID,window,objectID,childID,threadID,timestamp):
 			# If we send a WM_NULL to this window at this point (which happens in accessibleObjectFromEvent), Messenger will silently exit (#677).
 			# Therefore, completely ignore these events, which is useless to us anyway.
 			return
-		winEventLimiter.addEvent(eventID,window,objectID,childID,threadID)
+		if winEventLimiter.addEvent(eventID,window,objectID,childID,threadID):
+			core.requestPump()
 	except:
 		log.error("winEventCallback", exc_info=True)
 
@@ -690,8 +695,7 @@ def processDesktopSwitchWinEvent(window,objectID,childID):
 	hDesk=windll.user32.OpenInputDesktop(0, False, 0)
 	if hDesk!=0:
 		windll.user32.CloseDesktop(hDesk)
-		import wx
-		wx.CallLater(200, _correctFocus)
+		core.callLater(200, _correctFocus)
 	else:
 		# Switching to a secure desktop.
 		# We don't receive key up events for any keys down before switching to a secure desktop,
@@ -790,8 +794,7 @@ def processFakeFocusWinEvent(eventID, window, objectID, childID):
 	"""
 	# A suitable event for faking the focus has been received with no focus event, so we probably need to find the focus and fake it.
 	# However, it is possible that the focus event has simply been delayed, so wait a bit and only do it if the focus hasn't changed yet.
-	import wx
-	wx.CallLater(50, _fakeFocus, api.getFocusObject())
+	core.callLater(50, _fakeFocus, api.getFocusObject())
 
 def _fakeFocus(oldFocus):
 	if oldFocus is not api.getFocusObject():
diff --git a/source/JABHandler.py b/source/JABHandler.py
index a057d8e..1db108d 100644
--- a/source/JABHandler.py
+++ b/source/JABHandler.py
@@ -16,6 +16,7 @@ import api
 import eventHandler
 import controlTypes
 import NVDAObjects.JAB
+import core
 
 #Some utility functions to help with function defines
 
@@ -230,6 +231,7 @@ internalFunctionQueue.__name__="JABHandler.internalFunctionQueue"
 
 def internalQueueFunction(func,*args,**kwargs):
 	internalFunctionQueue.put_nowait((func,args,kwargs))
+	core.requestPump()
 
 class JABContext(object):
 
diff --git a/source/core.py b/source/core.py
index 6377487..d1a32f3 100644
--- a/source/core.py
+++ b/source/core.py
@@ -25,6 +25,11 @@ import globalVars
 from logHandler import log
 import addonHandler
 
+PUMP_MAX_DELAY = 10
+
+_pump = None
+_isPumpPending = False
+
 def doStartupDialogs():
 	import config
 	import gui
@@ -116,7 +121,7 @@ def _setInitialFocus():
 
 def main():
 	"""NVDA's core main loop.
-This initializes all modules such as audio, IAccessible, keyboard, mouse, and GUI. Then it initialises the wx application object and installs the core pump timer, which checks the queues and executes functions every 1 ms. Finally, it starts the wx main loop.
+This initializes all modules such as audio, IAccessible, keyboard, mouse, and GUI. Then it initialises the wx application object and sets up the core pump, which checks the queues and executes functions when requested. Finally, it starts the wx main loop.
 """
 	log.debug("Core starting")
 	import config
@@ -281,13 +286,19 @@ This initializes all modules such as audio, IAccessible, keyboard, mouse, and GU
 	queueHandler.queueFunction(queueHandler.eventQueue, _setInitialFocus)
 	import watchdog
 	import baseObject
+
+	# Doing this here is a bit ugly, but we don't want these modules imported
+	# at module level, including wx.
+	log.debug("Initializing core pump")
 	class CorePump(wx.Timer):
 		"Checks the queues and executes functions."
-		def __init__(self,*args,**kwargs):
-			log.debug("Core pump starting")
-			super(CorePump,self).__init__(*args,**kwargs)
 		def Notify(self):
+			global _isPumpPending
+			_isPumpPending = False
+			watchdog.alive()
 			try:
+				if touchHandler.handler:
+					touchHandler.handler.pump()
 				JABHandler.pumpAll()
 				IAccessibleHandler.pumpAll()
 				queueHandler.pumpAll()
@@ -296,10 +307,16 @@ This initializes all modules such as audio, IAccessible, keyboard, mouse, and GU
 			except:
 				log.exception("errors in this core pump cycle")
 			baseObject.AutoPropertyObject.invalidateCaches()
-			watchdog.alive()
-	log.debug("starting core pump")
-	pump = CorePump()
-	pump.Start(1)
+			watchdog.asleep()
+			if _isPumpPending and not _pump.IsRunning():
+				# #3803: A pump was requested, but the timer was ignored by a modal loop
+				# because timers aren't re-entrant.
+				# Therefore, schedule another pump.
+				_pump.Start(PUMP_MAX_DELAY, True)
+	global _pump
+	_pump = CorePump()
+	requestPump()
+
 	log.debug("Initializing watchdog")
 	watchdog.initialize()
 	try:
@@ -368,3 +385,31 @@ def _terminate(module, name=None):
 	except:
 		log.exception("Error terminating %s" % name)
 
+def requestPump():
+	"""Request a core pump.
+	This will perform any queued activity.
+	It is delayed slightly so that queues can implement rate limiting,
+	filter extraneous events, etc.
+	"""
+	global _isPumpPending
+	if not _pump or _isPumpPending:
+		return
+	_isPumpPending = True
+	_pump.Start(PUMP_MAX_DELAY, True)
+
+def callLater(delay, callable, *args, **kwargs):
+	"""Call a callable once after the specified number of milliseconds.
+	This is currently a thin wrapper around C{wx.CallLater},
+	but this should be used instead for calls which aren't just for UI,
+	as it notifies watchdog appropriately.
+	"""
+	import wx
+	return wx.CallLater(delay, _callLaterExec, callable, args, kwargs)
+
+def _callLaterExec(callable, args, kwargs):
+	import watchdog
+	watchdog.alive()
+	try:
+		return callable(*args, **kwargs)
+	finally:
+		watchdog.asleep()
diff --git a/source/mouseHandler.py b/source/mouseHandler.py
index b6c054c..b7668ac 100644
--- a/source/mouseHandler.py
+++ b/source/mouseHandler.py
@@ -17,6 +17,7 @@ import eventHandler
 from logHandler import log
 import config
 import winInputHook
+import core
 
 WM_MOUSEMOVE=0x0200
 WM_LBUTTONDOWN=0x0201
@@ -75,6 +76,7 @@ def internal_mouseEvent(msg,x,y,injected):
 		curMousePos=(x,y)
 		if msg==WM_MOUSEMOVE: 
 			mouseMoved=True
+			core.requestPump()
 		elif msg in (WM_LBUTTONDOWN,WM_RBUTTONDOWN):
 			queueHandler.queueFunction(queueHandler.eventQueue,speech.cancelSpeech)
 	except:
diff --git a/source/pythonConsole.py b/source/pythonConsole.py
index 563a440..c66630b 100755
--- a/source/pythonConsole.py
+++ b/source/pythonConsole.py
@@ -4,6 +4,8 @@
 #See the file COPYING for more details.
 #Copyright (C) 2008-2013 NV Access Limited
 
+import watchdog
+
 """Provides an interactive Python console which can be run from within NVDA.
 To use, call L{initialize} to create a singleton instance of the console GUI. This can then be accessed externally as L{consoleUI}.
 """
@@ -207,7 +209,9 @@ class ConsoleUI(wx.Frame):
 
 	def execute(self):
 		data = self.inputCtrl.GetValue()
+		watchdog.alive()
 		self.console.push(data)
+		watchdog.asleep()
 		if data:
 			# Only add non-blank lines to history.
 			if len(self.inputHistory) > 1 and self.inputHistory[-2] == data:
diff --git a/source/queueHandler.py b/source/queueHandler.py
index 0db66da..b0b6108 100644
--- a/source/queueHandler.py
+++ b/source/queueHandler.py
@@ -9,6 +9,7 @@ from Queue import Queue
 import globalVars
 from logHandler import log
 import watchdog
+import core
 
 eventQueue=Queue()
 eventQueue.__name__="eventQueue"
@@ -22,6 +23,7 @@ def registerGeneratorObject(generatorObj):
 	lastGeneratorObjID+=1
 	log.debug("Adding generator %d"%lastGeneratorObjID)
 	generators[lastGeneratorObjID]=generatorObj
+	core.requestPump()
 	return lastGeneratorObjID
 
 def cancelGeneratorObject(generatorObjID):
@@ -33,6 +35,7 @@ def cancelGeneratorObject(generatorObjID):
 
 def queueFunction(queue,func,*args,**kwargs):
 	queue.put_nowait((func,args,kwargs))
+	core.requestPump()
 
 def isRunningGenerators():
 	res=len(generators)>0
@@ -75,4 +78,6 @@ def pumpAll():
 			del generators[ID]
 		# Lose our reference so Python can destroy the generator if appropriate.
 		del gen
+	if generators:
+		core.requestPump()
 	flushQueue(eventQueue)
diff --git a/source/touchHandler.py b/source/touchHandler.py
index 573c480..0abd66e 100644
--- a/source/touchHandler.py
+++ b/source/touchHandler.py
@@ -4,6 +4,7 @@
 #See the file COPYING for more details.
 #Copyright (C) 2012 NV Access Limited
 
+import wx
 import threading
 from ctypes import *
 from ctypes.wintypes import *
@@ -15,12 +16,12 @@ import winUser
 import speech
 import api
 import ui
-import queueHandler
 import inputCore
 import screenExplorer
 from logHandler import log
 import touchTracker
 import gui
+import core
 
 availableTouchModes=['text','object']
 
@@ -181,6 +182,7 @@ inputCore.registerGestureSource("ts", TouchInputGesture)
 class TouchHandler(threading.Thread):
 
 	def __init__(self):
+		self.pendingEmitsTimer=wx.PyTimer(core.requestPump)
 		super(TouchHandler,self).__init__()
 		self._curTouchMode='object'
 		self.initializedEvent=threading.Event()
@@ -193,6 +195,7 @@ class TouchHandler(threading.Thread):
 	def terminate(self):
 		windll.user32.PostThreadMessageW(self.ident,WM_QUIT,0,0)
 		self.join()
+		self.pendingEmitsTimer.Stop()
 
 	def run(self):
 		try:
@@ -206,8 +209,6 @@ class TouchHandler(threading.Thread):
 			self.trackerManager=touchTracker.TrackerManager()
 			self.screenExplorer=screenExplorer.ScreenExplorer()
 			self.screenExplorer.updateReview=True
-			self.gesturePump=self.gesturePumpFunc()
-			queueHandler.registerGeneratorObject(self.gesturePump)
 		except Exception as e:
 			self.threadExc=e
 		finally:
@@ -216,7 +217,6 @@ class TouchHandler(threading.Thread):
 		while windll.user32.GetMessageW(byref(msg),None,0,0):
 			windll.user32.TranslateMessage(byref(msg))
 			windll.user32.DispatchMessageW(byref(msg))
-		self.gesturePump.close()
 		oledll.oleacc.AccSetRunningUtilityState(self._touchWindow,ANRUS_TOUCH_MODIFICATION_ACTIVE,0)
 		windll.user32.UnregisterPointerInputTarget(self._touchWindow,PT_TOUCH)
 		windll.user32.DestroyWindow(self._touchWindow)
@@ -231,8 +231,10 @@ class TouchHandler(threading.Thread):
 			ID=winUser.LOWORD(wParam)
 			if touching:
 				self.trackerManager.update(ID,x,y,False)
+				core.requestPump()
 			elif not flags&POINTER_MESSAGE_FLAG_FIRSTBUTTON:
 				self.trackerManager.update(ID,x,y,True)
+				core.requestPump()
 			return 0
 		return windll.user32.DefWindowProcW(hwnd,msg,wParam,lParam)
 
@@ -241,15 +243,20 @@ class TouchHandler(threading.Thread):
 			raise ValueError("Unknown mode %s"%mode)
 		self._curTouchMode=mode
 
-	def gesturePumpFunc(self):
-		while True:
-			for tracker in self.trackerManager.emitTrackers():
-				gesture=TouchInputGesture(tracker,self._curTouchMode)
-				try:
-					inputCore.manager.executeGesture(gesture)
-				except inputCore.NoInputGestureAction:
-					pass
-			yield
+	def pump(self):
+		for tracker in self.trackerManager.emitTrackers():
+			gesture=TouchInputGesture(tracker,self._curTouchMode)
+			try:
+				inputCore.manager.executeGesture(gesture)
+			except inputCore.NoInputGestureAction:
+				pass
+		interval=self.trackerManager.pendingEmitInterval
+		if interval and interval>0:
+			# Ensure we are pumpped again by the time more pending multiTouch trackers are ready
+			self.pendingEmitsTimer.Start(interval*1000,True)
+		else:
+			# Stop the timer in case we were pumpped due to something unrelated but just happened to be at the appropriate time to clear any remaining trackers 
+			self.pendingEmitsTimer.Stop()
 
 	def notifyInteraction(self, obj):
 		"""Notify the system that UI interaction is occurring via touch.
diff --git a/source/touchTracker.py b/source/touchTracker.py
index 0fcd302..3d8ccc0 100644
--- a/source/touchTracker.py
+++ b/source/touchTracker.py
@@ -197,12 +197,14 @@ class TrackerManager(object):
 			if tracker.action!=action_hoverDown:
 				self.multiTouchTrackers.append(tracker)
 
+	pendingEmitInterval=None #: If set: how long to wait before calling emitTrackers again as trackers are still in the queue 
 	def emitTrackers(self):
 		"""
 		Yields queued trackers that have existed in the queue for long enough to not be connected with other trackers.
 		A part from a timeout, trackers are also not emitted if there are other fingers touching that still have an unknown action. 
 		If there are no queued trackers to yield but there is a hover tracker, a hover action is yielded instead.
 		"""
+		self.pendingEmitInterval=None
 		t=time.time()
 		hasUnknownTrackers=False
 		lastHoverTracker=None
@@ -217,10 +219,13 @@ class TrackerManager(object):
 		if not hasUnknownTrackers:
 			for tracker in list(self.multiTouchTrackers):
 				#All trackers can be emitted with no delay except for tap which must wait for the timeout (to detect plural taps)
-				if tracker.action!=action_tap or (tracker.startTime+multitouchTimeout)<=t:
+				trackerTimeout=(tracker.startTime+multitouchTimeout)-t if tracker.action==action_tap else 0 
+				if trackerTimeout<=0: 
 					self.multiTouchTrackers.remove(tracker)
 					foundTrackers=True
 					yield tracker
+				else:
+					self.pendingEmitInterval=min(self.pendingEmitInterval,trackerTimeout) if self.pendingEmitInterval else trackerTimeout
 		#If no tracker could be emitted, at least emit the most recent  hover tracker if there is one
 		if not foundTrackers and lastHoverTracker:
 			yield MultiTouchTracker(lastHoverTracker.action,lastHoverTracker.x,lastHoverTracker.y,lastHoverTracker.startTime,t,1,1,self.numHeldFingers-1)
diff --git a/source/watchdog.py b/source/watchdog.py
index ca19c70..17f891c 100644
--- a/source/watchdog.py
+++ b/source/watchdog.py
@@ -15,14 +15,16 @@ import comtypes
 import winUser
 import winKernel
 from logHandler import log
+import NVDAHelper
 
 #settings
 #: How often to check whether the core is alive
 CHECK_INTERVAL=0.1
-#: How long to wait for the core to be alive under normal circumstances
-NORMAL_CORE_ALIVE_TIMEOUT=10
-#: The minimum time to wait for the core to be alive
+#: The minimum time to wait for the core to be alive.
 MIN_CORE_ALIVE_TIMEOUT=0.5
+#: How long to wait for the core to be alive under normal circumstances.
+#: This must be a multiple of MIN_CORE_ALIVE_TIMEOUT.
+NORMAL_CORE_ALIVE_TIMEOUT=10
 #: How long to wait between recovery attempts
 RECOVER_ATTEMPT_INTERVAL = 0.05
 #: The amount of time before the core should be considered severely frozen and a warning logged.
@@ -37,8 +39,8 @@ safeWindowClassSet=set([
 isRunning=False
 isAttemptingRecovery = False
 
-_coreAliveEvent = threading.Event()
-_resumeEvent = threading.Event()
+_coreDeadTimer = windll.kernel32.CreateWaitableTimerW(None, True, None)
+_suspended = False
 _coreThreadID=windll.kernel32.GetCurrentThreadId()
 _watcherThread=None
 
@@ -49,49 +51,63 @@ class CallCancelled(Exception):
 def alive():
 	"""Inform the watchdog that the core is alive.
 	"""
-	global _coreAliveEvent
-	_coreAliveEvent.set()
+	# Stop cancelling calls.
+	windll.kernel32.ResetEvent(ctypes.wintypes.HANDLE.in_dll(
+		NVDAHelper.localLib, "cancelCallEvent"))
+	# Set the timer so the watcher will take action in MIN_CORE_ALIVE_TIMEOUT
+	# if this function or asleep() isn't called.
+	windll.kernel32.SetWaitableTimer(_coreDeadTimer,
+		ctypes.byref(ctypes.wintypes.LARGE_INTEGER(-int(10000000 * MIN_CORE_ALIVE_TIMEOUT))),
+		0, None, None, False)
+
+def asleep():
+	"""Inform the watchdog that the core is going to sleep.
+	"""
+	windll.kernel32.CancelWaitableTimer(_coreDeadTimer)
+
+def _isAlive():
+	return winKernel.waitForSingleObject(_coreDeadTimer, 0) != 0
 
 def _watcher():
 	global isAttemptingRecovery
-	while isRunning:
-		# If the watchdog is suspended, wait until it is resumed.
-		_resumeEvent.wait()
-
-		# Wait for the core to be alive.
-		# Wait a maximum of NORMAL_CORE_ALIVE_TIMEOUT, but shorten this to a minimum of MIN_CORE_ALIVE_TIMEOUT under special circumstances.
-		waited = 0
-		while True:
-			# Wait MIN_CORE_ALIVE_TIMEOUT, unless there is less than that time remaining for NORMAL_CORE_ALIVE_TIMEOUT.
-			timeout = min(MIN_CORE_ALIVE_TIMEOUT, NORMAL_CORE_ALIVE_TIMEOUT - waited)
-			if timeout <= 0:
-				# Timeout elapsed.
-				break
-			_coreAliveEvent.wait(timeout)
-			waited += timeout
-			if _coreAliveEvent.isSet() or _shouldRecoverAfterMinTimeout():
+	while True:
+		# Wait for the core to die.
+		winKernel.waitForSingleObject(_coreDeadTimer, winKernel.INFINITE)
+		if not isRunning:
+			return
+		# The core hasn't reported alive for MIN_CORE_ALIVE_TIMEOUT.
+		waited = MIN_CORE_ALIVE_TIMEOUT
+		while not _isAlive() and not _shouldRecoverAfterMinTimeout():
+			# The core is still dead and fast recovery doesn't apply.
+			# Wait up to NORMAL_ALIVE_TIMEOUT.
+			time.sleep(MIN_CORE_ALIVE_TIMEOUT)
+			waited += MIN_CORE_ALIVE_TIMEOUT
+			if waited >= NORMAL_CORE_ALIVE_TIMEOUT:
 				break
-		if log.isEnabledFor(log.DEBUGWARNING) and not _coreAliveEvent.isSet():
+		if _isAlive():
+			continue
+		if log.isEnabledFor(log.DEBUGWARNING):
 			log.debugWarning("Trying to recover from freeze, core stack:\n%s"%
 				"".join(traceback.format_stack(sys._current_frames()[_coreThreadID])))
 		lastTime=time.time()
-		while not _coreAliveEvent.isSet():
+		isAttemptingRecovery = True
+		# Cancel calls until the core is alive.
+		# This event will be reset by alive().
+		windll.kernel32.SetEvent(ctypes.wintypes.HANDLE.in_dll(
+			NVDAHelper.localLib, "cancelCallEvent"))
+		# Some calls have to be killed individually.
+		while True:
 			curTime=time.time()
 			if curTime-lastTime>FROZEN_WARNING_TIMEOUT:
 				lastTime=curTime
 				log.warning("Core frozen in stack:\n%s"%
 					"".join(traceback.format_stack(sys._current_frames()[_coreThreadID])))
-			# The core is dead, so attempt recovery.
-			isAttemptingRecovery = True
 			_recoverAttempt()
-			_coreAliveEvent.wait(RECOVER_ATTEMPT_INTERVAL)
+			time.sleep(RECOVER_ATTEMPT_INTERVAL)
+			if _isAlive():
+				break
 		isAttemptingRecovery = False
 
-		# At this point, the core is alive.
-		_coreAliveEvent.clear()
-		# Wait a bit to avoid excessive resource consumption.
-		time.sleep(CHECK_INTERVAL)
-
 def _shouldRecoverAfterMinTimeout():
 	info=winUser.getGUIThreadInfo(0)
 	if not info.hwndFocus:
@@ -116,8 +132,6 @@ def _recoverAttempt():
 		oledll.ole32.CoCancelCall(_coreThreadID,0)
 	except:
 		pass
-	import NVDAHelper
-	NVDAHelper.localLib.cancelSendMessage()
 
 @ctypes.WINFUNCTYPE(ctypes.wintypes.LONG, ctypes.c_void_p)
 def _crashHandler(exceptionInfo):
@@ -158,13 +172,11 @@ def initialize():
 	windll.kernel32.SetUnhandledExceptionFilter(_crashHandler)
 	oledll.ole32.CoEnableCallCancellation(None)
 	# Handle cancelled SendMessage calls.
-	import NVDAHelper
 	NVDAHelper._setDllFuncPointer(NVDAHelper.localLib, "_notifySendMessageCancelled", _notifySendMessageCancelled)
 	# Monkey patch comtypes to specially handle cancelled COM calls.
 	comtypes.COMError.__init__ = _COMError_init
-	_coreAliveEvent.set()
-	_resumeEvent.set()
 	_watcherThread=threading.Thread(target=_watcher)
+	alive()
 	_watcherThread.start()
 
 def terminate():
@@ -176,8 +188,10 @@ def terminate():
 	isRunning=False
 	oledll.ole32.CoDisableCallCancellation(None)
 	comtypes.COMError.__init__ = _orig_COMError_init
-	_resumeEvent.set()
-	_coreAliveEvent.set()
+	# Wake up the watcher so it knows to finish.
+	windll.kernel32.SetWaitableTimer(_coreDeadTimer,
+		ctypes.byref(ctypes.wintypes.LARGE_INTEGER(0)),
+		0, None, None, False)
 	_watcherThread.join()
 
 class Suspender(object):
@@ -185,10 +199,14 @@ class Suspender(object):
 	"""
 
 	def __enter__(self):
-		_resumeEvent.clear()
+		global _suspended
+		_suspended = True
+		asleep()
 
 	def __exit__(self,*args):
-		_resumeEvent.set()
+		global _suspended
+		_suspended = False
+		alive()
 
 class CancellableCallThread(threading.Thread):
 	"""A worker thread used to execute a call which must be made cancellable.
@@ -262,7 +280,7 @@ def cancellableExecute(func, *args, **kwargs):
 	"""
 	global cancellableCallThread
 	pumpMessages = kwargs.pop("ccPumpMessages", True)
-	if not isRunning or not _resumeEvent.isSet() or not isinstance(threading.currentThread(), threading._MainThread):
+	if not isRunning or _suspended or not isinstance(threading.currentThread(), threading._MainThread):
 		# Watchdog is not running or this is a background thread,
 		# so just execute the call.
 		return func(*args, **kwargs)
@@ -279,7 +297,6 @@ def cancellableSendMessage(hwnd, msg, wParam, lParam, flags=0, timeout=60000):
 	The call will still be cancelled if appropriate even if the specified timeout has not yet been reached.
 	@raise CallCancelled: If the call was cancelled.
 	"""
-	import NVDAHelper
 	result = ctypes.wintypes.DWORD()
 	NVDAHelper.localLib.cancellableSendMessageTimeout(hwnd, msg, wParam, lParam, flags, timeout, ctypes.byref(result))
 	return result.value




2013	Jan	Feb	Mar	Apr	May	Jun (357)	Jul (585)	Aug (677)	Sep (480)	Oct (476)	Nov (533)	Dec (368)
2014	Jan (542)	Feb (591)	Mar (392)	Apr (512)	May (442)	Jun (583)	Jul (799)	Aug (619)	Sep (674)	Oct (620)	Nov (468)	Dec (848)
2015	Jan (877)	Feb (568)	Mar (366)	Apr (538)	May (349)	Jun (478)	Jul (444)	Aug (399)	Sep (424)	Oct (413)	Nov (227)	Dec (101)
2016	Jan (73)	Feb (39)	Mar (60)	Apr (47)	May (58)	Jun (54)	Jul (148)	Aug (122)	Sep (67)	Oct (60)	Nov (31)	Dec (36)
2017	Jan (76)	Feb (37)	Mar (50)	Apr (42)	May (68)	Jun (58)	Jul (72)	Aug (106)	Sep (48)	Oct (79)	Nov (57)	Dec (59)
2018	Jan (50)	Feb (41)	Mar (73)	Apr (62)	May (66)	Jun (97)	Jul (47)	Aug (33)	Sep (49)	Oct (19)	Nov (40)	Dec (40)
2019	Jan (39)	Feb (29)	Mar (34)	Apr (41)	May (75)	Jun (55)	Jul (44)	Aug (39)	Sep (103)	Oct (65)	Nov (72)	Dec (41)
2020	Jan (40)	Feb (44)	Mar (49)	Apr (57)	May (34)	Jun (58)	Jul (72)	Aug (24)	Sep (61)	Oct (36)	Nov (36)	Dec (31)
2021	Jan (35)	Feb (17)	Mar (50)	Apr (47)	May (71)	Jun (41)	Jul (66)	Aug (32)	Sep (44)	Oct (57)	Nov (32)	Dec (27)
2022	Jan (26)	Feb (46)	Mar (74)	Apr (32)	May (32)	Jun (48)	Jul (50)	Aug (69)	Sep (52)	Oct (61)	Nov (38)	Dec (36)
2023	Jan (45)	Feb (42)	Mar (49)	Apr (35)	May (11)	Jun (56)	Jul (60)	Aug (52)	Sep (109)	Oct (83)	Nov (55)	Dec (59)
2024	Jan (71)	Feb (66)	Mar (50)	Apr (35)	May (86)	Jun (55)	Jul (81)	Aug (13)	Sep	Oct	Nov	Dec

nvda-commits Mailing List for NonVisual Desktop Access (Page 681)

Free, open source screen reader for Windows

nvda-commits — Notification of changes to source code and bug/feature tickets