Python message.warning函数代码示例

def message_warning(text):
    """Show a warning message in the statusbar.

    Args:
        text: The text to show.
    """
    message.warning(text)

    def _check_prerequisites(self, win_id):
        """Check if the command is permitted to run currently.

        Args:
            win_id: The window ID the command is run in.
        """
        mode_manager = objreg.get('mode-manager', scope='window',
                                  window=win_id)
        curmode = mode_manager.mode
        if self._modes is not None and curmode not in self._modes:
            mode_names = '/'.join(mode.name for mode in self._modes)
            raise cmdexc.PrerequisitesError(
                "{}: This command is only allowed in {} mode.".format(
                    self.name, mode_names))
        elif self._not_modes is not None and curmode in self._not_modes:
            mode_names = '/'.join(mode.name for mode in self._not_modes)
            raise cmdexc.PrerequisitesError(
                "{}: This command is not allowed in {} mode.".format(
                    self.name, mode_names))
        if self._needs_js and not QWebSettings.globalSettings().testAttribute(
                QWebSettings.JavascriptEnabled):
            raise cmdexc.PrerequisitesError(
                "{}: This command needs javascript enabled.".format(self.name))
        if self.deprecated:
            message.warning(win_id, '{} is deprecated - {}'.format(
                self.name, self.deprecated))

 def _find_installed(self, code):
     local_filename = spell.local_filename(code)
     if not local_filename:
         message.warning(
             "Language {} is not installed - see scripts/dictcli.py "
             "in qutebrowser's sources".format(code))
     return local_filename

    def _check_prerequisites(self, win_id):
        """Check if the command is permitted to run currently.

        Args:
            win_id: The window ID the command is run in.
        """
        mode_manager = objreg.get("mode-manager", scope="window", window=win_id)
        curmode = mode_manager.mode
        if self._modes is not None and curmode not in self._modes:
            mode_names = "/".join(mode.name for mode in self._modes)
            raise cmdexc.PrerequisitesError(
                "{}: This command is only allowed in {} mode.".format(self.name, mode_names)
            )
        elif self._not_modes is not None and curmode in self._not_modes:
            mode_names = "/".join(mode.name for mode in self._not_modes)
            raise cmdexc.PrerequisitesError("{}: This command is not allowed in {} mode.".format(self.name, mode_names))

        used_backend = usertypes.arg2backend[objreg.get("args").backend]
        if self.backend is not None and used_backend != self.backend:
            raise cmdexc.PrerequisitesError(
                "{}: Only available with {} " "backend.".format(self.name, self.backend.name)
            )

        if self.deprecated:
            message.warning(win_id, "{} is deprecated - {}".format(self.name, self.deprecated))

 def _find_installed(self, code):
     installed_file = spell.installed_file(code)
     if not installed_file:
         message.warning(
             "Language {} is not installed - see scripts/install_dict.py "
             "in qutebrowser's sources".format(code))
     return installed_file

def version(filename):
    """Extract the version number from the dictionary file name."""
    match = dict_version_re.match(filename)
    if match is None:
        message.warning(
            "Found a dictionary with a malformed name: {}".format(filename))
        return None
    return tuple(int(n) for n in match.group('version').split('-'))

def _set_dictionary_language(profile, warn=True):
    filenames = []
    for code in config.val.spellcheck.languages or []:
        local_filename = spell.local_filename(code)
        if not local_filename:
            if warn:
                message.warning(
                    "Language {} is not installed - see scripts/dictcli.py "
                    "in qutebrowser's sources".format(code))
            continue

        filenames.append(local_filename)

    log.config.debug("Found dicts: {}".format(filenames))
    profile.setSpellCheckLanguages(filenames)

    def set_dictionary_language(self, warn=True):
        """Load the given dictionaries."""
        filenames = []
        for code in config.val.spellcheck.languages or []:
            local_filename = spell.local_filename(code)
            if not local_filename:
                if warn:
                    message.warning("Language {} is not installed - see "
                                    "scripts/dictcli.py in qutebrowser's "
                                    "sources".format(code))
                continue

            filenames.append(local_filename)

        log.config.debug("Found dicts: {}".format(filenames))
        self._profile.setSpellCheckLanguages(filenames)
        self._profile.setSpellCheckEnabled(bool(filenames))

    def _check_prerequisites(self, win_id):
        """Check if the command is permitted to run currently.

        Args:
            win_id: The window ID the command is run in.
        """
        mode_manager = objreg.get('mode-manager', scope='window',
                                  window=win_id)
        self.validate_mode(mode_manager.mode)

        if self.backend is not None and objects.backend != self.backend:
            raise cmdexc.PrerequisitesError(
                "{}: Only available with {} "
                "backend.".format(self.name, self.backend.name))

        if self.deprecated:
            message.warning('{} is deprecated - {}'.format(self.name,
                                                           self.deprecated))

    def search(self, text, flags):
        """Search for text in the current page.

        Args:
            text: The text to search for.
            flags: The QWebPage::FindFlags.
        """
        log.webview.debug("Searching with text '{}' and flags "
                          "0x{:04x}.".format(text, int(flags)))
        old_scroll_pos = self.scroll_pos
        flags = QWebPage.FindFlags(flags)
        found = self.findText(text, flags)
        backward = flags & QWebPage.FindBackward

        if not found and not flags & QWebPage.HighlightAllOccurrences and text:
            # User disabled wrapping; but findText() just returns False. If we
            # have a selection, we know there's a match *somewhere* on the page
            if (not flags & QWebPage.FindWrapsAroundDocument and
                    self.hasSelection()):
                if not backward:
                    message.warning(self.win_id, "Search hit BOTTOM without "
                                    "match for: {}".format(text),
                                    immediately=True)
                else:
                    message.warning(self.win_id, "Search hit TOP without "
                                    "match for: {}".format(text),
                                    immediately=True)
            else:
                message.error(self.win_id, "Text '{}' not found on "
                              "page!".format(text), immediately=True)
        else:
            def check_scroll_pos():
                """Check if the scroll position got smaller and show info."""
                if not backward and self.scroll_pos < old_scroll_pos:
                    message.info(self.win_id, "Search hit BOTTOM, continuing "
                                 "at TOP", immediately=True)
                elif backward and self.scroll_pos > old_scroll_pos:
                    message.info(self.win_id, "Search hit TOP, continuing at "
                                 "BOTTOM", immediately=True)
            # We first want QWebPage to refresh.
            QTimer.singleShot(0, check_scroll_pos)

    def download_remove(self, all_=False, count=0):
        """Remove the last/[count]th download from the list.

        Args:
            all_: Deprecated argument for removing all finished downloads.
            count: The index of the download to cancel.
        """
        if all_:
            message.warning(self._win_id, ":download-remove --all is "
                            "deprecated - use :download-clear instead!")
            self.download_clear()
        else:
            try:
                download = self.downloads[count - 1]
            except IndexError:
                self.raise_no_download(count)
            if not download.done:
                if not count:
                    count = len(self.downloads)
                raise cmdexc.CommandError("Download {} is not done!"
                                          .format(count))
            self.remove_item(download)

    def _handle_old_rapid_targets(self, win_id):
        """Switch to the new way for rapid hinting with a rapid target.

        Args:
            win_id: The window ID to display the warning in.

        DEPRECATED.
        """
        old_rapid_targets = {
            Target.rapid: Target.tab_bg,
            Target.rapid_win: Target.window,
        }
        target = self._context.target
        if target in old_rapid_targets:
            self._context.target = old_rapid_targets[target]
            self._context.rapid = True
            name = target.name.replace('_', '-')
            group_name = self._context.group.name.replace('_', '-')
            new_name = self._context.target.name.replace('_', '-')
            message.warning(
                win_id, ':hint with target {} is deprecated, use :hint '
                '--rapid {} {} instead!'.format(name, group_name, new_name))

    def _check_prerequisites(self, win_id):
        """Check if the command is permitted to run currently.

        Args:
            win_id: The window ID the command is run in.
        """
        mode_manager = objreg.get('mode-manager', scope='window',
                                  window=win_id)
        curmode = mode_manager.mode
        if self._modes is not None and curmode not in self._modes:
            mode_names = '/'.join(mode.name for mode in self._modes)
            raise cmdexc.PrerequisitesError(
                "{}: This command is only allowed in {} mode.".format(
                    self.name, mode_names))
        elif self._not_modes is not None and curmode in self._not_modes:
            mode_names = '/'.join(mode.name for mode in self._not_modes)
            raise cmdexc.PrerequisitesError(
                "{}: This command is not allowed in {} mode.".format(
                    self.name, mode_names))

        if self._needs_js and not QWebSettings.globalSettings().testAttribute(
                QWebSettings.JavascriptEnabled):
            raise cmdexc.PrerequisitesError(
                "{}: This command needs javascript enabled.".format(self.name))

        backend_mapping = {
            'webkit': usertypes.Backend.QtWebKit,
            'webengine': usertypes.Backend.QtWebEngine,
        }
        used_backend = backend_mapping[objreg.get('args').backend]
        if self.backend is not None and used_backend != self.backend:
            raise cmdexc.PrerequisitesError(
                "{}: Only available with {} "
                "backend.".format(self.name, self.backend.name))

        if self.deprecated:
            message.warning(win_id, '{} is deprecated - {}'.format(
                self.name, self.deprecated))

    def _check_prerequisites(self, win_id, count):
        """Check if the command is permitted to run currently.

        Args:
            win_id: The window ID the command is run in.
        """
        mode_manager = objreg.get('mode-manager', scope='window',
                                  window=win_id)
        self.validate_mode(mode_manager.mode)

        used_backend = usertypes.arg2backend[objreg.get('args').backend]
        if self.backend is not None and used_backend != self.backend:
            raise cmdexc.PrerequisitesError(
                "{}: Only available with {} "
                "backend.".format(self.name, self.backend.name))

        if count == 0 and not self._zero_count:
            raise cmdexc.PrerequisitesError(
                "{}: A zero count is not allowed for this command!"
                .format(self.name))

        if self.deprecated:
            message.warning('{} is deprecated - {}'.format(self.name,
                                                           self.deprecated))