Python config.get函数代码示例

    def show_help(self, topic=None):
        r"""Show help about a command or setting.

        Args:
            topic: The topic to show help for.

                   - :__command__ for commands.
                   - __section__\->__option__ for settings.
        """
        if topic is None:
            path = 'index.html'
        elif topic.startswith(':'):
            command = topic[1:]
            if command not in cmdutils.cmd_dict:
                raise cmdexc.CommandError("Invalid command {}!".format(
                    command))
            path = 'commands.html#{}'.format(command)
        elif '->' in topic:
            parts = topic.split('->')
            if len(parts) != 2:
                raise cmdexc.CommandError("Invalid help topic {}!".format(
                    topic))
            try:
                config.get(*parts)
            except config.NoSectionError:
                raise cmdexc.CommandError("Invalid section {}!".format(
                    parts[0]))
            except config.NoOptionError:
                raise cmdexc.CommandError("Invalid option {}!".format(
                    parts[1]))
            path = 'settings.html#{}'.format(topic.replace('->', '-'))
        else:
            raise cmdexc.CommandError("Invalid help topic {}!".format(topic))
        self.openurl('qute://help/{}'.format(path))

    def _get_new_tab_idx(self, explicit):
        """Get the index of a tab to insert.

        Args:
            explicit: Whether the tab was opened explicitely.

        Return:
            The index of the new tab.
        """
        if explicit:
            pos = config.get('tabs', 'new-tab-position-explicit')
        else:
            pos = config.get('tabs', 'new-tab-position')
        if pos == 'left':
            idx = self._tab_insert_idx_left
            # On first sight, we'd think we have to decrement
            # self._tab_insert_idx_left here, as we want the next tab to be
            # *before* the one we just opened. However, since we opened a tab
            # *to the left* of the currently focused tab, indices will shift by
            # 1 automatically.
        elif pos == 'right':
            idx = self._tab_insert_idx_right
            self._tab_insert_idx_right += 1
        elif pos == 'first':
            idx = 0
        elif pos == 'last':
            idx = -1
        else:
            raise ValueError("Invalid new-tab-position '{}'.".format(pos))
        log.webview.debug("new-tab-position {} -> opening new tab at {}, "
                          "next left: {} / right: {}".format(
                              pos, idx, self._tab_insert_idx_left,
                              self._tab_insert_idx_right))
        return idx

    def edit(self, text):
        """Edit a given text.

        Args:
            text: The initial text to edit.
        """
        if self._text is not None:
            raise ValueError("Already editing a file!")
        self._text = text
        try:
            self._oshandle, self._filename = tempfile.mkstemp(
                text=True, prefix='qutebrowser-editor-')
            if text:
                encoding = config.get('general', 'editor-encoding')
                with open(self._filename, 'w', encoding=encoding) as f:
                    f.write(text)  # pragma: no branch
        except OSError as e:
            message.error(self._win_id, "Failed to create initial file: "
                                        "{}".format(e))
            return
        self._proc = guiprocess.GUIProcess(self._win_id, what='editor',
                                           parent=self)
        self._proc.finished.connect(self.on_proc_closed)
        self._proc.error.connect(self.on_proc_error)
        editor = config.get('general', 'editor')
        executable = editor[0]
        args = [self._filename if arg == '{}' else arg for arg in editor[1:]]
        log.procs.debug("Calling \"{}\" with args {}".format(executable, args))
        self._proc.start(executable, args)

    def undo(self):
        """Undo removing of a tab."""
        # Remove unused tab which may be created after the last tab is closed
        last_close = config.get('tabs', 'last-close')
        use_current_tab = False
        if last_close in ['blank', 'startpage', 'default-page']:
            only_one_tab_open = self.count() == 1
            no_history = len(self.widget(0).history) == 1
            urls = {
                'blank': QUrl('about:blank'),
                'startpage': QUrl(config.get('general', 'startpage')[0]),
                'default-page': config.get('general', 'default-page'),
            }
            first_tab_url = self.widget(0).url()
            last_close_urlstr = urls[last_close].toString().rstrip('/')
            first_tab_urlstr = first_tab_url.toString().rstrip('/')
            last_close_url_used = first_tab_urlstr == last_close_urlstr
            use_current_tab = (only_one_tab_open and no_history and
                               last_close_url_used)

        url, history_data, idx = self._undo_stack.pop()

        if use_current_tab:
            self.openurl(url, newtab=False)
            newtab = self.widget(0)
        else:
            newtab = self.tabopen(url, background=False, idx=idx)

        newtab.history.deserialize(history_data)

    def _hint_strings(self, elems):
        """Calculate the hint strings for elems.

        Inspired by Vimium.

        Args:
            elems: The elements to get hint strings for.

        Return:
            A list of hint strings, in the same order as the elements.
        """
        hint_mode = config.get('hints', 'mode')
        if hint_mode == 'word':
            try:
                return self._word_hinter.hint(elems)
            except WordHintingError as e:
                message.error(self._win_id, str(e), immediately=True)
                # falls back on letter hints
        if hint_mode == 'number':
            chars = '0123456789'
        else:
            chars = config.get('hints', 'chars')
        min_chars = config.get('hints', 'min-chars')
        if config.get('hints', 'scatter') and hint_mode != 'number':
            return self._hint_scattered(min_chars, chars, elems)
        else:
            return self._hint_linear(min_chars, chars, elems)

    def _handle_auto_follow(self, keystr="", filterstr="", visible=None):
        """Handle the auto-follow option."""
        if visible is None:
            visible = {string: label
                       for string, label in self._context.labels.items()
                       if label.isVisible()}

        if len(visible) != 1:
            return

        auto_follow = config.get('hints', 'auto-follow')

        if auto_follow == "always":
            follow = True
        elif auto_follow == "unique-match":
            follow = keystr or filterstr
        elif auto_follow == "full-match":
            elemstr = str(list(visible.values())[0].elem)
            filter_match = self._filter_matches_exactly(filterstr, elemstr)
            follow = (keystr in visible) or filter_match
        else:
            follow = False
            # save the keystr of the only one visible hint to be picked up
            # later by self.follow_hint
            self._context.to_follow = list(visible.keys())[0]

        if follow:
            # apply auto-follow-timeout
            timeout = config.get('hints', 'auto-follow-timeout')
            keyparsers = objreg.get('keyparsers', scope='window',
                                    window=self._win_id)
            normal_parser = keyparsers[usertypes.KeyMode.normal]
            normal_parser.set_inhibited_timeout(timeout)
            # unpacking gets us the first (and only) key in the dict.
            self._fire(*visible)

    def _draw_textdoc(self, rect):
        """Draw the QTextDocument of an item.

        Args:
            rect: The QRect to clip the drawing to.
        """
        # We can't use drawContents because then the color would be ignored.
        # See: https://qt-project.org/forums/viewthread/21492
        clip = QRectF(0, 0, rect.width(), rect.height())
        self._painter.save()
        if self._opt.state & QStyle.State_Selected:
            option = 'completion.item.selected.fg'
        elif not self._opt.state & QStyle.State_Enabled:
            option = 'completion.category.fg'
        else:
            option = 'completion.fg'
        try:
            self._painter.setPen(config.get('colors', option))
        except configexc.NoOptionError:
            self._painter.setPen(config.get('colors', 'completion.fg'))
        ctx = QAbstractTextDocumentLayout.PaintContext()
        ctx.palette.setColor(QPalette.Text, self._painter.pen().color())
        if clip.isValid():
            self._painter.setClipRect(clip)
            ctx.clip = clip
        self._doc.documentLayout().draw(self._painter, ctx)
        self._painter.restore()

    def search(self, text, reverse=False):
        """Search for a text on the current page.

        Args:
            text: The text to search for.
            reverse: Reverse search direction.
        """
        if self._text is not None and self._text != text:
            # We first clear the marked text, then the highlights
            self.do_search.emit('', 0)
            self.do_search.emit('', QWebPage.HighlightAllOccurrences)
        self._text = text
        self._flags = 0
        ignore_case = config.get('general', 'ignore-case')
        if ignore_case == 'smart':
            if not text.islower():
                self._flags |= QWebPage.FindCaseSensitively
        elif not ignore_case:
            self._flags |= QWebPage.FindCaseSensitively
        if config.get('general', 'wrap-search'):
            self._flags |= QWebPage.FindWrapsAroundDocument
        if reverse:
            self._flags |= QWebPage.FindBackward
        # We actually search *twice* - once to highlight everything, then again
        # to get a mark so we can navigate.
        self.do_search.emit(self._text, self._flags)
        self.do_search.emit(self._text, self._flags |
                            QWebPage.HighlightAllOccurrences)

 def resize_completion(self):
     """Adjust completion according to config."""
     if not self._completion.isVisible():
         # It doesn't make sense to resize the completion as long as it's
         # not shown anyways.
         return
     # Get the configured height/percentage.
     confheight = str(config.get("completion", "height"))
     if confheight.endswith("%"):
         perc = int(confheight.rstrip("%"))
         height = self.height() * perc / 100
     else:
         height = int(confheight)
     # Shrink to content size if needed and shrinking is enabled
     if config.get("completion", "shrink"):
         contents_height = (
             self._completion.viewportSizeHint().height()
             + self._completion.horizontalScrollBar().sizeHint().height()
         )
         if contents_height <= height:
             height = contents_height
     else:
         contents_height = -1
     # hpoint now would be the bottom-left edge of the widget if it was on
     # the top of the main window.
     topleft_y = self.height() - self.status.height() - height
     topleft_y = qtutils.check_overflow(topleft_y, "int", fatal=False)
     topleft = QPoint(0, topleft_y)
     bottomright = self.status.geometry().topRight()
     rect = QRect(topleft, bottomright)
     log.misc.debug("completion rect: {}".format(rect))
     if rect.isValid():
         self._completion.setGeometry(rect)

    def undo(self):
        """Undo removing of a tab."""
        # Remove unused tab which may be created after the last tab is closed
        last_close = config.get("tabs", "last-close")
        use_current_tab = False
        if last_close in ["blank", "startpage", "default-page"]:
            only_one_tab_open = self.count() == 1
            no_history = self.widget(0).history().count() == 1
            urls = {
                "blank": QUrl("about:blank"),
                "startpage": QUrl(config.get("general", "startpage")[0]),
                "default-page": config.get("general", "default-page"),
            }
            first_tab_url = self.widget(0).page().mainFrame().requestedUrl()
            last_close_urlstr = urls[last_close].toString().rstrip("/")
            first_tab_urlstr = first_tab_url.toString().rstrip("/")
            last_close_url_used = first_tab_urlstr == last_close_urlstr
            use_current_tab = only_one_tab_open and no_history and last_close_url_used

        url, history_data = self._undo_stack.pop()

        if use_current_tab:
            self.openurl(url, newtab=False)
            newtab = self.widget(0)
        else:
            newtab = self.tabopen(url, background=False)

        qtutils.deserialize(history_data, newtab.history())

    def close_tab(self, tab, *, add_undo=True):
        """Close a tab.

        Args:
            tab: The QWebView to be closed.
            add_undo: Whether the tab close can be undone.
        """
        last_close = config.get('tabs', 'last-close')
        count = self.count()

        if last_close == 'ignore' and count == 1:
            return

        # If we are removing a pinned tab, decrease count
        if tab.data.pinned:
            self.tabBar().pinned_count -= 1

        self._remove_tab(tab, add_undo=add_undo)

        if count == 1:  # We just closed the last tab above.
            if last_close == 'close':
                self.close_window.emit()
            elif last_close == 'blank':
                self.openurl(QUrl('about:blank'), newtab=True)
            elif last_close == 'startpage':
                url = QUrl(config.get('general', 'startpage')[0])
                self.openurl(url, newtab=True)
            elif last_close == 'default-page':
                url = config.get('general', 'default-page')
                self.openurl(url, newtab=True)

    def close_tab(self, tab):
        """Close a tab.

        Args:
            tab: The QWebView to be closed.
        """
        last_close = config.get("tabs", "last-close")
        count = self.count()

        if last_close == "ignore" and count == 1:
            return

        self._remove_tab(tab)

        if count == 1:  # We just closed the last tab above.
            if last_close == "close":
                self.close_window.emit()
            elif last_close == "blank":
                self.openurl(QUrl("about:blank"), newtab=True)
            elif last_close == "startpage":
                url = QUrl(config.get("general", "startpage")[0])
                self.openurl(url, newtab=True)
            elif last_close == "default-page":
                url = config.get("general", "default-page")
                self.openurl(url, newtab=True)

    def search(self, text="", reverse=False):
        """Search for a text on the current page. With no text, clear results.

        Args:
            text: The text to search for.
            reverse: Reverse search direction.
        """
        view = self._current_widget()
        if view.search_text is not None and view.search_text != text:
            # We first clear the marked text, then the highlights
            view.search('', 0)
            view.search('', QWebPage.HighlightAllOccurrences)

        flags = 0
        ignore_case = config.get('general', 'ignore-case')
        if ignore_case == 'smart':
            if not text.islower():
                flags |= QWebPage.FindCaseSensitively
        elif not ignore_case:
            flags |= QWebPage.FindCaseSensitively
        if config.get('general', 'wrap-search'):
            flags |= QWebPage.FindWrapsAroundDocument
        if reverse:
            flags |= QWebPage.FindBackward
        # We actually search *twice* - once to highlight everything, then again
        # to get a mark so we can navigate.
        view.search(text, flags)
        view.search(text, flags | QWebPage.HighlightAllOccurrences)
        view.search_text = text
        view.search_flags = flags

    def _hint_strings(self, elems):
        """Calculate the hint strings for elems.

        Inspired by Vimium.

        Args:
            elems: The elements to get hint strings for.

        Return:
            A list of hint strings, in the same order as the elements.
        """
        if not elems:
            return []
        hint_mode = self._context.hint_mode
        if hint_mode == "word":
            try:
                return self._word_hinter.hint(elems)
            except HintingError as e:
                message.error(str(e))
                # falls back on letter hints
        if hint_mode == "number":
            chars = "0123456789"
        else:
            chars = config.get("hints", "chars")
        min_chars = config.get("hints", "min-chars")
        if config.get("hints", "scatter") and hint_mode != "number":
            return self._hint_scattered(min_chars, chars, elems)
        else:
            return self._hint_linear(min_chars, chars, elems)

def _get_search_url(txt):
    """Get a search engine URL for a text.

    Args:
        txt: Text to search for.

    Return:
        The search URL as a QUrl.
    """
    log.url.debug("Finding search engine for '{}'".format(txt))
    r = re.compile(r'(^\w+)\s+(.+)($|\s+)')
    m = r.search(txt)
    if m:
        engine = m.group(1)
        try:
            template = config.get('searchengines', engine)
        except configexc.NoOptionError:
            template = config.get('searchengines', 'DEFAULT')
            term = txt
        else:
            term = m.group(2).rstrip()
            log.url.debug("engine {}, term '{}'".format(engine, term))
    else:
        template = config.get('searchengines', 'DEFAULT')
        term = txt
        log.url.debug("engine: default, term '{}'".format(txt))
    if not term:
        raise FuzzyUrlError("No search term given")
    url = qurl_from_user_input(template.format(urllib.parse.quote(term)))
    qtutils.ensure_valid(url)
    return url