# Orca
#
# Copyright 2005-2007 Sun Microsystems Inc.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Library General Public License for more details.
#
# You should have received a copy of the GNU Library General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
"""Bug reproducer for bug x. This standalone module talks
directly with the AT-SPI Registry via its IDL interfaces. No Orca
logic or code is stuck in the middle.
To run this module, merely type 'python bug_x.py'.
To reproduce bug x, follow these steps:
1)
2)
3)
"""
import time
import bonobo
import ORBit
ORBit.load_typelib("Accessibility")
ORBit.CORBA.ORB_init()
import Accessibility
import Accessibility__POA
listeners = []
keystrokeListeners = []
registry = bonobo.get_object("OAFIID:Accessibility_Registry:1.0",
"Accessibility/Registry")
########################################################################
# #
# Event listener classes for global and keystroke events #
# #
########################################################################
class EventListener(Accessibility__POA.EventListener):
"""Registers a callback directly with the AT-SPI Registry for the
given event type. Most users of this module will not use this
class directly, but will instead use the addEventListener method.
"""
def __init__(self, registry, callback, eventType):
self.registry = registry
self.callback = callback
self.eventType = eventType
self.register()
def ref(self): pass
def unref(self): pass
def queryInterface(self, repo_id):
thiz = None
if repo_id == "IDL:Accessibility/EventListener:1.0":
thiz = self._this()
return thiz
def register(self):
self._default_POA().the_POAManager.activate()
self.registry.registerGlobalEventListener(self._this(),
self.eventType)
self.__registered = True
return self.__registered
def deregister(self):
if not self.__registered:
return
self.registry.deregisterGlobalEventListener(self._this(),
self.eventType)
self.__registered = False
def notifyEvent(self, event):
self.callback(event)
def __del__(self):
self.deregister()
class KeystrokeListener(Accessibility__POA.DeviceEventListener):
"""Registers a callback directly with the AT-SPI Registry for the
given keystroke. Most users of this module will not use this
class directly, but will instead use the registerKeystrokeListeners
method."""
def keyEventToString(event):
return ("KEYEVENT: type=%d\n" % event.type) \
+ (" hw_code=%d\n" % event.hw_code) \
+ (" modifiers=%d\n" % event.modifiers) \
+ (" event_string=(%s)\n" % event.event_string) \
+ (" is_text=%s\n" % event.is_text) \
+ (" time=%f" % time.time())
keyEventToString = staticmethod(keyEventToString)
def __init__(self, registry, callback,
keyset, mask, type, synchronous, preemptive, isGlobal):
self._default_POA().the_POAManager.activate()
self.registry = registry
self.callback = callback
self.keyset = keyset
self.mask = mask
self.type = type
self.mode = Accessibility.EventListenerMode()
self.mode.synchronous = synchronous
self.mode.preemptive = preemptive
self.mode._global = isGlobal
self.register()
def ref(self): pass
def unref(self): pass
def queryInterface(self, repo_id):
thiz = None
if repo_id == "IDL:Accessibility/EventListener:1.0":
thiz = self._this()
return thiz
def register(self):
d = self.registry.getDeviceEventController()
if d.registerKeystrokeListener(self._this(),
self.keyset,
self.mask,
self.type,
self.mode):
self.__registered = True
else:
self.__registered = False
return self.__registered
def deregister(self):
if not self.__registered:
return
d = self.registry.getDeviceEventController()
d.deregisterKeystrokeListener(self._this(),
self.keyset,
self.mask,
self.type)
self.__registered = False
def notifyEvent(self, event):
"""Called by the at-spi registry when a key is pressed or released.
Arguments:
- event: an at-spi DeviceEvent
Returns True if the event has been consumed.
"""
return self.callback(event)
def __del__(self):
self.deregister()
########################################################################
# #
# Testing functions. #
# #
########################################################################
def start():
"""Starts event notification with the AT-SPI Registry. This method
only returns after 'stop' has been called.
"""
bonobo.main()
def stop():
"""Unregisters any event or keystroke listeners registered with
the AT-SPI Registry and then stops event notification with the
AT-SPI Registry.
"""
for listener in (listeners + keystrokeListeners):
listener.deregister()
bonobo.main_quit()
def registerEventListener(callback, eventType):
global listeners
listener = EventListener(registry, callback, eventType)
listeners.append(listener)
def registerKeystrokeListeners(callback):
"""Registers a single callback for all possible keystrokes.
"""
global keystrokeListeners
for i in range(0, (1 << (Accessibility.MODIFIER_NUMLOCK + 1))):
keystrokeListeners.append(
KeystrokeListener(registry,
callback, # callback
[], # keyset
i, # modifier mask
[Accessibility.KEY_PRESSED_EVENT,
Accessibility.KEY_RELEASED_EVENT],
True, # synchronous
True, # preemptive
False)) # global
def getNameString(acc):
if acc.name:
return "'%s'" % acc.name
else:
return "None"
def getAccessibleString(acc):
return "name=%s role='%s'" % (getNameString(acc), acc.getRoleName())
eventTypes = [
"focus:"
]
def printFrame(obj):
while obj:
obj.ref()
if obj.getRoleName() == "frame":
print "FRM:", obj, getAccessibleString(obj)
obj = obj.parent
def notifyEvent(event):
print "OBJ:", event.source, getAccessibleString(event.source)
printFrame(event.source)
def notifyKeystroke(event):
if event.event_string == "F12":
shutdownAndExit()
return False
def shutdownAndExit(signum=None, frame=None):
stop()
print "Goodbye."
def test():
print "Press F12 to Exit."
for eventType in eventTypes:
registerEventListener(notifyEvent, eventType)
registerKeystrokeListeners(notifyKeystroke)
start()
if __name__ == "__main__":
import signal
signal.signal(signal.SIGINT, shutdownAndExit)
signal.signal(signal.SIGQUIT, shutdownAndExit)
test()