def _on_aborted(self, key_mode):
     """Leave KEY_MODE whenever a prompt is aborted."""
     try:
         modeman.leave(self._win_id, key_mode, 'aborted', maybe=True)
     except objreg.RegistryUnavailableError:
         # window was deleted: ignore
         pass

    def _filter_number_hints(self):
        """Apply filters for numbered hints and renumber them.

        Return:
            Elements which are still visible
        """
        # renumber filtered hints
        elems = []
        for e in self._context.all_elems:
            try:
                if not self._is_hidden(e.label):
                    elems.append(e)
            except webelem.IsNullError:
                pass
        if not elems:
            # Whoops, filtered all hints
            modeman.leave(self._win_id, usertypes.KeyMode.hint,
                          'all filtered')
            return {}

        strings = self._hint_strings(elems)
        self._context.elems = {}
        for elem, string in zip(elems, strings):
            elem.label.setInnerXml(string)
            self._context.elems[string] = elem
        keyparsers = objreg.get('keyparsers', scope='window',
                                window=self._win_id)
        keyparser = keyparsers[usertypes.KeyMode.hint]
        keyparser.update_bindings(strings, preserve_filter=True)

        return self._context.elems

    def filter_hints(self, filterstr):
        """Filter displayed hints according to a text.

        Args:
            filterstr: The string to filer with, or None to show all.
        """
        for elems in self._context.elems.values():
            if (filterstr is None or
                    str(elems.elem).lower().startswith(filterstr)):
                if self._is_hidden(elems.label):
                    # hidden element which matches again -> unhide it
                    elems.label.setStyleProperty('display', 'none')
            else:
                # element doesn't match anymore -> hide it
                elems.label.setStyleProperty('display', 'none')
        visible = {}
        for k, e in self._context.elems.items():
            if not self._is_hidden(e.label):
                visible[k] = e
        if not visible:
            # Whoops, filtered all hints
            modeman.leave(self._win_id, usertypes.KeyMode.hint, 'all filtered')
        elif len(visible) == 1 and config.get('hints', 'auto-follow'):
            # unpacking gets us the first (and only) key in the dict.
            self.fire(*visible)

    def filter_hints(self, filterstr):
        """Filter displayed hints according to a text.

        Args:
            filterstr: The string to filter with, or None to show all.
        """
        for elems in self._context.elems.values():
            try:
                if (filterstr is None or
                        filterstr.casefold() in str(elems.elem).casefold()):
                    if self._is_hidden(elems.label):
                        # hidden element which matches again -> show it
                        self._show_elem(elems.label)
                else:
                    # element doesn't match anymore -> hide it
                    self._hide_elem(elems.label)
            except webelem.IsNullError:
                pass
        visible = {}
        for k, e in self._context.elems.items():
            try:
                if not self._is_hidden(e.label):
                    visible[k] = e
            except webelem.IsNullError:
                pass
        if not visible:
            # Whoops, filtered all hints
            modeman.leave(self._win_id, usertypes.KeyMode.hint, 'all filtered')
        elif len(visible) == 1 and config.get('hints', 'auto-follow'):
            # unpacking gets us the first (and only) key in the dict.
            self.fire(*visible)

 def prompt_yes(self):
     """Answer yes to a yes/no prompt."""
     if self._question.mode != usertypes.PromptMode.yesno:
         # We just ignore this if we don't have a yes/no question.
         return
     self._question.answer = True
     modeman.leave(usertypes.KeyMode.yesno, 'yesno accept')
     self._question.done()

 def prompt_no(self):
     """Answer no to a yes/no prompt."""
     if self._question.mode != usertypes.PromptMode.yesno:
         # We just ignore this if we don't have a yes/no question.
         return
     self._question.answer = False
     modeman.leave(self._win_id, usertypes.KeyMode.yesno, 'prompt accept')
     self._question.done()

    def filter_hints(self, filterstr):
        """Filter displayed hints according to a text.

        Args:
            filterstr: The string to filter with, or None to use the filter
                       from previous call (saved in `self._filterstr`). If
                       `filterstr` is an empty string or if both `filterstr`
                       and `self._filterstr` are None, all hints are shown.
        """
        if filterstr is None:
            filterstr = self._context.filterstr
        else:
            self._context.filterstr = filterstr

        log.hints.debug("Filtering hints on {!r}".format(filterstr))

        visible = []
        # pylint: disable=not-an-iterable
        for label in self._context.all_labels:
            try:
                if self._filter_matches(filterstr, str(label.elem)):
                    visible.append(label)
                    # Show label again if it was hidden before
                    label.show()
                else:
                    # element doesn't match anymore -> hide it
                    label.hide()
            except webelem.Error:
                pass
        # pylint: enable=not-an-iterable

        if not visible:
            # Whoops, filtered all hints
            modeman.leave(self._win_id, usertypes.KeyMode.hint,
                          'all filtered')
            return

        if self._context.hint_mode == 'number':
            # renumber filtered hints
            strings = self._hint_strings(visible)
            self._context.labels = {}
            for label, string in zip(visible, strings):
                label.update_text('', string)
                self._context.labels[string] = label
            keyparsers = objreg.get('keyparsers', scope='window',
                                    window=self._win_id)
            keyparser = keyparsers[usertypes.KeyMode.hint]
            keyparser.update_bindings(strings, preserve_filter=True)

            # Note: filter_hints can be called with non-None filterstr only
            # when number mode is active
            if filterstr is not None:
                # pass self._context.labels as the dict of visible hints
                self._handle_auto_follow(filterstr=filterstr,
                                         visible=self._context.labels)

 def command_accept(self):
     """Execute the command currently in the commandline."""
     prefixes = {
         ':': '',
         '/': 'search -- ',
         '?': 'search -r -- ',
     }
     text = self.text()
     self.history.append(text)
     modeman.leave(self._win_id, usertypes.KeyMode.command, 'cmd accept')
     self.got_cmd.emit(prefixes[text[0]] + text[1:])

 def command_accept(self):
     """Execute the command currently in the commandline."""
     signals = {
         ':': self.got_cmd,
         '/': self.got_search,
         '?': self.got_search_rev,
     }
     text = self.text()
     self.history.append(text)
     modeman.leave(self._win_id, usertypes.KeyMode.command, 'cmd accept')
     if text[0] in signals:
         signals[text[0]].emit(text.lstrip(text[0]))

    def _on_global_mode_left(self, mode):
        """Leave prompt/yesno mode in this window if it was left elsewhere.

        This ensures no matter where a prompt was answered, we leave the prompt
        mode and dispose of the prompt object in every window.
        """
        if mode not in [usertypes.KeyMode.prompt, usertypes.KeyMode.yesno]:
            return
        modeman.leave(self._win_id, mode, 'left in other window', maybe=True)
        item = self._layout.takeAt(0)
        if item is not None:
            widget = item.widget()
            log.prompt.debug("Deleting prompt {}".format(widget))
            widget.hide()
            widget.deleteLater()

        def mouserelease_insertmode_cb(elem):
            """Callback which gets called from JS."""
            if elem is None:
                log.mouse.debug("Element vanished!")
                return

            if elem.is_editable():
                log.mouse.debug("Clicked editable element (delayed)!")
                modeman.enter(self._tab.win_id, usertypes.KeyMode.insert,
                              'click-delayed', only_if_normal=True)
            else:
                log.mouse.debug("Clicked non-editable element (delayed)!")
                if config.get('input', 'auto-leave-insert-mode'):
                    modeman.leave(self._tab.win_id, usertypes.KeyMode.insert,
                                  'click-delayed', maybe=True)

    def command_accept(self, rapid=False):
        """Execute the command currently in the commandline.

        Args:
            rapid: Run the command without closing or clearing the command bar.
        """
        text = self.text()
        self.history.append(text)

        was_search = self._handle_search()

        if not rapid:
            modeman.leave(self._win_id, usertypes.KeyMode.command,
                          'cmd accept')

        if not was_search:
            self.got_cmd[str].emit(text[1:])

    def command_accept(self):
        """Execute the command currently in the commandline.

        Emit:
            got_cmd: If a new cmd was entered.
            got_search: If a new search was entered.
            got_search_rev: If a new reverse search was entered.
        """
        signals = {
            ':': self.got_cmd,
            '/': self.got_search,
            '?': self.got_search_rev,
        }
        text = self.text()
        self.history.append(text)
        modeman.leave(usertypes.KeyMode.command, 'cmd accept')
        if text[0] in signals:
            signals[text[0]].emit(text.lstrip(text[0]))

    def keyPressEvent(self, e):
        """Override keyPressEvent to ignore Return key presses.

        If this widget is focused, we are in passthrough key mode, and
        Enter/Shift+Enter/etc. will cause QLineEdit to think it's finished
        without command_accept to be called.
        """
        text = self.text()
        if text in modeparsers.STARTCHARS and e.key() == Qt.Key_Backspace:
            e.accept()
            modeman.leave(self._win_id, usertypes.KeyMode.command,
                          'prefix deleted')
            return
        if e.key() == Qt.Key_Return:
            e.ignore()
            return
        else:
            super().keyPressEvent(e)

    def _filter_non_number_hints(self):
        """Apply filters for letter/word hints.

        Return:
            Elements which are still visible
        """
        visible = {}
        for string, elem in self._context.elems.items():
            try:
                if not self._is_hidden(elem.label):
                    visible[string] = elem
            except webelem.IsNullError:
                pass
        if not visible:
            # Whoops, filtered all hints
            modeman.leave(self._win_id, usertypes.KeyMode.hint,
                          'all filtered')
        return visible

 def _leave_modes_on_load(self):
     """Leave insert/hint mode when loading started."""
     try:
         url = self.current_url()
         if not url.isValid():
             url = None
     except qtutils.QtValueError:
         url = None
     if config.instance.get('input.insert_mode.leave_on_load',
                            url=url):
         modeman.leave(self._win_id, usertypes.KeyMode.insert,
                       'load started', maybe=True)
     else:
         log.modes.debug("Ignoring leave_on_load request due to setting.")
     if config.cache['hints.leave_on_load']:
         modeman.leave(self._win_id, usertypes.KeyMode.hint,
                       'load started', maybe=True)
     else:
         log.modes.debug("Ignoring leave_on_load request due to setting.")

    def _mousepress_insertmode_cb(self, elem):
        """Check if the clicked element is editable."""
        if elem is None:
            # Something didn't work out, let's find the focus element after
            # a mouse release.
            log.mouse.debug("Got None element, scheduling check on "
                            "mouse release")
            self._check_insertmode_on_release = True
            return

        if elem.is_editable():
            log.mouse.debug("Clicked editable element!")
            modeman.enter(self._tab.win_id, usertypes.KeyMode.insert,
                          'click', only_if_normal=True)
        else:
            log.mouse.debug("Clicked non-editable element!")
            if config.get('input', 'auto-leave-insert-mode'):
                modeman.leave(self._tab.win_id, usertypes.KeyMode.insert,
                              'click', maybe=True)

    def on_current_changed(self, idx):
        """Set last-focused-tab and leave hinting mode when focus changed."""
        mode_on_change = config.val.tabs.mode_on_change
        if idx == -1 or self.shutting_down:
            # closing the last tab (before quitting) or shutting down
            return
        tab = self.widget.widget(idx)
        if tab is None:
            log.webview.debug("on_current_changed got called with invalid "
                              "index {}".format(idx))
            return

        log.modes.debug("Current tab changed, focusing {!r}".format(tab))
        tab.setFocus()

        modes_to_leave = [usertypes.KeyMode.hint, usertypes.KeyMode.caret]

        mm_instance = modeman.instance(self._win_id)
        current_mode = mm_instance.mode
        log.modes.debug("Mode before tab change: {} (mode_on_change = {})"
                        .format(current_mode.name, mode_on_change))
        if mode_on_change == 'normal':
            modes_to_leave += modeman.INPUT_MODES
        for mode in modes_to_leave:
            modeman.leave(self._win_id, mode, 'tab changed', maybe=True)
        if (mode_on_change == 'restore' and
                current_mode not in modeman.PROMPT_MODES):
            modeman.enter(self._win_id, tab.data.input_mode, 'restore')
        if self._now_focused is not None:
            objreg.register('last-focused-tab', self._now_focused, update=True,
                            scope='window', window=self._win_id)
        log.modes.debug("Mode after tab change: {} (mode_on_change = {})"
                        .format(current_mode.name, mode_on_change))
        self._now_focused = tab
        self.current_tab_changed.emit(tab)
        QTimer.singleShot(0, self._update_window_title)
        self._tab_insert_idx_left = self.widget.currentIndex()
        self._tab_insert_idx_right = self.widget.currentIndex() + 1

    def on_current_changed(self, idx):
        """Set last-focused-tab and leave hinting mode when focus changed."""
        mode_on_change = config.val.tabs.mode_on_change
        modes_to_save = [usertypes.KeyMode.insert,
                         usertypes.KeyMode.passthrough]
        if idx == -1 or self.shutting_down:
            # closing the last tab (before quitting) or shutting down
            return
        tab = self.widget(idx)
        if tab is None:
            log.webview.debug("on_current_changed got called with invalid "
                              "index {}".format(idx))
            return
        if self._now_focused is not None and mode_on_change == 'restore':
            current_mode = modeman.instance(self._win_id).mode
            if current_mode not in modes_to_save:
                current_mode = usertypes.KeyMode.normal
            self._now_focused.data.input_mode = current_mode

        log.modes.debug("Current tab changed, focusing {!r}".format(tab))
        tab.setFocus()

        modes_to_leave = [usertypes.KeyMode.hint, usertypes.KeyMode.caret]
        if mode_on_change != 'persist':
            modes_to_leave += modes_to_save
        for mode in modes_to_leave:
            modeman.leave(self._win_id, mode, 'tab changed', maybe=True)
        if mode_on_change == 'restore':
            modeman.enter(self._win_id, tab.data.input_mode,
                          'restore input mode for tab')
        if self._now_focused is not None:
            objreg.register('last-focused-tab', self._now_focused, update=True,
                            scope='window', window=self._win_id)
        self._now_focused = tab
        self.current_tab_changed.emit(tab)
        QTimer.singleShot(0, self._update_window_title)
        self._tab_insert_idx_left = self.currentIndex()
        self._tab_insert_idx_right = self.currentIndex() + 1

 def filter_hints(self, filterstr):
     """Filter displayed hints according to a text."""
     for elems in self._context.elems.values():
         if str(elems.elem).lower().startswith(filterstr):
             if elems.label['hidden'] == 'true':
                 # hidden element which matches again -> unhide it
                 elems.label['hidden'] = 'false'
                 css = self._get_hint_css(elems.elem, elems.label)
                 elems.label['style'] = css
         else:
             # element doesn't match anymore -> hide it
             elems.label['hidden'] = 'true'
             css = self._get_hint_css(elems.elem, elems.label)
             elems.label['style'] = css
     visible = {}
     for k, e in self._context.elems.items():
         if e.label['hidden'] != 'true':
             visible[k] = e
     if not visible:
         # Whoops, filtered all hints
         modeman.leave(usertypes.KeyMode.hint, 'all filtered')
     elif len(visible) == 1 and config.get('hints', 'auto-follow'):
         # unpacking gets us the first (and only) key in the dict.
         self.fire(*visible)