def decreaseSpeechRate(self, step=5):
"""Decreases the rate of speech for the given ACSS. If
acssName is None, the rate decrease will be applied to all
known ACSSs.
[[[TODO: WDW - this is a hack for now. Need to take min/max
values in account, plus also need to take into account that
different engines provide different rate ranges.]]]
Arguments:
-acssName: the ACSS whose speech rate should be decreased
"""
voices = settings.voices
acss = voices[settings.DEFAULT_VOICE]
speaker = self.__getSpeaker(acss)
rateDelta = settings.speechRateDelta
try:
rate = max(1, self.__getRate(speaker) - rateDelta)
acss[ACSS.RATE] = rate
self.__setRate(speaker, rate)
debug.println(debug.LEVEL_CONFIGURATION,
"speech.decreaseSpeechRate: rate is now " \
" %d" % rate)
# Translators: this is a short string saying that the speech
# synthesis engine is now speaking at a slower rate (words
# per minute).
#
self.speak(_("slower."))
except:
debug.printException(debug.LEVEL_SEVERE)
def getValueForKey(prefsDict, key):
need2repr = ['brailleEOLIndicator', 'brailleContractionTable',
'brailleRequiredStateString', 'enabledBrailledTextAttributes',
'enabledSpokenTextAttributes', 'speechRequiredStateString',
'speechServerFactory', 'presentDateFormat',
'presentTimeFormat']
value = None
if key in prefsDict:
if type(prefsDict[key]) is str:
if key in need2repr:
value = "\'%s\'" % prefsDict[key]
elif key == 'voices':
key = getVoiceKey(key)
value = prefsDict[key]
else:
try:
value = getattr(settings, prefsDict[key])
except:
debug.println(debug.LEVEL_SEVERE,
"Something went wront with key: " % key)
debug.printStack(debug.LEVEL_FINEST)
else:
value = prefsDict[key]
return value
def load(self, keymap, handlers):
""" Takes the keymappings and tries to find a matching named
function in handlers.
keymap is a list of lists, each list contains 5 elements
If addUnbound is set to true, then at the end of loading all the
keybindings, any remaining functions will be unbound.
"""
for i in keymap:
keysymstring = i[0]
modifierMask = i[1]
modifiers = i[2]
handler = i[3]
try:
clickCount = i[4]
except:
clickCount = 1
if handlers.has_key(handler):
# add the keybinding
self.add(KeyBinding( \
keysymstring, modifierMask, modifiers, \
handlers[handler], clickCount))
else:
debug.println(debug.LEVEL_WARNING, \
"WARNING: could not find %s handler to associate " \
"with keybinding." % handler)
def skipObjectEvent(self, event):
"""Gives us, and scripts, the ability to decide an event isn't
worth taking the time to process under the current circumstances.
Arguments:
- event: the Event
Returns True if we shouldn't bother processing this object event.
"""
cachedEvent, eventTime = self.eventCache.get(event.type, [None, 0])
if not cachedEvent or cachedEvent == event:
return False
focus = ["focus:", "object:state-changed:focused"]
typing = ["object:text-changed:insert", "object:text-changed:delete"]
arrowing = ["object:text-caret-moved", "object:text-selection-changed",
"object:selection-changed"]
skip = False
if (event.type in arrowing or event.type in typing) \
and event.source == cachedEvent.source:
skip = True
reason = "more recent event of the same type in the same object"
elif event.type in focus and event.source != cachedEvent.source \
and event.detail1 == cachedEvent.detail1:
skip = True
reason = "more recent event of the same type in a different object"
if skip:
debug.println(debug.LEVEL_FINE,
"script.skipObjectEvent: skipped due to %s" \
% reason)
return skip
def _isSimpleObject(self, obj):
"""Returns True if the given object has 'simple' contents, such as text
without embedded objects or a single embedded object without text."""
if not obj:
return False
try:
children = [child for child in obj]
except (LookupError, RuntimeError):
debug.println(debug.LEVEL_FINE, 'Dead Accessible in %s' % obj)
return False
children = filter(lambda x: x.getRole() != pyatspi.ROLE_LINK, children)
if len(children) > 1:
return False
try:
text = obj.queryText()
except NotImplementedError:
return True
string = text.getText(0, -1).decode('UTF-8').strip()
if string.find(self._script.EMBEDDED_OBJECT_CHARACTER) > -1:
return len(string) == 1
return True
def run(self):
"""Try to start an HTTP server on settings.httpServerPort.
If this fails, retry settings.maxHttpServerRetries times,
each time incrementing the server port number by 1. If we
are still unable to start a server, just fail gracefully.
"""
portNo = settings.httpServerPort
connected = False
while not connected and \
(portNo < settings.httpServerPort + settings.maxHttpServerRetries):
try:
httpd = BaseHTTPServer.HTTPServer(('', portNo),
_HTTPRequestHandler)
connected = True
except:
if portNo == settings.httpServerPort:
debug.printException(debug.LEVEL_WARNING)
debug.println(debug.LEVEL_WARNING,
"httpserver._HTTPRequestThread unable to start server " \
"on port %d" % portNo)
portNo += 1
if not connected:
debug.println(debug.LEVEL_WARNING,
"httpserver._HTTPRequestThread server startup failed.")
else:
httpd.serve_forever()
def reset(self, text=None, acss=None):
"""Resets the speech engine."""
# We might get into a vicious loop of resetting speech, so
# we will abort if we see this happening.
#
if (time.time() - self.__lastResetTime) < 20:
debug.println(debug.LEVEL_SEVERE,
"Something looks wrong with speech. Aborting.")
debug.printStack(debug.LEVEL_ALL)
os._exit(50)
else:
self.__lastResetTime = time.time()
speakers = self.__speakers
self.shutdown()
servers = bonobo.activation.query(
"repo_ids.has('IDL:GNOME/Speech/SynthesisDriver:0.3')")
for server in servers:
if server.iid == self.__iid:
try:
self.__driver = self.__activateDriver(self.__iid)
self.__speakers = {}
for name in speakers.keys():
self.__getSpeaker(speakers[name])
if text:
self.speak(text, acss)
break
except:
debug.printException(debug.LEVEL_SEVERE)
self.__driver = None
pass
def getLongBrailleForRoleName(obj, role=None):
"""Returns the localized name of the given Accessible object; the name is
a long string suitable for a Braille display. If a localized name cannot
be discovered, this will return the string as defined by the at-spi.
Arguments:
- obj: an Accessible object
Returns a string containing the localized name of the object suitable for
a Braille display.
"""
role = _adjustRole(obj, role or obj.getRole())
# If the enum is not in the dictionary, check by name.
role_entry = \
rolenames.get(role) or rolenames.get(obj.getRoleName())
if role_entry:
return role_entry.brailleLong
else:
debug.println(debug.LEVEL_WARNING, "No rolename for %s" % repr(role))
localizedRoleName = obj.getLocalizedRoleName()
if localizedRoleName and len(localizedRoleName):
return localizedRoleName
else:
return repr(role)
def _speak(text, acss, interrupt):
"""Speaks the individual string using the given ACSS."""
if settings.speakMultiCaseStringsAsWords:
text = _processMultiCaseString(text)
if orca_state.activeScript and orca_state.usePronunciationDictionary:
text = orca_state.activeScript.utilities.adjustForPronunciation(text)
if settings.speakMultiCaseStringsAsWords:
text = _processMultiCaseString(text)
logLine = "SPEECH OUTPUT: '" + text + "'"
extraDebug = ""
if acss in settings.voices.values():
for key in settings.voices:
if acss == settings.voices[key]:
if key != settings.DEFAULT_VOICE:
extraDebug = " voice=%s" % key
break
try:
extraDebug = extraDebug.encode("UTF-8")
except UnicodeDecodeError:
pass
debug.println(debug.LEVEL_INFO, logLine + extraDebug)
log.info(logLine + extraDebug)
if _speechserver:
voice = ACSS(settings.voices.get(settings.DEFAULT_VOICE))
try:
voice.update(acss)
except:
pass
_speechserver.speak(text, __resolveACSS(voice), interrupt)
def speak(text, acss=None, interrupt=True):
"""Speaks all queued text immediately. If text is not None,
it is added to the queue before speaking.
Arguments:
- text: optional text to add to the queue before speaking
- acss: acss.ACSS instance; if None,
the default voice settings will be used.
Otherwise, the acss settings will be
used to augment/override the default
voice settings.
- interrupt: if True, stops any speech in progress before
speaking the text
"""
# We will not interrupt a key echo in progress.
#
if orca_state.lastKeyEchoTime:
interrupt = interrupt \
and ((time.time() - orca_state.lastKeyEchoTime) > 0.5)
if settings.silenceSpeech:
return
debug.println(debug.LEVEL_INFO, "SPEECH OUTPUT: '" + text + "'")
log.info("speak utterance='%s'" % text)
if _speechserver:
_speechserver.speak(text, __resolveACSS(acss), interrupt)
def speakKeyEvent(event_string, type):
"""Speaks a key event immediately.
Arguments:
- event_string: string representing the key event as defined by
input_event.KeyboardEvent.
- type: key event type as one of orca.KeyEventType constants.
"""
if settings.silenceSpeech:
return
if _speechserver:
_speechserver.speakKeyEvent(event_string, type)
else:
# Check to see if there are localized words to be spoken for
# this key event.
#
event_string = keynames.getKeyName(event_string)
if type == orca.KeyEventType.LOCKING_LOCKED:
# Translators: this represents the state of a locking modifier
# key (e.g., Caps Lock)
#
event_string += " " + _("on")
elif type == orca.KeyEventType.LOCKING_UNLOCKED:
# Translators: this represents the state of a locking modifier
# key (e.g., Caps Lock)
#
event_string += " " + _("off")
debug.println(debug.LEVEL_INFO, "SPEECH OUTPUT: '" + event_string +"'")
log.info("speakKeyEvent utterance='%s'" % event_string)
def speakUtterances(utterances, acss=None, interrupt=True):
"""Speaks the given list of utterances immediately.
Arguments:
- list: list of strings to be spoken
- acss: acss.ACSS instance; if None,
the default voice settings will be used.
Otherwise, the acss settings will be
used to augment/override the default
voice settings.
- interrupt: if True, stop any speech currently in progress.
"""
# We will not interrupt a key echo in progress.
#
if orca_state.lastKeyEchoTime:
interrupt = interrupt \
and ((time.time() - orca_state.lastKeyEchoTime) > 0.5)
if settings.silenceSpeech:
return
for utterance in utterances:
debug.println(debug.LEVEL_INFO,
"SPEECH OUTPUT: '" + utterance + "'")
log.info("speakUtterances utterance='%s'" % utterance)
if _speechserver:
_speechserver.speakUtterances(utterances,
__resolveACSS(acss),
interrupt)
def init():
if _speechserver:
return
try:
moduleName = settings.speechServerFactory
_initSpeechServer(moduleName,
settings.speechServerInfo)
except:
moduleNames = settings.speechFactoryModules
for moduleName in moduleNames:
if moduleName != settings.speechServerFactory:
try:
_initSpeechServer(moduleName, None)
if _speechserver:
break
except:
debug.printException(debug.LEVEL_SEVERE)
if _speechserver:
debug.println(debug.LEVEL_CONFIGURATION,
"Using speech server factory: %s" % moduleName)
else:
debug.println(debug.LEVEL_CONFIGURATION, "Speech not available.")
def speakKeyEvent(self, event_string, type):
"""Speaks a key event immediately.
Arguments:
- event_string: string representing the key event as defined by
input_event.KeyboardEvent.
- type: key event type as one of orca.KeyEventType constants.
"""
if type == orca.KeyEventType.PRINTABLE and \
event_string.decode("UTF-8").isupper():
voice = settings.voices[settings.UPPERCASE_VOICE]
else:
voice = settings.voices[settings.DEFAULT_VOICE]
# Check to see if there are localized words to be spoken for
# this key event.
#
event_string = keynames.getKeyName(event_string)
if type == orca.KeyEventType.LOCKING_LOCKED:
# Translators: this represents the state of a locking modifier
# key (e.g., Caps Lock)
#
event_string += " " + _("on")
elif type == orca.KeyEventType.LOCKING_UNLOCKED:
# Translators: this represents the state of a locking modifier
# key (e.g., Caps Lock)
#
event_string += " " + _("off")
debug.println(debug.LEVEL_INFO, "SPEECH OUTPUT: '" + event_string +"'")
log.info("speakKeyEvent utterance='%s'" % event_string)
self.speak(event_string, acss=voice)
def decreaseSpeechPitch(self, step=0.5):
"""Decreases the speech pitch for the default voice.
Arguments:
- step: the pitch step decrement.
"""
# [[[TODO: WDW - this is a hack for now. Need to take min/max
# values in account, plus also need to take into account that
# different engines provide different rate ranges.]]]
voices = settings.voices
acss = voices[settings.DEFAULT_VOICE]
speaker = self.__getSpeaker(acss)
pitchDelta = settings.speechPitchDelta
try:
pitch = max(1, self.__getPitch(speaker) - pitchDelta)
acss[ACSS.AVERAGE_PITCH] = pitch
self.__setPitch(speaker, pitch)
debug.println(debug.LEVEL_CONFIGURATION,
"speech.decreaseSpeechPitch: pitch is now " \
" %d" % pitch)
# Translators: this is a short string saying that the speech
# synthesis engine is now speaking in a lower pitch.
#
self.speak(_("lower."))
except:
debug.printException(debug.LEVEL_SEVERE)
def _createScript(self, app, obj=None):
"""For the given application, create a new script instance."""
moduleName = self.getModuleName(app)
script = self._newNamedScript(app, moduleName)
if script:
return script
objToolkit = self._toolkitForObject(obj)
script = self._newNamedScript(app, objToolkit)
if script:
return script
try:
toolkitName = getattr(app, "toolkitName", None)
except (LookupError, RuntimeError):
msg = "Error getting toolkitName for: %s" % app
debug.println(debug.LEVEL_FINE, msg)
else:
if app and toolkitName:
script = self._newNamedScript(app, toolkitName)
if not script:
script = self.getDefaultScript(app)
debug.println(debug.LEVEL_FINE, "Default script created")
return script
def speakKeyEvent(self, event):
"""Speaks a key event immediately.
Arguments:
- event: the input_event.KeyboardEvent.
"""
if event.isPrintableKey() \
and event.event_string.decode("UTF-8").isupper():
voice = ACSS(settings.voices[settings.UPPERCASE_VOICE])
else:
voice = ACSS(settings.voices[settings.DEFAULT_VOICE])
event_string = event.getKeyName()
if orca_state.activeScript and orca_state.usePronunciationDictionary:
event_string = orca_state.activeScript.\
utilities.adjustForPronunciation(event_string)
lockingStateString = event.getLockingStateString()
event_string = "%s %s" % (event_string, lockingStateString)
logLine = "SPEECH OUTPUT: '" + event_string +"'"
debug.println(debug.LEVEL_INFO, logLine)
log.info(logLine)
self.speak(event_string, acss=voice)
def _showNotificationMessage(index):
global indexNotificationMessages
if not _messagesPresent():
return
if index < 1:
index = 1
# Translators: This is a brief message presented to the user when
# when the top of a list of notifications is reached.
#
msg = C_("notification", "Top")
_showMessage(msg)
elif index > size():
index = size()
# Translators: This is a brief message presented to the user when
# when the bottom of a list of notifications is reached.
#
msg = C_("notification", "Bottom")
_showMessage(msg)
indexNotificationMessages = index
index = size() - index
debug.println(debug.LEVEL_FINEST, \
"_showNotificationMessage (queue length: %s, index: %s)"\
% (size(), index))
if index >= 0 and index < size():
msg = notificationMessages[index]
_showMessage(msg)
def increaseSpeechRate(self, step=5):
"""Increases the speech rate.
[[[TODO: WDW - this is a hack for now. Need to take min/max
values in account, plus also need to take into account that
different engines provide different rate ranges.]]]
"""
voices = settings.voices
acss = voices[settings.DEFAULT_VOICE]
speaker = self.__getSpeaker(acss)
rateDelta = settings.speechRateDelta
try:
rate = min(100, self.__getRate(speaker) + rateDelta)
acss[ACSS.RATE] = rate
self.__setRate(speaker, rate)
debug.println(debug.LEVEL_CONFIGURATION,
"speech.increaseSpeechRate: rate is now " \
" %d" % rate)
# Translators: this is a short string saying that the speech
# synthesis engine is now speaking at a faster rate (words
# per minute).
#
self.speak(_("faster."))
except:
debug.printException(debug.LEVEL_SEVERE)
def getModuleName(self, app):
"""Returns the module name of the script to use for application app."""
try:
appAndNameExist = app != None and app.name != ''
except (LookupError, RuntimeError):
appAndNameExist = False
debug.println(debug.LEVEL_SEVERE,
"getModuleName: %s no longer exists" % app)
if not appAndNameExist:
return None
# Many python apps have an accessible name which ends in '.py'.
# Sometimes OOo has 'soffice.bin' as its name.
name = app.name.split('.')[0]
altNames = self._appNames.keys()
names = filter(lambda n: n.lower() == name.lower(), altNames)
if names:
name = self._appNames.get(names[0])
else:
for nameList in (self._appModules, self._toolkitModules):
names = filter(lambda n: n.lower() == name.lower(), nameList)
if names:
name = names[0]
break
debug.println(debug.LEVEL_FINEST, "mapped %s to %s" % (app.name, name))
return name
def _processInputEvent(self, event):
"""Processes the given input event based on the keybinding from the
currently-active script.
Arguments:
- event: an instance of BrailleEvent or a KeyboardEvent
"""
if not orca_state.activeScript:
return
if isinstance(event, input_event.KeyboardEvent):
function = orca_state.activeScript.processKeyboardEvent
data = "'%s' (%d)" % (event.event_string, event.hw_code)
elif isinstance(event, input_event.BrailleEvent):
function = orca_state.activeScript.processBrailleEvent
data = "'%s'" % repr(event.event)
else:
return
eType = str(event.type).upper()
debug.println(debug.eventDebugLevel, "\nvvvvv PROCESS %s %s vvvvv" % (eType, data))
try:
function(event)
except:
debug.printException(debug.LEVEL_WARNING)
debug.printStack(debug.LEVEL_WARNING)
debug.println(debug.eventDebugLevel, "^^^^^ PROCESS %s %s ^^^^^\n" % (eType, data))
def __speak(self, text=None, acss=None, interrupt=True):
"""Speaks all queued text immediately. If text is not None,
it is added to the queue before speaking.
Arguments:
- text: optional text to add to the queue before speaking
- acss: acss.ACSS instance; if None,
the default voice settings will be used.
Otherwise, the acss settings will be
used to augment/override the default
voice settings.
- interrupt: if True, stops any speech in progress before
speaking the text
Returns an id of the thing being spoken or -1 if nothing is to
be spoken.
"""
# If the user has speech turned off, just return.
#
if not settings.enableSpeech:
return -1
speaker = self.__getSpeaker(acss)
if acss and not acss.has_key(ACSS.RATE):
voices = settings.voices
defaultACSS = voices[settings.DEFAULT_VOICE]
if defaultACSS.has_key(ACSS.RATE):
self.__setRate(speaker, defaultACSS[ACSS.RATE])
if not text:
if interrupt:
speech.stop()
return -1
text = self.__addVerbalizedPunctuation(text)
if orca_state.activeScript and orca_state.usePronunciationDictionary:
text = orca_state.activeScript.adjustForPronunciation(text)
try:
# [[[TODO: WDW - back this stop out for now. The problem is
# that we end up clipping too much speech, especially in the
# case where we want to speak the contents of a popup before
# speaking the object with focus.]]]
#
#if interrupt:
# speaker.stop()
self.__lastText = [text, acss]
self.__isSpeaking = True
return speaker.say(text)
except:
# On failure, remember what we said, reset our connection to the
# speech synthesis driver, and try to say it again.
#
debug.printException(debug.LEVEL_SEVERE)
debug.println(debug.LEVEL_SEVERE, "Restarting speech...")
self.reset()
return -1
def processObjectEvent(self, event):
"""Processes all AT-SPI object events of interest to this
script. The interest in events is specified via the
'listeners' field that was defined during the construction of
this script.
Note that this script may be passed events it doesn't care
about, so it needs to react accordingly.
Arguments:
- event: the Event
"""
if not event.source:
msg = 'script.processObjectEvent: event.source went away'
debug.println(debug.LEVEL_FINE, msg)
return
try:
role = event.source.getRole()
except (LookupError, RuntimeError):
msg = 'script.processObjectEvent: Error getting role'
debug.println(debug.LEVEL_FINE, msg)
return
# Check to see if we really want to process this event.
#
processEvent = (orca_state.activeScript == self \
or self.presentIfInactive)
if role == pyatspi.ROLE_PROGRESS_BAR \
and not processEvent \
and settings.progressBarVerbosity == settings.PROGRESS_BAR_ALL:
processEvent = True
if not processEvent:
return
if self.skipObjectEvent(event):
return
# Clear the generator cache for each event.
#
self.generatorCache = {}
# This calls the first listener it finds whose key *begins with* or is
# the same as the event.type. The reason we do this is that the event
# type in the listeners dictionary may not be as specific as the event
# type we received (e.g., the listeners dictionary might contain the
# key "object:state-changed:" and the event.type might be
# "object:state-changed:focused". [[[TODO: WDW - the order of the
# keys is *not* deterministic, and is not guaranteed to be related
# to the order in which they were added. So...we need to do something
# different here. Logged as bugzilla bug 319781.]]]
#
for key in self.listeners.keys():
if event.type.startswith(key):
self.listeners[key](event)
def _change_default_speech_pitch(self, decrease=False):
acss = settings.voices[settings.DEFAULT_VOICE]
delta = settings.speechPitchDelta * (decrease and -1 or +1)
pitch = acss[ACSS.AVERAGE_PITCH]
acss[ACSS.AVERAGE_PITCH] = max(0, min(9, pitch + delta))
debug.println(debug.LEVEL_CONFIGURATION,
"Speech pitch is now %d" % pitch)
# Translators: This string announces speech pitch change.
self.speak(decrease and _("lower.") or _("higher."), acss=acss)
def _dbusCallbackError(funcName, error):
"""Log D-Bus errors
Arguments:
- funcName: The name of the gsmag function that made the D-Bus call.
- error: The error that D-Bus returned.
"""
logLine = funcName + " failed: " + str(error)
debug.println(debug.LEVEL_WARNING, logLine)
def _change_default_speech_rate(self, decrease=False):
acss = settings.voices[settings.DEFAULT_VOICE]
delta = settings.speechRateDelta * (decrease and -1 or +1)
rate = acss[ACSS.RATE]
acss[ACSS.RATE] = max(0, min(99, rate + delta))
debug.println(debug.LEVEL_CONFIGURATION,
"Speech rate is now %d" % rate)
# Translators: This string announces speech rate change.
self.speak(decrease and _("slower.") or _("faster."), acss=acss)
def increaseSpeechPitch(script=None, inputEvent=None):
if _speechserver:
_speechserver.increaseSpeechPitch()
else:
logLine = "SPEECH OUTPUT: 'higher'"
debug.println(debug.LEVEL_INFO, logLine)
log.info(logLine)
return True
def increaseSpeechRate(script=None, inputEvent=None):
if _speechserver:
_speechserver.increaseSpeechRate()
else:
debug.println(debug.LEVEL_INFO,
"SPEECH OUTPUT: 'faster'")
log.info("increaseSpeechRate")
return True
def decreaseSpeechRate(script=None, inputEvent=None):
if _speechserver:
_speechserver.decreaseSpeechRate()
else:
logLine = "SPEECH OUTPUT: 'slower'"
debug.println(debug.LEVEL_INFO, logLine)
log.info(logLine)
return True
def decreaseSpeechPitch(script=None, inputEvent=None):
if _speechserver:
_speechserver.decreaseSpeechPitch()
else:
debug.println(debug.LEVEL_INFO,
"SPEECH OUTPUT: 'lower'")
log.info("decreaseSpeechPitch")
return True
def on_connect(self):
self.send({
'pseudo':
self._controlers['adventure'].get_pseudo(),
'pos':
self._controlers['perso'].get_pos(),
'key':
self._connection_key,
'avatar':
os.path.basename(self._controlers['perso'].get_skin_path())
})
debug.println("[NETWORK] Connexion")
def setLocusOfFocus(event, obj, notifyPresentationManager=True):
"""Sets the locus of focus (i.e., the object with visual focus) and
notifies the current presentation manager of the change.
Arguments:
- event: if not None, the Event that caused this to happen
- obj: the Accessible with the new locus of focus.
- notifyPresentationManager: if True, propagate this event
"""
if obj == orca_state.locusOfFocus:
return
oldLocusOfFocus = orca_state.locusOfFocus
if oldLocusOfFocus and not oldLocusOfFocus.valid:
oldLocusOfFocus = None
orca_state.locusOfFocus = obj
if orca_state.locusOfFocus and not orca_state.locusOfFocus.valid:
orca_state.locusOfFocus = None
if orca_state.locusOfFocus:
appname = ""
if not orca_state.locusOfFocus.app:
appname = "None"
else:
appname = "'" + orca_state.locusOfFocus.app.name + "'"
debug.println(debug.LEVEL_FINE,
"LOCUS OF FOCUS: app=%s name='%s' role='%s'" \
% (appname,
orca_state.locusOfFocus.name,
orca_state.locusOfFocus.role))
if event:
debug.println(debug.LEVEL_FINE,
" event='%s'" % event.type)
else:
debug.println(debug.LEVEL_FINE, " event=None")
else:
if event:
debug.println(debug.LEVEL_FINE,
"LOCUS OF FOCUS: None event='%s'" % event.type)
else:
debug.println(debug.LEVEL_FINE, "LOCUS OF FOCUS: None event=None")
if notifyPresentationManager and _currentPresentationManager >= 0:
_PRESENTATION_MANAGERS[_currentPresentationManager].\
locusOfFocusChanged(event,
oldLocusOfFocus,
orca_state.locusOfFocus)
def _send_command(self, command, *args, **kwargs):
if hasattr(speechd, 'SSIPCommunicationError'):
try:
return command(*args, **kwargs)
except speechd.SSIPCommunicationError:
debug.println(
debug.LEVEL_CONFIGURATION,
"Speech Dispatcher connection lost. "
"Trying to reconnect.")
self.reset()
return command(*args, **kwargs)
else:
# It is not possible tho catch the error with older SD versions.
return command(*args, **kwargs)
def __init__(self, app):
"""Creates a script for the given application, if necessary.
This method should not be called by anyone except the
focus_tracking_presenter.
Arguments:
- app: the Python Accessible application to create a script for
"""
self.app = app
if app:
self.name = self.app.name
else:
self.name = "default"
self.name += " (module=" + self.__module__ + ")"
self.listeners = self.getListeners()
# By default, handle events for non-active applications.
#
self.presentIfInactive = True
self.inputEventHandlers = {}
self.pointOfReference = {}
self.setupInputEventHandlers()
self.keyBindings = self.getKeyBindings()
self.brailleBindings = self.getBrailleBindings()
self.app_pronunciation_dict = self.getPronunciations()
self.brailleGenerator = self.getBrailleGenerator()
self.speechGenerator = self.getSpeechGenerator()
self.whereAmI = self.getWhereAmI()
self.bookmarks = self.getBookmarks()
self.voices = settings.voices
self.flatReviewContextClass = flat_review.Context
self.findCommandRun = False
# Assists with dealing with CORBA COMM_FAILURES. A failure doesn't
# always mean an object disappeared - there just might be a network
# glitch. So, on COMM_FAILURES, we might retry a few times before
# giving up on an object. This might need to be overridden by the
# script. See bug #397787.
#
self.commFailureWaitTime = settings.commFailureWaitTime
self.commFailureAttemptLimit = settings.commFailureAttemptLimit
debug.println(debug.LEVEL_FINE, "NEW SCRIPT: %s" % self.name)
def do_POST(self):
contentLength = self.headers.getheader('content-length')
if contentLength:
contentLength = int(contentLength)
inputBody = self.rfile.read(contentLength)
debug.println(debug.LEVEL_FINEST,
"httpserver._HTTPRequestHandler received %s" \
% inputBody)
if inputBody.startswith("speak:"):
speech.speak(inputBody[6:])
self.send_response(200, 'OK')
elif inputBody == "stop":
speech.stop()
self.send_response(200, 'OK')
elif inputBody == "isSpeaking":
self.send_response(200, 'OK')
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write("%s" % speech.isSpeaking())
elif inputBody.startswith("log:"):
import logging
logFile = inputBody[4:]
for logger in ['braille', 'speech']:
log = logging.getLogger(logger)
formatter = logging.Formatter('%(name)s.%(message)s')
try:
loggingFileHandlers[logger].close()
log.removeHandler(loggingFileHandlers[logger])
except:
pass
if logFile and len(logFile):
loggingFileHandlers[logger] = logging.FileHandler(
'%s.%s' % (logFile, logger), 'w')
loggingFileHandlers[logger].setFormatter(formatter)
log.addHandler(loggingFileHandlers[logger])
log.setLevel(logging.INFO)
self.send_response(200, 'OK')
elif inputBody.startswith("debug:"):
split = inputBody.split(':')
debug.debugLevel = int(split[1])
if debug.debugFile:
debug.debugFile.close()
debug.debugFile = None
if (len(split) == 3) and (len(split[2])):
debug.debugFile = open('%s.debug' % split[2], 'w', 0)
self.send_response(200, 'OK')
else:
debug.println(debug.LEVEL_FINEST,
"httpserver._HTTPRequestHandler received no data")
def panToOffset(offset):
"""Automatically pan left or right to make sure the current offset is
showing."""
while offset < _viewport[0]:
debug.println(debug.LEVEL_FINEST,
"braille.panToOffset (left) %d" % offset)
if not panLeft():
break
while offset >= (_viewport[0] + _displaySize[0]):
debug.println(debug.LEVEL_FINEST,
"braille.panToOffset (right) %d" % offset)
if not panRight():
break
def __setROI(rect):
"""Sets the region of interest.
Arguments:
- rect: A GNOME.Magnifier.RectBounds object.
"""
global _roi
debug.println(debug.LEVEL_ALL, "mag.py:__setROI: (%d, %d), (%d, %d)" \
% (rect.x1, rect.y1, rect.x2, rect.y2))
_roi = rect
_zoomer.setROI(_roi)
_zoomer.markDirty(_roi) # [[[TODO: WDW - for some reason, this seems
def _isLockingKey(event_string):
"""Return an indication of whether this is a locking key.
Arguments:
- event: the event string
Returns True if this is a locking key.
"""
lockingKeys = ["Caps_Lock", "Num_Lock", "Scroll_Lock"]
reply = event_string in lockingKeys \
and not event_string in settings.orcaModifierKeys
debug.println(debug.LEVEL_FINEST,
"orca._echoLockingKey: returning: %s" % reply)
return reply
def _isActionKey(event_string):
"""Return an indication of whether this is an action key.
Arguments:
- event: the event string
Returns True if this is an action key.
"""
actionKeys = [
"Return", "Escape", "Tab", "BackSpace", "Delete", "Page_Up",
"Page_Down", "Home", "End"
]
reply = event_string in actionKeys
debug.println(debug.LEVEL_FINEST,
"orca._echoActionKey: returning: %s" % reply)
return reply
def sayAll(self, utteranceIterator, progressCallback):
"""Iterates through the given utteranceIterator, speaking
each utterance one at a time. Subclasses may postpone
getting a new element until the current element has been
spoken.
Arguments:
- utteranceIterator: iterator/generator whose next() function
returns a [SayAllContext, acss] tuple
- progressCallback: called as speech progress is made - has a
signature of (SayAllContext, type), where
type is one of PROGRESS, INTERRUPTED, or
COMPLETED.
"""
for [context, acss] in utteranceIterator:
debug.println(debug.LEVEL_INFO,
"SPEECH OUTPUT: '" + context.utterance + "'")
log.info("sayAll utterance='%s'" % context.utterance)
self.speak(context.utterance, acss)
def shutdownOnSignal(signum, frame):
global exitCount
debug.println(debug.LEVEL_ALL,
"Shutting down and exiting due to signal = %d" \
% signum)
debug.println(debug.LEVEL_ALL, "Current stack is:")
debug.printStack(debug.LEVEL_ALL)
# Well...we'll try to exit nicely, but if we keep getting called,
# something bad is happening, so just quit.
#
if exitCount:
abort(signum)
else:
exitCount += 1
# Try to do a graceful shutdown if we can.
#
if settings.timeoutCallback and (settings.timeoutTime > 0):
signal.signal(signal.SIGALRM, settings.timeoutCallback)
signal.alarm(settings.timeoutTime)
try:
if _initialized:
shutdown()
else:
# We always want to try to shutdown speech since the
# speech servers are very persistent about living.
#
speech.shutdown()
shutdown()
cleanExit = True
except:
cleanExit = False
if settings.timeoutCallback and (settings.timeoutTime > 0):
signal.alarm(0)
if not cleanExit:
abort(signum)
def _cleanupCache(self):
"""Looks for defunct accessible objects in the cache and removes them.
"""
objectsRemoved = 0
for obj in atspi.Accessible._cache.values():
try:
if obj.state.count(atspi.Accessibility.STATE_DEFUNCT):
atspi.Accessible.deleteAccessible(obj)
objectsRemoved += 1
else:
# Try to force a COMM_FAILURE
#
obj.toString()
except CORBA.COMM_FAILURE:
atspi.Accessible.deleteAccessible(obj)
objectsRemoved += 1
debug.println(debug.LEVEL_FINEST,
"_cleanupCache: %d objects removed." % objectsRemoved)
def sayAll(self, utteranceIterator, progressCallback):
"""Iterates through the given utteranceIterator, speaking
each utterance one at a time.
Arguments:
- utteranceIterator: iterator/generator whose next() function
returns a new string to be spoken
- progressCallback: called as progress is made
"""
try:
[context, acss] = utteranceIterator.next()
debug.println(debug.LEVEL_INFO,
"SPEECH OUTPUT: '" + context.utterance + "'")
log.info("sayAll utterance='%s'" % context.utterance)
self.__sayAll = _SayAll(utteranceIterator,
context,
self.__speak(context.utterance, acss),
progressCallback)
except StopIteration:
pass
def _isPrintableKey(event_string):
"""Return an indication of whether this is an alphanumeric or
punctuation key.
Arguments:
- event: the event string
Returns True if this is an alphanumeric or punctuation key.
"""
if event_string == "space":
reply = True
else:
unicodeString = event_string.decode("UTF-8")
reply = (len(unicodeString) == 1) \
and (unicodeString.isalnum() or unicodeString.isspace()
or unicodedata.category(unicodeString)[0] in ('P', 'S'))
debug.println(debug.LEVEL_FINEST,
"orca._echoPrintableKey: returning: %s" % reply)
return reply
def _isModifierKey(event_string):
"""Return an indication of whether this is a modifier key.
Arguments:
- event: the event string
Returns True if this is a modifier key
"""
# [[[TODO:richb - the Fn key on my laptop doesn't seem to generate an
# event.]]]
modifierKeys = [ 'Alt_L', 'Alt_R', 'Control_L', 'Control_R', \
'Shift_L', 'Shift_R', 'Meta_L', 'Meta_R' ]
modifierKeys.extend(settings.orcaModifierKeys)
reply = event_string in modifierKeys
debug.println(debug.LEVEL_FINEST,
"orca._echoModifierKey: returning: %s" % reply)
return reply
def generateMouseEvent(x, y, eventName):
"""Synthesize a mouse event at a specific screen coordinate.
Most AT clients should use the #AccessibleAction interface when
tempted to generate mouse events, rather than this method.
Event names: b1p = button 1 press; b2r = button 2 release;
b3c = button 3 click; b2d = button 2 double-click;
abs = absolute motion; rel = relative motion.
Arguments:
- x: the x screen coordinate
- y: the y screen coordinate
- eventName: the event name string (as described above)
"""
debug.println(debug.LEVEL_FINER,
"SYNTHESIZING MOUSE EVENT: (%d, %d) %s"\
% (x, y, eventName))
d = atspi.Registry().registry.getDeviceEventController()
d.generateMouseEvent(x, y, eventName)
def _isFunctionKey(event_string):
"""Return an indication of whether this is a function key.
Arguments:
- event: the event string
Returns True if this is a function key.
"""
# [[[TODO:richb - what should be done about the function keys on the left
# side of my Sun keyboard and the other keys (like Scroll Lock), which
# generate "Fn" key events?]]]
functionKeys = [
"F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11",
"F12"
]
reply = event_string in functionKeys
debug.println(debug.LEVEL_FINEST,
"orca._echoFunctionKey: returning: %s" % reply)
return reply
def getLongBrailleForRoleName(obj):
"""Returns the localized name of the given Accessible object; the name is
a long string suitable for a Braille display. If a localized name cannot
be discovered, this will return the string as defined by the at-spi.
Arguments:
- obj: an Accessible object
Returns a string containing the localized name of the object suitable for
a Braille display.
"""
name = obj.role
if rolenames.has_key(name):
return rolenames[name].brailleLong
else:
debug.println(debug.LEVEL_WARNING, "No rolename for %s" % name)
localizedRoleName = obj.localizedRoleName
if localizedRoleName and len(localizedRoleName):
return localizedRoleName
else:
return name
def processRoutingKey(self, offset):
"""Processes a cursor routing key press on this Component. The offset
is 0-based, where 0 represents the leftmost character of string
associated with this region. Note that the zeroeth character may have
been scrolled off the display."""
actions = self.accessible.action
if actions:
actions.doAction(0)
else:
# [[[WDW - HACK to do a mouse button 1 click if we have
# to. For example, page tabs don't have any actions but
# we want to be able to select them with the cursor
# routing key.]]]
#
debug.println(debug.LEVEL_FINEST,
"braille.Component.processRoutingKey: no action")
try:
eventsynthesizer.clickObject(self.accessible, 1)
except:
debug.printException(debug.LEVEL_SEVERE)
def prepare(self):
debug.println("[GAME] Démarrage")
self.__start_at__ = time.time()
# Variables ayant besoin d'être rechargées avant le lancement du jeu (en cas de lancement multiple du jeu)
self.continuer = 1
yield 1
self.renderer_manager.clear_all()
yield 1
self.renderer_manager.ban_renderer(RENDER_COMBAT, RENDER_INVENTAIRE,
RENDER_CREATURES, RENDER_POKEDEX,
RENDER_CARTE, RENDER_MENU_IN_GAME,
RENDER_BOUTIQUE, RENDER_SAVE,
RENDER_PC)
yield 1
self.personnage.set_carte_mgr(self.carte_mgr)
yield 1
self.mini_map.load()
yield 1
self.pc_mgr.add_equipe(self.equipe_mgr)
yield 1
self.equipe_mgr.add_pc(self.pc_mgr)
yield 1
self.musics_player.load()
yield 1
for i in self.load():
yield i
ree.init_joystick()
yield 1
if ree.count_joysticks() > 0:
joystick = ree.create_joystick()
joystick.init()
self.joystick = JoystickController(joystick)
debug.println("[GAME] Un joystick a été trouvé")
ree.set_key_repeat(200, 100)
yield 1
if self.joystick:
self.joystick.set_repeat(40)
self.musics_player.create_random_playlist()
yield 1
self.musics_player.select(self.musics_player.get_rdm_playlist().pop())
yield 1
if not os.path.exists(os.path.join("..", "saves")):
os.mkdir(os.path.join("..", "saves"))
debug.println("[GAME] Démarré en %3.4f sec" %
(time.time() - self.__start_at__))
def init():
global _speechserver
if _speechserver:
return
# First, find the factory module to use. We will
# allow the user to give their own factory module,
# thus we look first in the global name space, and
# then we look in the orca namespace.
#
moduleName = settings.speechServerFactory
if moduleName:
debug.println(debug.LEVEL_CONFIGURATION,
"Using speech server factory: %s" % moduleName)
else:
debug.println(debug.LEVEL_CONFIGURATION, "Speech not available.")
return
factory = None
try:
factory = __import__(moduleName, globals(), locals(), [''])
except:
try:
moduleName = moduleName.replace("orca.", "", 1)
factory = __import__(moduleName, globals(), locals(), [''])
except:
debug.printException(debug.LEVEL_SEVERE)
# Now, get the speech server we care about.
#
speechServerInfo = settings.speechServerInfo
if speechServerInfo:
_speechserver = factory.SpeechServer.getSpeechServer(speechServerInfo)
else:
_speechserver = factory.SpeechServer.getSpeechServer()
def getScriptModuleName(app):
"""Returns the module name of the script to use for a given
application. Any script mapping set via the setScriptMapping
method is searched first, with the ultimate fallback being the
name of the application itself.
Arguments:
- app: the application to find a script module name for
"""
if not app.name:
return None
for mapping in _scriptMappings:
regExpression = mapping[0]
moduleName = mapping[1]
if regExpression.match(app.name):
debug.println(
debug.LEVEL_FINEST,
"Script mapping for %s is %s" % (app.name, moduleName))
return moduleName
return app.name
def general_load(self):
for i in glob(os.path.join("..", "assets", "tiles", "*")):
# chargement automatique des tiles, leur nom déterminent si elles sont bloquantes ou non
# chargement d'une tile simple
if os.path.isfile(i):
self.images[os.path.split(i)[1][:-4]] = ree.load_image(i)
self.lassets.append(os.path.split(i)[1][:-4])
# chargement d'une animation
elif os.path.isdir(i):
self.images[i.split(
os.sep)[-1]] = BaseMultipleSpritesAnimator(i)
self.lassets.append(i.split(os.sep)[-1])
self._load_animators()
self._load_tiles_rects()
with open(os.path.join("..", "assets", "configuration", "tiles.umd"),
"r") as file:
self.specials_blocs = eval(file.read())
self.loaded = True
debug.println("[CARTE] Chargement global terminé")
def load(self):
if not path.exists(self.path):
self.create()
debug.println("[ULoader] Chargement terminé")
else:
debug.println("[ULoader] Note :", sep='', end=' ')
with open(self.path, 'rb') as rlast_job_done:
debug.println(pickle.Unpickler(rlast_job_done).load())
self.create()
def speakKeyEvent(self, event_string, type):
"""Speaks a key event immediately.
Arguments:
- event_string: string representing the key event as defined by
input_event.KeyboardEvent.
- type: key event type as one of orca.KeyEventType constants.
"""
if type == orca.KeyEventType.PRINTABLE and \
event_string.decode("UTF-8").isupper():
voice = settings.voices[settings.UPPERCASE_VOICE]
else:
voice = settings.voices[settings.DEFAULT_VOICE]
# Check to see if there are localized words to be spoken for
# this key event.
#
event_string = keynames.getKeyName(event_string)
if type == orca.KeyEventType.LOCKING_LOCKED:
# Translators: this represents the state of a locking modifier
# key (e.g., Caps Lock)
#
event_string += " " + _("on")
elif type == orca.KeyEventType.LOCKING_UNLOCKED:
# Translators: this represents the state of a locking modifier
# key (e.g., Caps Lock)
#
event_string += " " + _("off")
debug.println(debug.LEVEL_INFO,
"SPEECH OUTPUT: '" + event_string + "'")
log.info("speakKeyEvent utterance='%s'" % event_string)
self.speak(event_string, acss=voice)
def clic(self, xp: int, yp: int):
real_y = (yp - INVENT_Y_ITEM) // INVENT_ESP_ITEM
if INVENT_X_ITEM <= xp <= INVENT_MAX_X_ITEM and 0 <= real_y < len(self.objets[self.cur_categorie]):
self.selected_item = real_y
else:
if INVENT_BTN_JETER_Y <= yp <= INVENT_BTN_JETER_Y + INVENT_SIZE_BTN_Y and \
INVENT_BTN_JETER_X <= xp <= INVENT_BTN_JETER_X + INVENT_SIZE_BTN_X:
# DEMANDER CONFIRMATION AVANT !
debug.println("[INVENTAIRE] besoin de confirmation")
self.jeter(self.selected_item)
elif INVENT_BTN_JETERTT_Y <= yp <= INVENT_BTN_JETERTT_Y + INVENT_SIZE_BTN_Y and \
INVENT_BTN_JETERTT_X <= xp <= INVENT_BTN_JETERTT_X + INVENT_SIZE_BTN_X:
# DEMANDER CONFIRMATION AVANT !
debug.println("[INVENTAIRE] besoin de confirmation")
self.jeter_tout(self.selected_item)
elif INVENT_BTN_USE_Y <= yp <= INVENT_BTN_USE_Y + INVENT_SIZE_BTN_Y and \
INVENT_BTN_USE_X <= xp <= INVENT_BTN_USE_X + INVENT_SIZE_BTN_X:
self.utiliser(self.selected_item)
elif INVENT_BTN_PREVIOUS <= xp <= INVENT_BTN_PREVIOUS + INVENT_BTN_PAGES_SX and \
INVENT_BTN_PAGES <= yp <= INVENT_BTN_PAGES + INVENT_BTN_PAGES_SY:
self.previous()
elif INVENT_BTN_NEXT <= xp <= INVENT_BTN_NEXT + INVENT_BTN_PAGES_SX and \
INVENT_BTN_PAGES <= yp <= INVENT_BTN_PAGES + INVENT_BTN_PAGES_SY:
self.next()
def loadAppSettings(self, script):
"""Load the users application specific settings for an app.
Arguments:
- script: the current active script.
"""
app = script.app
settingsPackages = settings.settingsPackages
moduleName = settings.getScriptModuleName(app)
module = None
if moduleName and len(moduleName):
for package in settingsPackages:
if len(package):
name = package + "." + moduleName
else:
name = moduleName
try:
debug.println(debug.LEVEL_FINEST,
"Looking for settings at %s.py..." % name)
if not self._knownAppSettings.has_key(name):
self._knownAppSettings[name] = \
__import__(name, globals(), locals(), [''])
reload(self._knownAppSettings[name])
debug.println(debug.LEVEL_FINEST, "...found %s.py" % name)
# Setup the user's application specific key bindings.
# (if any).
#
if hasattr(self._knownAppSettings[name],
"overrideAppKeyBindings"):
script.overrideAppKeyBindings = \
self._knownAppSettings[name].overrideAppKeyBindings
script.keyBindings = \
self._knownAppSettings[name].overrideAppKeyBindings( \
script, script.keyBindings)
# Setup the user's application specific pronunciations
# (if any).
#
if hasattr(self._knownAppSettings[name],
"overridePronunciations"):
script.overridePronunciations = \
self._knownAppSettings[name].overridePronunciations
script.app_pronunciation_dict = \
self._knownAppSettings[name].overridePronunciations( \
script, script.app_pronunciation_dict)
break
except ImportError:
debug.println(debug.LEVEL_FINEST,
"...could not find %s.py" % name)
def __init__(self, id):
self._id = id
self._acss_manipulators = (
(ACSS.RATE, self._set_rate),
(ACSS.AVERAGE_PITCH, self._set_pitch),
(ACSS.GAIN, self._set_volume),
(ACSS.FAMILY, self._set_family),
)
if not _speechd_available:
debug.println(debug.LEVEL_WARNING,
"Speech Dispatcher interface not installed.")
return
if not _speechd_version_ok:
debug.println(
debug.LEVEL_WARNING,
"Speech Dispatcher version 0.6.2 or later is required.")
return
# The following constants must be initialized in runtime since they
# depend on the speechd module being available.
self._PUNCTUATION_MODE_MAP = {
settings.PUNCTUATION_STYLE_ALL: speechd.PunctuationMode.ALL,
settings.PUNCTUATION_STYLE_MOST: speechd.PunctuationMode.SOME,
settings.PUNCTUATION_STYLE_SOME: speechd.PunctuationMode.SOME,
settings.PUNCTUATION_STYLE_NONE: speechd.PunctuationMode.NONE,
}
self._CALLBACK_TYPE_MAP = {
speechd.CallbackType.BEGIN: speechserver.SayAllContext.PROGRESS,
speechd.CallbackType.CANCEL:
speechserver.SayAllContext.INTERRUPTED,
speechd.CallbackType.END: speechserver.SayAllContext.COMPLETED,
#speechd.CallbackType.INDEX_MARK:speechserver.SayAllContext.PROGRESS,
}
# Translators: This string will appear in the list of
# available voices for the current speech engine. %s will be
# replaced by the name of the current speech engine, such as
# "Festival default voice" or "IBMTTS default voice". It
# refers to the default voice configured for given speech
# engine within the speech subsystem. Apart from this item,
# the list will contain the names of all available "real"
# voices provided by the speech engine.
#
self._default_voice_name = _("%s default voice") % id
try:
self._init()
except Exception, e:
debug.println(
debug.LEVEL_WARNING,
"Speech Dispatcher service failed to connect: %s" % e)
def _debug(self, msg):
""" Convenience method for printing debug messages
"""
debug.println(self.debugLevel, "J2SE-access-bridge.py: " + msg)
def set_color(self, color: str):
try:
self.image = ree.load_image(os.path.join("..", "assets", "gui", "bulle_{}.png".format(color)))
except OSError:
debug.println("[GUI] La couleur demandée n'est pas trouvable pour la gui bulle ('{}')".format(color))
