def run(self, edit):
        SpellChecker.reload()
        try:
            errs = const.spell_error_regions[self.view.id()]
        except KeyError:
            sublime.status_message("Document has not been checked.")
            return
        errs = sorted(errs, key=lambda e: e.a)
        try:
            self.checker = SpellChecker.get_checker(self.view.id())
        except KeyError:
            sublime.status_message("Document has not been checked.")
            return

        if self.checker.orthography.dominantLanguage() == "und":
            sublime.status_message("Language could not be determined.")
            return
        if not len(errs):
            sublime.status_message("No errors!")
            return

        self.offset = 0
        self.reset = 0
        self.i = 0
        self.forward = True
        self.ignored = []

        pos = self.view.sel()[0].a
        # self.view.sel().clear()
        start = 0
        for j in range(len(errs)):
            if errs[j].contains(pos):
                start = j
                break

            b = errs[j].b
            try:
                x = errs[j + 1].a
            except IndexError:
                break

            if b < pos < x:
                start = j + 1
                break
        self.start = start
        end_chunk = errs[start:]
        beginning_chunk = errs[:start]
        self.chunks = []
        if not beginning_chunk == end_chunk:
            self.chunks.extend(end_chunk)
            self.chunks.extend(beginning_chunk)
        else:
            self.chunks = errs

        self.get_next_error(0, next=False)
    def hit(self, view):
        if not ST3:
            self.check(view.id())

        self.checked.add(view.id())
        if view.size() == 0:
            c = SpellChecker.get_checker(view.id())
            if c:
                c.clear()
            SpellChecker.reload()
            sublime.set_timeout(lambda: view.erase_status('checkbounce'), 0)
            return

        const.spell_queue.hit(view)