def set_connected(self, switch):
		self._connected = switch

		for child in self.children:
			child.set_connected(switch)

		urwid.emit_signal(self, "connected", switch)

 def keypress(self, size, key):
     if key == "enter":
         text = self.get_edit_text()
         urwid.emit_signal(self, "send_signal", text)
         self.set_edit_text("")
     else:
         return super(EditSms, self).keypress(size, key)

 def edit_changed(self, x, d, *arg):
     # r = self.lck.acquire(False)
     # if r:
     if self.textField._checamudou():
         urwid.emit_signal(self, 'change', self, d)
         nisk.util.dump((self.textField.value(), self.textField._lastlastvalue, self.textField._checamudou()),
                        'change date')

 def keypress(self, size, key):
     if key=='enter':
         line=self.edit_text.strip()
         if line:
             urwid.emit_signal(self,'line_entered', line)
             self.history.append(line)
         self._history_index=len(self.history)
         self.edit_text=u''
     if key=='up':
         
         self._history_index-=1
         if self._history_index< 0:
             self._history_index= 0
         else:
             self.edit_text=self.history[self._history_index]
             self.set_edit_pos(len(self.edit_text))
     if key=='down':
         self._history_index+=1
         if self._history_index>=len(self.history):
             self._history_index=len(self.history) 
             self.edit_text=u''
         else:
             self.edit_text=self.history[self._history_index]
             self.set_edit_pos(len(self.edit_text))
     else:
         urwid.Edit.keypress(self, size, key)

 def __accept(self):
     new_vals = {
         'server_uri': self.server_uri,
         'username': self.username,
         'password': self.password,
     }
     urwid.emit_signal(self, SettingsWidget.SIG_SETTINGS_ACCEPTED, new_vals)

 def keypress(self, size, key):
     if key == 'enter':
         urwid.emit_signal(self, 'done', self.get_edit_text())
         return
     if key == 'esc':
         urwid.emit_signal(self, 'done', None)
     urwid.Edit.keypress(self, size, key)

 def bottom(self):
     for index in xrange(len(self.contents) - 1, -1, -1):
         widget = self.contents[index][0]
         if self.constraint(index, widget):
             self.focus_position = index
             urwid.emit_signal(self, 'shift')
             return

 def shiftUp(self, amount=1):
     if self.body.focus is not self.scroll(-amount):
         self.focus_position = self.scroll()
         self.body[:] = self.body[:]
         urwid.emit_signal(self, 'shift')
     else:
         urwid.emit_signal(self,'top')

    def keypress(self, size, key):
        if key == "enter":
            if self.edit_text == "" and self.history:
                self.command = Command(self.history[-1])
            else:
                self.command = Command(self.edit_text)
                self.history.append(self.edit_text)

            self.command.executeCommand()
            self.historyIdx = -1
            self.edit_text = ""

            urwid.emit_signal(self, "executed")
        elif key == "up":
            if len(self.history) != 0:
                self.edit_text = self.history[self.historyIdx]
                self.edit_pos = len(self.edit_text)
                if self.historyIdx - 1 >= -1 * len(self.history):
                    self.historyIdx -= 1
        elif key == "down":
            if self.historyIdx == -1:
                self.edit_text = ""
            else:
                self.historyIdx += 1
                self.edit_text = self.history[self.historyIdx]
                self.edit_pos = len(self.edit_text)
        else:
            return super(CliEdit, self).keypress(size, key)

    def __cebPrisoners(self, a_arg_or_err, a_auth, a_prisoners):
        if isinstance(a_arg_or_err, twisted.python.failure.Failure):
            urwid.emit_signal(self, SIG_RSP_PRISONERS, None, None, a_arg_or_err.value)

            return

        next_uri = None
        iresponse, resp_str, json_obj = a_arg_or_err
        new_items = dict(( ( i['id'], i ) for i in json_obj['items'] ))
        a_prisoners['items'].update(new_items)

        # Note, we check to see if "offset" has changed because there is a
        # bug in the server reference implementation where the "offset"
        # parameter is ignored (see "Server Issues" section in README)
        if json_obj['next'] is not None \
                and json_obj.get('offset', SENTINEL) != a_prisoners['offset']:
            next_uri = urlparse.urljoin(self.__base_uri, json_obj['next'])

        a_prisoners.update(( ( k, v ) for k, v in json_obj.items() if k != 'items' ))

        # Keep calling ourselves as long as we have somewhere to go
        if next_uri is not None:
            d = self._jsonRequest(next_uri, a_auth)
            d.addCallback(self.__cebPrisoners, a_auth, a_prisoners)
            d.addErrback(self.__cebPrisoners, a_auth, a_prisoners)

            return d

        urwid.emit_signal(self, SIG_RSP_PRISONERS, a_auth, a_prisoners['items'])

    def __cebNewAccountLogIn(self, a_arg_or_err, a_base_uri, a_auth):
        try:
            self.__logIn(a_base_uri, a_auth, a_arg_or_err)
        except Exception, e:
            urwid.emit_signal(self, SIG_RSP_NEW_ACCT, None, e)

            return

	def remove(self):
		""" emit remove signals """
		for child in self.children:
			child.remove()
			self.child_removed(child)
		urwid.emit_signal(self, "remove")
		self.set_parent(None)

 def keypress(self, size, key):
     key = super().keypress(size, key)
     if key is not 'enter':
         return key
     else:
         message_text = self.input_field.get_edit_text()
         urwid.emit_signal(self, 'message-send', message_text)

  def cmd_exit_msgbox(self, *args):
    if self.logo_displayed:
      self.clear_msgbox()
      self.logo_displayed = False
      self._selectable = False

    urwid.emit_signal(self, 'exit_msgbox')

 def keypress(self, size, key):
     if key == "enter":
         self.save()
     elif key == "ctrl k":
         urwid.emit_signal(self, 'saved')
     else:
         return super(Saver, self).keypress(size, key)

 def shiftDown(self, amount=1):
     if self.body.focus is not self.scroll(amount):
         self.focus_position = self.scroll()
         self.body[:] = self.body[:]
         urwid.emit_signal(self, 'shift')
     else:
         urwid.emit_signal(self, 'bottom')

 def keypress(self, size, key):
     if self.single:
         urwid.emit_signal(self, 'prompt_enter', self, key)
     elif key == 'enter':
         urwid.emit_signal(self, 'prompt_enter', self, self.get_edit_text())
     else:
         return urwid.Edit.keypress(self, size, key)

    def keypress(self, size, key):
        """ 
            Handle user inputs
        """

        urwid.emit_signal(self, "keypress", size, key)

        # scroll the top panel

        if key in ("page up","page down","up","down"):
            self.body.keypress (size, key)
    
        # resize the main windows
        elif key == "window resize":
            self.size = self.ui.get_cols_rows()
#    
#        elif key in ('ctrl q'):
#            self.quit()
#            self.context.keypress (size, key)
               
        elif key == "enter":
            # Parse data or (if parse failed)
            # send it to the current world
            text = self.footer.get_edit_text()
            self.footer.set_edit_text(u" "*len(text))
            self.footer.set_edit_text(u"")
            if text.strip():
                self.print_sent_message(text)
                #self.print_received_message('Answer')
        else:
            self.context.keypress(size, key)

 def keypress(self, size, key):
     if key == 'enter':
         urwid.emit_signal(self, 'ask_done', self.get_edit_text())
     elif key == 'esc':
         urwid.emit_signal(self, 'ask_done', None)
     elif len(key) != 1 or self.validator is None or self.validator(key):
         super().keypress(size, key)

 def do_select(self, remember):
     accountitem = self.listwalker.get_focus()[0]
     if remember:
         self.manager.set_default(accountitem.num)
     else:
         self.manager.set_default(None)
     self.close()
     urwid.emit_signal(self, 'done', accountitem.account)