def showGUI(self): """Show the splash screen dialog.""" imageFile = os.path.join(orca_platform.prefix, orca_platform.datadirname, orca_platform.package, "gfx", "orca-splash.png") image = Gtk.Image() image.set_from_file(imageFile) self.add(image) try: self.realize() except: debug.printException(debug.LEVEL_FINEST) self.set_transient_for(None) self.grab_focus() self.show_all() GObject.timeout_add(3000, self.hideGUI) while Gtk.events_pending(): Gtk.main_iteration() return self
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 queueText(self, text="", acss=None): """Adds the text to the queue. Arguments: - text: text 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. Output is produced by the next call to speak. """ if not settings.enableSpeech: return # A command to send to the speech server queueing text cmd = "q { %s }\n" if acss: try: code = self.getvoice(acss) cmd = "q {%s %%s %s}\n" % (code[0], code[1]) except: debug.printException(debug.LEVEL_WARNING) # Split text into chunks and each chunk queue separately for chunk in (t.group() for t in self._speechChunk.finditer(text)): self._output.write(cmd % self._quoteSpecialChars(chunk))
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 getSpeechServers(): """Gets available speech servers as a list. The caller is responsible for calling the shutdown() method of each speech server returned. """ haveNewServers = False try: serversConf = file(os.path.join(SpeechServer.location, '.servers')) except: return SpeechServer.__activeServers.values() for name in serversConf: name = name.strip() if name == '' or name[0] == '#': continue if name not in SpeechServer.__activeServers: try: SpeechServer.__activeServers[name] = SpeechServer(name) haveNewServers = True except: debug.printException(debug.LEVEL_WARNING) serversConf.close() # Check whether some servers have died and remove those from the list if haveNewServers: from time import sleep sleep(1) for server in SpeechServer.__activeServers.values(): if not server.process or server.process.poll() is not None: server.shutdown() return SpeechServer.__activeServers.values()
def reclaimScripts(self): """Compares the list of known scripts to the list of known apps, deleting any scripts as necessary. """ from pyatspi import Registry try: desktop = Registry.getDesktop(0) except: debug.printException(debug.LEVEL_FINEST) return appList = self.appScripts.keys() appList = filter(lambda a: a!= None and a not in desktop, appList) for app in appList: appScript = self.appScripts.pop(app) _eventManager.deregisterScriptListeners(appScript) del appScript try: toolkitScripts = self.toolkitScripts.pop(app) except KeyError: pass else: for toolkitScript in toolkitScripts.values(): _eventManager.deregisterScriptListeners(toolkitScript) del toolkitScript del app
def processInputEvent(self, script, inputEvent): """Processes an input event. If settings.learnModeEnabled is True, this will merely report the description of the input event to braille and speech. If settings.learnModeEnabled is False, this will call the function bound to this InputEventHandler instance, passing the inputEvent as the sole argument to the function. This function is expected to return True if it consumes the event; otherwise it is expected to return False. Arguments: - script: the script (if any) associated with this event - inputEvent: the input event to pass to the function bound to this InputEventHandler instance. """ consumed = False if settings.learnModeEnabled and self._learnModeEnabled: if self._description: # These imports are here to eliminate circular imports. # import braille import speech braille.displayMessage(self._description) speech.speak(self._description) consumed = True else: try: consumed = self._function(script, inputEvent) except: debug.printException(debug.LEVEL_SEVERE) return consumed
def _markModified(self): """ Mark as modified the user application specific custom key bindings: """ global appScript try: appScript.setupInputEventHandlers() keyBinds = keybindings.KeyBindings() keyBinds = appScript.overrideAppKeyBindings(appScript, keyBinds) keyBind = keybindings.KeyBinding(None, None, None, None) treeModel = self.keyBindingsModel myiter = treeModel.get_iter_first() while myiter != None: iterChild = treeModel.iter_children(myiter) while iterChild != None: descrip = treeModel.get_value(iterChild, orca_gui_prefs.DESCRIP) keyBind.handler = input_event.InputEventHandler( None, descrip) if keyBinds.hasKeyBinding(keyBind, typeOfSearch="description"): treeModel.set_value(iterChild, orca_gui_prefs.MODIF, True) iterChild = treeModel.iter_next(iterChild) myiter = treeModel.iter_next(myiter) except: debug.printException(debug.LEVEL_SEVERE)
def _processBrailleEvent(command): """Called whenever a key is pressed on the Braille display. Arguments: - command: the BrlAPI command for the key that was pressed. Returns True if the event was consumed; otherwise False """ # [[[TODO: WDW - probably should add braille bindings to this module.]]] consumed = False # Braille key presses always interrupt speech. # speech.stop() event = BrailleEvent(command) orca_state.lastInputEvent = event try: consumed = _PRESENTATION_MANAGERS[_currentPresentationManager].\ processBrailleEvent(event) except: debug.printException(debug.LEVEL_SEVERE) if (not consumed) and settings.learnModeEnabled: consumed = True return consumed
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 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 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 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 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 _markModified(self): """ Mark as modified the user application specific custom key bindings: """ global appScript try: appScript.setupInputEventHandlers() keyBinds = keybindings.KeyBindings() keyBinds = appScript.overrideAppKeyBindings(appScript, keyBinds) keyBind = keybindings.KeyBinding(None, None, None, None) treeModel = self.keyBindingsModel myiter = treeModel.get_iter_first() while myiter != None: iterChild = treeModel.iter_children(myiter) while iterChild != None: descrip = treeModel.get_value(iterChild, orca_gui_prefs.DESCRIP) keyBind.handler = input_event.InputEventHandler(None, descrip) if keyBinds.hasKeyBinding(keyBind, typeOfSearch="description"): treeModel.set_value(iterChild, orca_gui_prefs.MODIF, True) iterChild = treeModel.iter_next(iterChild) myiter = treeModel.iter_next(myiter) except: debug.printException(debug.LEVEL_SEVERE)
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 shutdown(): """Shuts down the magnifier module. Returns True if the shutdown procedure was run or False if this module has not been initialized. """ global _initialized global _magnifier if not _magnifierAvailable: return False if not _initialized: return False atspi.Registry().deregisterEventListener(__onMouseEvent, "mouse:abs") # Someone might have killed the magnifier on us. They shouldn't # have done so, but we need to be able to recover if they did. # See http://bugzilla.gnome.org/show_bug.cgi?id=375396. # try: _magnifier.clearAllZoomRegions() _magnifier.dispose() except: debug.printException(debug.LEVEL_WARNING) _magnifier = None _initialized = False return True
def processInputEvent(self, script, inputEvent): """Processes an input event. If settings.learnModeEnabled is True, this will merely report the description of the input event to braille and speech. If settings.learnModeEnabled is False, this will call the function bound to this InputEventHandler instance, passing the inputEvent as the sole argument to the function. This function is expected to return True if it consumes the event; otherwise it is expected to return False. Arguments: - script: the script (if any) associated with this event - inputEvent: the input event to pass to the function bound to this InputEventHandler instance. """ consumed = False if settings.learnModeEnabled and self._learnModeEnabled: if self.description: script.presentMessage(self.description) consumed = True else: try: consumed = self.function(script, inputEvent) except: debug.printException(debug.LEVEL_SEVERE) return consumed
def shutdown(): """Shuts down the magnifier module. Returns True if the shutdown procedure was run or False if this module has not been initialized. """ global _initialized global _magnifier if not _magnifierAvailable: return False if not _initialized: return False atspi.Registry().deregisterEventListener(__onMouseEvent,"mouse:abs") # Someone might have killed the magnifier on us. They shouldn't # have done so, but we need to be able to recover if they did. # See http://bugzilla.gnome.org/show_bug.cgi?id=375396. # try: _magnifier.clearAllZoomRegions() _magnifier.dispose() except: debug.printException(debug.LEVEL_WARNING) _magnifier = None _initialized = False return True
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 __init__(self, serverId): super(SpeechServer, self).__init__() self._id = serverId self._client = None self._current_voice_properties = {} 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. # try: serverId = serverId.encode("UTF-8") except UnicodeDecodeError: pass self._default_voice_name = _("%s default voice") % serverId try: self._init() except: debug.println(debug.LEVEL_WARNING, "Speech Dispatcher service failed to connect:") debug.printException(debug.LEVEL_WARNING) else: SpeechServer._active_servers[serverId] = self
def getSpeechServer(info=['outloud','outloud']): """Gets a given SpeechServer based upon the info. See SpeechServer.getInfo() for more info. """ if SpeechServer.__activeServers.has_key(info[0]): return SpeechServer.__activeServers[info[0]] else: try: return SpeechServer(info[0]) except: debug.printException(debug.LEVEL_SEVERE) return None
def _processBrailleEvent(self, brailleEvent): """Called whenever a cursor key is pressed on the Braille display. Arguments: - brailleEvent: an instance of input_event.BrailleEvent """ if orca_state.activeScript: try: orca_state.activeScript.processBrailleEvent(brailleEvent) except: debug.printException(debug.LEVEL_WARNING) debug.printStack(debug.LEVEL_WARNING)
def _showFindGUI(script=None, inputEvent=None): """Displays the user interace to perform an Orca Find. Returns True to indicate the input event has been consumed. """ try: module = __import__(settings.findModule, globals(), locals(), ['']) module.showFindUI() except: debug.printException(debug.LEVEL_SEVERE) pass
def getSpeechServer(info=['outloud', 'outloud']): """Gets a given SpeechServer based upon the info. See SpeechServer.getInfo() for more info. """ if SpeechServer.__activeServers.has_key(info[0]): return SpeechServer.__activeServers[info[0]] else: try: return SpeechServer(info[0]) except: debug.printException(debug.LEVEL_SEVERE) return None
def _processKeyboardEvent(self, keyboardEvent): """Processes the given keyboard event based on the keybinding from the currently active script. Arguments: - keyboardEvent: an instance of input_event.KeyboardEvent """ if orca_state.activeScript: try: orca_state.activeScript.processKeyboardEvent(keyboardEvent) except: debug.printException(debug.LEVEL_WARNING) debug.printStack(debug.LEVEL_WARNING)
def _processBrailleEvent(command): """Handles BrlTTY command events. This passes commands on to Orca for processing. If Orca does not handle them (as indicated by a return value of false from the callback passed to init, it will attempt to handle the command itself - either by panning the viewport or passing cursor routing keys to the Regions for handling. Arguments: - command: the BrlAPI command for the key that was pressed. """ _printBrailleEvent(debug.LEVEL_FINE, command) # [[[TODO: WDW - DaveM suspects the Alva driver is sending us a # repeat flag. So...let's kill a couple birds here until BrlTTY # 3.8 fixes the problem: we'll disable autorepeat and we'll also # strip out the autorepeat flag if this is the first press of a # button.]]] # if command & BRL_FLG_REPEAT_INITIAL: command &= ~(BRL_FLG_REPEAT_INITIAL | BRL_FLG_REPEAT_DELAY) elif command & BRL_FLG_REPEAT_DELAY: return True consumed = False if settings.timeoutCallback and (settings.timeoutTime > 0): signal.signal(signal.SIGALRM, settings.timeoutCallback) signal.alarm(settings.timeoutTime) if _callback: try: # Like key event handlers, a return value of True means # the command was consumed. # consumed = _callback(command) except: debug.printException(debug.LEVEL_WARNING) consumed = False if (command >= 0x100) and (command < (0x100 + _displaySize[0])): if len(_lines) > 0: cursor = (command - 0x100) + _viewport[0] lineNum = _viewport[1] _lines[lineNum].processRoutingKey(cursor) consumed = True if settings.timeoutCallback and (settings.timeoutTime > 0): signal.alarm(0) return consumed
def init(): """Creates an HTTP server that listens for speak commands from a separate port defined by settings.httpServerPort. We run this as a daemon so it will die automatically when orca dies.""" global _httpRequestThread if settings.httpServerPort and (not _httpRequestThread): try: _httpRequestThread = _HTTPRequestThread() _httpRequestThread.setDaemon(True) _httpRequestThread.start() except: debug.printException(debug.LEVEL_WARNING)
def getSpeechServer(info=None): """Gets a given SpeechServer based upon the info. See SpeechServer.getInfo() for more info. """ if info and SpeechServer.__activeServers.has_key(info[1]): return SpeechServer.__activeServers[info[1]] server = None gservers = bonobo.activation.query( "repo_ids.has('IDL:GNOME/Speech/SynthesisDriver:0.3')") if len(gservers) == 0: return None gserver = None # All this logic is to attempt to fall back to a working # driver if the desired one cannot be found or is not # not working. # if not info: gserver = gservers[0] else: for s in gservers: if s.iid == info[1]: gserver = s break if not gserver: return None server = None try: server = SpeechServer.__createServer(gserver.iid) except: debug.printException(debug.LEVEL_WARNING) if not server: for s in gservers: try: server = SpeechServer.__createServer(s.iid) if server: break except: debug.printException(debug.LEVEL_WARNING) return server
def _getScriptForEvent(event): """Returns the script associated with event.""" if event.type.startswith("mouse:"): return orca_state.activeScript script = None try: app = event.host_application or event.source.getApplication() except: debug.printException(debug.LEVEL_WARNING) else: script = _scriptManager.getScript(app, event.source) return script
def getVoiceFamilies(self): """Returns a list of speechserver.VoiceFamily instances representing all the voice families known by the speech server. """ families = [] try: for voice in self.getvoicelist(): props = {speechserver.VoiceFamily.NAME: voice} families.append(speechserver.VoiceFamily(props)) except: debug.printException(debug.LEVEL_SEVERE) pass return families
def _verifyFormatting(self): # Verify the formatting strings are OK. This is only # for verification and does not effect the function of # Orca at all. # Populate the entire globals with empty arrays # for the results of all the legal method names. # globalsDict = {} for key in self._methodsDict.keys(): globalsDict[key] = [] self._addGlobals(globalsDict) for roleKey in self._script.formatting[self._mode]: for key in ["focused", "unfocused"]: try: evalString = \ self._script.formatting[self._mode][roleKey][key] except: continue else: if not evalString: # It's legal to have an empty string. # continue while True: try: eval(evalString, globalsDict) break except NameError: info = _formatExceptionInfo() arg = info[1][0] arg = arg.replace("name '", "") arg = arg.replace("' is not defined", "") if not self._methodsDict.has_key(arg): debug.printException(debug.LEVEL_SEVERE) debug.println( debug.LEVEL_SEVERE, "Unable to find function for '%s'\n" % arg) globalsDict[arg] = [] except: debug.printException(debug.LEVEL_SEVERE) debug.println( debug.LEVEL_SEVERE, "While processing '%s' '%s' '%s' '%s'" \ % (roleKey, key, evalString, globalsDict)) break
def _showPreferencesConsole(script=None, inputEvent=None): """Displays the user interace to configure Orca and set up user preferences via a command line interface. Returns True to indicate the input event has been consumed. """ try: module = __import__(settings.consolePreferencesModule, globals(), locals(), ['']) module.showPreferencesUI() except: debug.printException(debug.LEVEL_SEVERE) pass return True
def getVoiceFamilies(self): """Returns a list of speechserver.VoiceFamily instances representing all the voice families known by the speech server. """ families = [] try: for voice in self.getvoicelist(): props = { speechserver.VoiceFamily.NAME : voice } families.append(speechserver.VoiceFamily(props)) except: debug.printException(debug.LEVEL_SEVERE) return families
def consumeKeyboardEvent(self, script, keyboardEvent): """Attempts to consume the given keyboard event. If these keybindings have a handler for the given keyboardEvent, it is assumed the event will always be consumed. """ consumed = False handler = self.getInputHandler(keyboardEvent) if handler: consumed = True if keyboardEvent.type == atspi.Accessibility.KEY_PRESSED_EVENT: try: handler.processInputEvent(script, keyboardEvent) except: debug.printException(debug.LEVEL_SEVERE) return consumed
def _showAppPreferencesGUI(script=None, inputEvent=None): """Displays the user interace to configure the settings for a specific applications within Orca and set up those app-specific user preferences using a GUI. Returns True to indicate the input event has been consumed. """ try: module = __import__(settings.appGuiPreferencesModule, globals(), locals(), ['']) module.showPreferencesUI() except: debug.printException(debug.LEVEL_SEVERE) pass return True
def getSpeechServerFactories(): """Imports all known SpeechServer factory modules. Returns a list of modules that implement the getSpeechServers method, which returns a list of speechserver.SpeechServer instances. """ factories = [] moduleNames = settings.speechFactoryModules for moduleName in moduleNames: try: module = __import__(moduleName, globals(), locals(), ['']) factories.append(module) except: debug.printException(debug.LEVEL_OFF) return factories
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 _showMainWindowGUI(script=None, inputEvent=None): """Displays the Orca main window. Returns True to indicate the input event has been consumed. """ try: module = __import__(settings.mainWindowModule, globals(), locals(), ['']) if settings.showMainWindow: module.showMainUI() else: module.hideMainUI() except: debug.printException(debug.LEVEL_SEVERE) pass return True
def _writeAppKeyBindingsMap(self, prefs, appName, appScript, treeModel): """Write to an application specific configuration file 'prefs', the key bindings passed in the model treeModel. Arguments: - prefs: file handle for application preferences. - appName: the application these preferences are for. - appScript: the application script. - treeModel: key bindings treemodel. """ self._writeKeyBindingsPreamble(prefs) try: self._iterateKeyBindings(prefs, treeModel) except: debug.println(debug.LEVEL_FINEST, "FAILURE: _iterateKeyBindings") debug.printException(debug.LEVEL_FINEST) self._writeAppKeyBindingsPostamble(prefs, appName, appScript)
def _showGUI(self): """Show the Orca quit GUI dialog. This assumes that the GUI has already been created. """ # Set the current time on the quit GUI dialog so that it'll # get focus. set_user_time is a new call in pygtk 2.9.2 or later. # It's surronded by a try/except block here so that if it's not found, # then we can fail gracefully. # try: self.quitDialog.realize() self.quitDialog.window.set_user_time(\ orca_state.lastInputEventTimestamp) except AttributeError: debug.printException(debug.LEVEL_FINEST) self.quitDialog.show()
def quitOrca(script=None, inputEvent=None): """Quit Orca. Check if the user wants to confirm this action. If so, show the confirmation GUI otherwise just shutdown. Returns True to indicate the input event has been consumed. """ if settings.quitOrcaNoConfirmation: shutdown() else: try: module = __import__(settings.quitModule, globals(), locals(), ['']) module.showQuitUI() except: debug.printException(debug.LEVEL_SEVERE) pass return True
def test(): import speechserver factories = getSpeechServerFactories() for factory in factories: print factory.__name__ servers = factory.SpeechServer.getSpeechServers() for server in servers: try: print " ", server.getInfo() for family in server.getVoiceFamilies(): name = family[speechserver.VoiceFamily.NAME] print " ", name acss = ACSS({ACSS.FAMILY: family}) server.speak(name, acss) server.speak("testing") server.shutdown() except: debug.printException(debug.LEVEL_OFF) pass
def getSpeechServers(): """Gets available speech servers as a list. The caller is responsible for calling the shutdown() method of each speech server returned. """ # Get a list of all the drivers on the system and find out how many # of them work. # knownServers = bonobo.activation.query( "repo_ids.has('IDL:GNOME/Speech/SynthesisDriver:0.3')") for server in knownServers: if not SpeechServer.__activeServers.has_key(server.iid): try: SpeechServer.__createServer(server.iid) except: debug.printException(debug.LEVEL_WARNING) return SpeechServer.__activeServers.values()
def _showGUI(self): """Show the Orca Find dialog. This assumes that the GUI has already been created. """ # Set the current time on the Find GUI dialog so that it'll # get focus. set_user_time is a new call in pygtk 2.9.2 or later. # It's surronded by a try/except block here so that if it's not found, # then we can fail gracefully. # try: self.findDialog.realize() self.findDialog.window.set_user_time(\ orca_state.lastInputEventTimestamp) except AttributeError: debug.printException(debug.LEVEL_FINEST) self.findDialog.show() # Populate the dialog box from the previous searchQuery, should # one exist. Note: This is necessary because we are destroying # the dialog (rather than merely hiding it) before performing the # search. try: self.searchForEntry.set_text(\ orca_state.searchQuery.searchString) self.searchForEntry.select_region( 0, len(self.searchForEntry.get_text())) if orca_state.searchQuery.startAtTop: self.topRadioButton.set_active(True) self.matchCaseCheckbox.set_active(\ orca_state.searchQuery.caseSensitive) self.matchEntireWordCheckbox.set_active(\ orca_state.searchQuery.matchEntireWord) self.wrapAroundCheckbox.set_active(\ orca_state.searchQuery.windowWrap) self.searchBackwardsCheckbox.set_active(\ orca_state.searchQuery.searchBackwards) except: pass
def _reclaimScripts(self): """Compares the list of known scripts to the list of known apps, deleting any scripts as necessary. """ # Sometimes the desktop can become unavailable. This happens # often when synaptic is used to load new modules (see the bug # report http://bugzilla.gnome.org/show_bug.cgi?id=342022). # So...if this happens, we'll just move along. The next # successful call to _reclaimScripts will reclaim anything we # didn't reclaim this time. # try: apps = [] desktop = self.registry.desktop for i in range(0, desktop.childCount): try: acc = desktop.getChildAtIndex(i) app = atspi.Accessible.makeAccessible(acc) if app: apps.insert(0, app) except: pass for app in self._knownScripts.keys(): if apps.count(app) == 0: script = self._knownScripts[app] self._deregisterEventListeners(script) # Provide a bunch of hints to the garbage collector # that we just don't care about this stuff any longer. # Note the "app.app = None" - that helps remove a # cycle of the application referring to itself. # del self._knownScripts[app] app.app = None del app del script except: debug.printException(debug.LEVEL_FINEST)
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)