def autonomous(self):
        speech.speak("I am Humphrey!")

        while self.autonomous_thread_running:
            if self.autonomous_thread_pause:
                time.sleep(.1)
                self.time_of_last_stuck = time.time()
                continue

            self.start_forward()

            if config.SERVO_ON:
                servo = self.next_step()
                self.set_servo(servo)

            self.current_distance = self.get_top_distance()

            if self.object_detected(self.current_distance, servo):
                self.stop_forward()
                self.backward(config.BACKWARD_TIME)
                self.auto_turn(servo)

            elif self.is_robot_stuck():
                self.stop_forward()
                self.get_unstuck()

            speech.say_something()

 def possibilities(self, event):
     l = self._board.possibilities(self._x, self._y)
     if l:
         message = " ".join(map(str, l))
         speech.speak(message)
     else:
         speech.speak(_("Nothing"))

def sayAndPrint(text,
                stop=False,
                getInput=False,
                speechServer=None,
                voice=None):
    """Prints the given text.  In addition, if the text field
    is not None, speaks the given text, optionally interrupting
    anything currently being spoken.

    Arguments:
    - text: the text to print and speak
    - stop: if True, interrupt any speech currently being spoken
    - getInput: if True, elicits raw input from the user and returns it
    - speechServer: the speech server to use
    - voice: the ACSS to use for speaking

    Returns raw input from the user if getInput is True.
    """

    if stop:
        speech.stop()
        if speechServer:
            speechServer.stop()

    if speechServer:
        speechServer.speak(text, voice)
    else:
        speech.speak(text, voice)

    if getInput:
        return raw_input(text)
    else:
        print text

    def utterMessage(self, chatRoomName, message, focused=True):
        """ Speak/braille a chat room message.

        Arguments:
        - chatRoomName: name of the chat room this message came from
        - message: the chat room message
        - focused: whether or not the current chatroom has focus. Defaults
          to True so that we can use this method to present chat history
          as well as incoming messages.
        """

        # Only speak/braille the new message if it matches how the user
        # wants chat messages spoken.
        #
        verbosity = self._script.getSettings().chatMessageVerbosity
        if orca_state.activeScript.name != self._script.name and verbosity == settings.CHAT_SPEAK_ALL_IF_FOCUSED:
            return
        elif not focused and verbosity == settings.CHAT_SPEAK_FOCUSED_CHANNEL:
            return

        text = ""
        if _settingsManager.getSetting("chatSpeakRoomName") and chatRoomName:
            text = _("Message from chat room %s") % chatRoomName
        text = self._script.utilities.appendString(text, message)

        if len(text.strip()):
            speech.speak(text)
        self._script.displayBrailleMessage(text)

    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 process_name_change(new_name):
    if new_name:
        settings.set_username(new_name)
        speech.speak('Pleased to meet you, ' + settings.username + '!', True)
        return True
    else:
        return False

def removeFile(file):
	"""remove a file"""
	if "y" in speech.question("Are you sure you want to remove " + file + "? (Y/N): "):
		speech.speak("Removing " + file + " with the 'rm' command.")
		subprocess.call(["rm", "-r", file])
	else:
		speech.speak("Okay, I won't remove " + file + ".")

	def script_navigate(self, gesture):
		modNames = gesture.modifierNames
		try:
			text = self.provider._mpNavigation.DoNavigateKeyPress(gesture.vkCode,
				"shift" in modNames, "control" in modNames, "alt" in modNames, False)
		except COMError:
			return
		speech.speak(_processMpSpeech(text, self.provider._language))

def speakInstalledPackages(package, package_manager, installed, similar=[], speakSimilar=True):
    if installed:
        speech.speak("The package '" + package + "' is installed with the '" + package_manager + "' package manager.\n")
    elif speakSimilar:
        speech.speak("The package '" + package + "' is not installed with the '" + package_manager + "' package manager." +
                     ("" if similar else "\n"))
        if similar:
            speakSimilarPackages(similar)

def process_send_email(recipient_info, verbose):
    '''Take appropriate action with the given email recipient information.'''
    if recipient_info and recipient_info.find("@") != -1:
        recipient = 'mailto:' + recipient_info  # Open default email client
    else:
        recipient = 'https://mail.google.com/mail/u/0/#compose' # Gmail
    speech.speak('Composing an email...', verbose)
    webbrowser.open(recipient)

def copy(location):
	"""copy file or directory at a given location; can be pasted later"""
	copyData = settings.getDataFile()
	copyFileLocation = os.path.abspath(location)
	copy = {"copyLocation": copyFileLocation}
	dataFile = open(copyData, "wb")
	pickle.dump(copy, dataFile)
	speech.speak(location + " copied successfully!")
	speech.speak("Tip: use 'hallie paste' to paste this file.")

 def put(self, event):
     value = event.key - K_0
     ret = self._board.put(self._x, self._y, value)
     if ret:
         self._move_sound.play()
         self.speak_current()
         if self._board.is_solution():
             self._win_sound.play()
             speech.speak(_("Solution found"))
     else:
         speech.speak(_("Impossible move"))

def process_add_cal_event(event_str, verbose):
    '''Schedule a new calendar event with the user.'''
    if event_str == 'event':
        event_sentence = speech.ask_question('Okay, what is the event called?', verbose)
        day_sentence = speech.ask_question('What day will this be on?', verbose)
        time_sentence = speech.ask_question('What time will this start at?', verbose)
        cal_event = calendardb.CalendarEvent(event_sentence, day_sentence, time_sentence, '')
        calendardb.add_event(cal_event)
        feedback_sentence = 'Alright, I\'m putting down ' + str(cal_event) + '.'
        speech.speak(feedback_sentence, verbose)
    else:
        speech.speak('Sorry, I am unable to help you schedule this right now.', verbose)

 def saveBookmarks(self, inputEvent):
     """ Save the bookmarks for this script. """        
     try:
         self._saveBookmarksToDisk(self._bookmarks)
         # Translators: this announces that a bookmark has been saved to 
         # disk
         #
         speech.speak(_('bookmarks saved'))
     except IOError:
         # Translators: this announces that a bookmark could not be saved to 
         # disk
         #
         speech.speak(_('bookmarks could not be saved'))

 def help(self, event):
     help_string = _(
         """
     To move around the board use the arrow keys.
     To put a number on a square use numbers from 1 to 9.
     To clear a square use the 0 key. A square can only be cleared if it was blank on the original puzzle.
     To speak the current square position on the board use the p key.
     To know how many squares are still blank press b.
     To speak what possibilities exist for the current square press s.
     To quit the game press the q key.
     """
     )
     speech.speak(help_string)

def shutdown(script=None, inputEvent=None):
    """Exits Orca.  Unregisters any event listeners and cleans up.  Also
    quits the bonobo main loop and resets the initialized state to False.

    Returns True if the shutdown procedure ran or False if this module
    was never initialized.
    """

    global _initialized

    if not _initialized:
        return False

    # Try to say goodbye, but be defensive if something has hung.
    #
    if settings.timeoutCallback and (settings.timeoutTime > 0):
        signal.signal(signal.SIGALRM, settings.timeoutCallback)
        signal.alarm(settings.timeoutTime)

    # Translators: this is what Orca speaks and brailles when it quits.
    #
    speech.speak(_("Goodbye."))
    braille.displayMessage(_("Goodbye."))

    # Deregister our event listeners
    #
    registry = atspi.Registry()
    registry.deregisterEventListener(_onChildrenChanged,
                                     "object:children-changed:")
    registry.deregisterEventListener(_onMouseButton,
                                     "mouse:button")

    if _currentPresentationManager >= 0:
        _PRESENTATION_MANAGERS[_currentPresentationManager].deactivate()

    # Shutdown all the other support.
    #
    if settings.enableSpeech:
        speech.shutdown()
    if settings.enableBraille:
        braille.shutdown();
    if settings.enableMagnifier:
        mag.shutdown();

    registry.stop()

    if settings.timeoutCallback and (settings.timeoutTime > 0):
        signal.alarm(0)

    _initialized = False
    return True

def showPreferencesUI():
    global applicationName, appScript

    # There must be an application with focus for this to work.
    #
    if not orca_state.locusOfFocus or not orca_state.locusOfFocus.getApplication():
        message = _("No application has focus.")
        braille.displayMessage(message)
        speech.speak(message)
        return

    appScript = orca_state.activeScript

    # The name of the application that currently has focus.
    #
    applicationName = orca_state.activeScript.app.name
    if not orca_state.appOS and not orca_state.orcaOS:
        # Translators: Orca Preferences in this case, is a configuration GUI
        # for allowing users to set application specific settings from within
        # Orca for the application that currently has focus.
        #
        line = _("Starting Orca Preferences for %s.") % applicationName
        appScript.presentMessage(line)

        prefsDict = orca_prefs.readPreferences()
        orca_state.prefsUIFile = os.path.join(
            orca_platform.prefix, orca_platform.datadirname, orca_platform.package, "ui", "orca-setup.ui"
        )

        orca_state.appOS = OrcaSetupGUI(orca_state.prefsUIFile, "orcaSetupWindow", prefsDict)
        orca_state.appOS.initAppGUIState(appScript)

        orca_state.appOS.init()
    else:
        if not orca_state.orcaWD:
            orca_state.orcaWarningDialogUIFile = os.path.join(
                orca_platform.prefix,
                orca_platform.datadirname,
                orca_platform.package,
                "ui",
                "orca-preferences-warning.ui",
            )
            orca_state.orcaWD = WarningDialogGUI(orca_state.orcaWarningDialogUIFile, "orcaPrefsWarningDialog")
            warningDialog = orca_state.orcaWD.getPrefsWarningDialog()
            warningDialog.realize()
            warningDialog.show()
        return

    orca_state.appOS.showGUI()

 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 addBookmark(self, inputEvent):
     """ Add an in-page accessible object bookmark for this key. """
     context = self._script.getFlatReviewContext()
     self._bookmarks[inputEvent.hw_code] = self._contextToBookmark(context)
     
     # Translators: this announces that a bookmark has been entered.  
     # Orca allows users to tell it to remember a particular spot in an 
     # application window and provides keystrokes for the user to jump to 
     # those spots.  These spots are known as 'bookmarks'. 
     #
     utterances = [_('bookmark entered')]
     utterances.extend(
         self._script.speechGenerator.generateSpeech(
             context.getCurrentAccessible()))
     speech.speak(utterances)

def paste(location):
	"""paste a file or directory that has been previously copied"""
	copyData = settings.getDataFile()
	if not location:
		location = "."
	try:
		data = pickle.load(open(copyData, "rb"))
		speech.speak("Pasting " + data["copyLocation"] + " to current directory.")
	except:
		speech.fail("It doesn't look like you've copied anything yet.")
		speech.fail("Type 'hallie copy <file>' to copy a file or folder.")
		return
	process, error = subprocess.Popen(["cp", "-r", data["copyLocation"], location], stderr=subprocess.STDOUT, stdout=subprocess.PIPE).communicate()
	if "denied" in process:
		speech.fail("Unable to paste your file successfully. This is most likely due to a permission issue. You can try to run me as sudo!")