def clear(self):
     urwid.disconnect_signal(self.walker, 'modified', self.interface.lazzy_load)
     while len(self.walker) > 1:
         pop = self.walker.pop()
         self.cleared = pop.id
     if self.cleared == None:
         self.cleared = True

    def complete_move(self, value, current_position):
        urwid.disconnect_signal(
            self,
            self.move_prompt,
            signals.PROMPT_DONE,
            self.complete_move)
        urwid.disconnect_signal(
            self,
            self.move_prompt,
            signals.UPDATE_INDEX,
            self.view.move_update_index)

        self.update_focus('body')

        try:
            new_index = int(value)
            logger.debug('Moving playlist track from {} to {}'.format(
                current_position, new_index))

            mpd = mstat.initialize_mpd(self.conf)
            mpd.move(current_position, new_index)
            self.view.focus_position = new_index
        except (TypeError, ValueError):
            logger.error('Invalid move index: {}'.format(value))

        self.view.update()
        self.update()

 def search_entered(self, content):
     self.view.set_focus('body')
     urwid.disconnect_signal(
         self, self.foot, 'search_entered', self.anime_entered)
     urwid.disconnect_signal(
         self, self.foot, 'query_escaped', self.query_escaped)
     self.view.set_footer(urwid.AttrWrap(self.default_footer, 'foot'))
     
     items = []
     # categories
     if self.current_view == 1 and self.list_sort_type in (0, 1):
         lst = malconstrict.helpers.search_substring(self.cached_sections[self.cats[self.catfocus]], content)
         i = 1
         items.append(CategoryItemWidget(self.cats[self.catfocus]))
         for anime in lst:
             items.append(ListItemWidget(i, anime.title + ' [' + str(anime.score) + ']', anime.id))
             i = i + 1
     # full
     elif (self.current_view == 1 and self.list_sort_type in (2, 3)) or self.current_view == 2:
         items = []
         lst = malconstrict.helpers.search_substring(self.cached_list, content)
         i = 1
         for anime in lst:
             if self.current_view == 1:
                 items.append(ListItemWidget(i, anime.title + ' [' + str(anime.score) + ']', anime.id))
             elif self.current_view == 2:
                 items.append(
                     ListItemWidget(i, anime.title + ' [' + str(anime.members_score) + ']', anime.id))
             i = i + 1
     
     walker = urwid.SimpleListWalker(items)
     self.listbox = urwid.ListBox(walker)
     self.view.set_body(urwid.Frame(urwid.AttrWrap(self.listbox, 'body')))
     self.view.set_footer(urwid.AttrWrap(self.default_footer, 'foot'))
     self.view.set_focus('body')

 def query_escaped(self, content):
     self.view.set_focus('body')
     urwid.disconnect_signal(
         self, self.foot, 'username_entered', self.username_entered)
     urwid.disconnect_signal(
         self, self.foot, 'anime_entered', self.anime_entered)
     self.view.set_footer(urwid.AttrWrap(self.default_footer, 'foot'))

    def command_done(self, command):
        self.top.set_focus('body')
        urwid.disconnect_signal(
            self,
            self.edit,
            signals.COMMAND_DONE,
            self.command_done)

        if command:
            try:
                current_buf = self.top.current_buffer()
                success = current_buf.execute_command(command)
                if not success:
                    success = self.execute_command(command)

                if not success:
                    self.update_footer_text(
                        "Unable to execute command '{}'".format(command),
                        error=True)
            except TypeError as err:
                logger.debug('TypeError: {}'.format(err))
                self.update_footer_text(
                    "Invalid arguments for command '{}'".format(command),
                    error=True)
            except CommandError as ex:
                logger.debug(ex)
                self.update_footer_text(ex.message, error=True)

 def _promptSearch_done(self, query):
     self.view.set_focus("body")
     urwid.disconnect_signal(self, self.prompt, "done", self._promptSearch_done)
     if not query:
         self.set_status()
         return
     self.newbuffer(["search", query])

    def go_search(self, what_for):
        # Set the focus back to body
        self.view.set_focus('body')

        # Disconnect
        urwid.disconnect_signal(self.foot_new, 'done', self.go_search)

        # Check if we got a query...
        if not what_for: return

        # Construct a regex (yeah...)
        pattern = r'(.*)' + re.escape(what_for) + r'(.*)'

        # Store elements that match the query
        self.matches = []

        # Loop and match
        n = 0
        for i in self.elements:
            m = re.search(pattern, i.content, re.IGNORECASE)
            if m:
                # self.listbox.set_focus(n)
                # break
                self.matches.append(n)
            n = n + 1

        # Now jump to the first match and then later we can use n N to go around
        if self.matches:
            self.listbox.set_focus(self.matches[0])

            # Set the search pointer to point to the first element.
            self.search_ptr = 0
        else:
            self.search_ptr = -1

 def hide_editor(self, done_signal_handler):
     try:
         disconnect_signal(self._editor, 'done', done_signal_handler)
     except Exception, message:
         # `disconnect_signal` raises an exception if no signal was
         # connected from `self._editor`. we can safely ignore it.
         logging.exception(message)

 def _filterSearch_done(self, newquery):
     self.ui.view.set_focus('body')
     urwid.disconnect_signal(self.ui, self.ui.prompt, 'done', self._filterSearch_done)
     if not newquery:
         self.ui.set_status()
         return
     self.ui.newbuffer(['search', self.query, newquery])

	def switch_body(self, body):
		if self.body:
			urwid.disconnect_signal(body, "modified", self._invalidate)

		self.body = body
		self._invalidate()

		urwid.connect_signal(body, "modified", self._invalidate)

 def hide_editor(self, done_signal_handler):
     try:
         disconnect_signal(self._editor, 'done', done_signal_handler)
     except:
         # `disconnect_signal` raises an exception if no signal was
         # connected from `self._editor`. We can safely ignore it.
         pass
     self._editor = None
     self.body.hide_top_widget()

 def remove_editor(self, done_signal_handler):
     try:
         disconnect_signal(self.editor, 'done', done_signal_handler)
     except:
         # `disconnect_signal` raises an exception if no signal was
         # connected from `self.editor`. We can safely ignore it.
         pass
     self.editor = None
     self.clear_status()

 def anime_entered(self, content):
     self.view.set_focus('body')
     urwid.disconnect_signal(
         self, self.foot, 'anime_entered', self.anime_entered)
     urwid.disconnect_signal(
         self, self.foot, 'query_escaped', self.query_escaped)
     self.view.set_footer(urwid.AttrWrap(self.default_footer, 'foot'))
     self.display_to_top('MALSnakes - showing results for "' + content + '"')
     self.pull_in_anime_query_list(content)

 def login_escaped(self, content):
     self.view.set_focus('body')
     urwid.disconnect_signal(
         self, self.foot, 'login_authenticate', self.login_authenticate)
     urwid.disconnect_signal(
         self, self.foot, 'login_escaped', self.login_escaped)
     self.username = ''
     self.password = ''
     self.view.set_footer(urwid.AttrWrap(self.default_footer, 'foot'))

    def input_done(self, response):
        urwid.disconnect_signal(self, self.container.get_footer(),
                                'done', self.input_done)
        self.container.set_footer(self.footer)
        self.container.set_focus('body')

        if self.input_callback:
            self.input_callback(response)

        self.input_callback = None

 def _runtest(self, b):
     if not self._tclist:
         self._emit("message", "No tests selected")
         return
     urwid.disconnect_signal(b, "click", self._runtest) # prevent running again until test ends
     environmentname = self._envsel.value
     reportname = self._repsel.value
     options = self._get_options()
     testlist = [tw.base_widget.text for tw in self._tclist]
     self.runtest(testlist, environmentname, reportname, options)
     self._w.set_focus("body")

 def login_authenticate(self, content):
     self.view.set_focus('body')
     urwid.disconnect_signal(
         self, self.foot, 'login_authenticate', self.login_authenticate)
     urwid.disconnect_signal(
         self, self.foot, 'login_escaped', self.login_escaped)
     self.username = content[0]
     self.password = content[1]
     self.view.set_footer(urwid.AttrWrap(self.default_footer, 'foot'))
     self.display_to_top('MALSnakes - logged in as ' + self.username)
     self.authenticated = True

 def edit_done(self, content):
   self.box.set_focus('body')
   urwid.disconnect_signal(self, self.foot, 'done', self.edit_done)
   if content:
     if content[0] == "/":
       self.parse_self_command(content[1:])
     else:
       for friend in self.friends:
         self.send_command(friend, content)
     self.txt.set_text(self.txt.get_text()[0] + "\n<" + self.nick + "> " + content)
   self.inputbox.set_text("> ")
   self.loop.draw_screen()

    def edit_done(self, content=None):
        """After footer editing process is pointed here.

        Args:
            content: The content, what user entered, if any.

        """
        self.view.set_focus('body')
        urwid.disconnect_signal(self.foot_new, 'done', self.edit_done)
        if content:
            # Command processor here?
            self.view.set_body(urwid.Filler(urwid.Text(content), 'top'))
        self.view.set_footer(self.foot)

	def edit_done(self, content):
		
		try:
			self.view.set_focus('body')
			urwid.disconnect_signal(self, self.foot, 'done', self.edit_done)
			
			if content:
				self.q = '\"'+content+'\"'
				self.num = 50
				self.order = 'relevance'
				self.execute()
			
			self.view.set_footer(None)
		
		except Exception as e:
			logging.exception(e)