BufferScroll.py

import sublime, sublime_plugin
from os.path import lexists, normpath, dirname
from os import makedirs, remove, rename
from hashlib import sha1
from gzip import GzipFile
from collections import OrderedDict
import _thread as thread
import threading

try:
    from cPickle import load, dump
except:
    from pickle import load, dump

import time
from os.path import basename

# import inspect
debug = {}
database = {}
Pref = {}
BufferScrollAPI = {}
db = OrderedDict()
s = {}
already_restored = {}
scroll_already_restored = {}
last_focused_view_name = ""
last_focused_goto_definition = False


def print_debug(*msg):
    if debug:
        print("BufferScroll: " + str(msg))


def print_line():
    if debug:
        print("-" * 100)


def plugin_loaded():

    global debug, database, Pref, BufferScrollAPI, db, s
    debug = False

    # open
    db = OrderedDict()
    database = dirname(sublime.packages_path()) + "/Settings/BufferScroll.bin.gz"
    try:
        makedirs(dirname(database))
    except:
        pass
    try:
        gz = GzipFile(database, "rb")
        db = load(gz)
        gz.close()
        if not isinstance(db, OrderedDict):
            db = OrderedDict(db)
    except:
        db = OrderedDict()

    # settings
    s = sublime.load_settings("BufferScroll.sublime-settings")
    Pref = Pref()
    Pref.load()
    s.clear_on_change("reload")
    s.add_on_change("reload", lambda: Pref.load())

    BufferScrollAPI = BufferScroll()

    BufferScrollAPI.init_()

    # threads listening scroll, and waiting to set data on focus change
    if not "running_synch_data_loop" in globals():
        global running_synch_data_loop
        running_synch_data_loop = True
        thread.start_new_thread(synch_data_loop, ())

    if not "running_synch_scroll_loop" in globals():
        global running_synch_scroll_loop
        running_synch_scroll_loop = True
        thread.start_new_thread(synch_scroll_loop, ())


class Pref:
    def load(self):
        global debug
        Pref.remember_color_scheme = s.get("remember_color_scheme", False)
        Pref.remember_syntax = s.get("remember_syntax", False)
        Pref.synch_bookmarks = s.get("synch_bookmarks", False)
        Pref.synch_marks = s.get("synch_marks", False)
        Pref.synch_folds = s.get("synch_folds", False)
        Pref.synch_scroll = s.get("synch_scroll", False)
        Pref.typewriter_scrolling = s.get("typewriter_scrolling", False)
        Pref.typewriter_scrolling_shift = int(s.get("typewriter_scrolling_shift", 0))
        Pref.typewriter_scrolling_follow_cursor_movement = s.get(
            "typewriter_scrolling_follow_cursor_movement", True
        )
        Pref.use_animations = s.get("use_animations", False)
        Pref.i_use_cloned_views = s.get("i_use_cloned_views", False)
        Pref.max_database_records = s.get("max_database_records", 500)
        Pref.restore_scroll = s.get("restore_scroll", True)
        Pref.remember_settings_list = s.get("remember_settings_list", [])

        Pref.current_view_id = -1

        Pref.synch_data_running = False
        Pref.synch_scroll_running = False
        Pref.synch_scroll_last_view_id = 0
        Pref.synch_scroll_last_view_position = 0
        Pref.synch_scroll_current_view_object = None
        Pref.writing_to_disk = False
        version = 7
        debug = s.get("debug", False)
        version_current = s.get("version")
        if version_current != version:
            s.set("version", version)
            sublime.save_settings("BufferScroll.sublime-settings")

    # syntax specific settings
    def get(self, type, view):
        if view.settings().has("bs_sintax"):
            syntax = view.settings().get("bs_sintax")
        else:
            syntax = view.settings().get("syntax")
            syntax = (
                basename(syntax).split(".")[0].lower()
                if syntax != None
                else "plain text"
            )
            view.settings().set("bs_sintax", syntax)

        if hasattr(Pref, syntax) and type in getattr(Pref, syntax):
            return getattr(Pref, syntax)[type]
        elif hasattr(Pref, syntax) and type not in getattr(Pref, syntax):
            return getattr(Pref, type)
        elif s.has(syntax):
            setattr(Pref, syntax, s.get(syntax))
            self.get(type, view)
        else:
            return getattr(Pref, type)


class BufferScrollSaveThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        if not Pref.writing_to_disk:
            Pref.writing_to_disk = True

            print_line()
            print_debug("WRITING TO DISK")
            start = time.time()

            while len(db) > Pref.max_database_records:
                db.popitem(last=False)

            gz = GzipFile(database + ".tmp", "wb")
            dump(db, gz, -1)
            gz.close()
            try:
                remove(database)
            except:
                pass
            try:
                rename(database + ".tmp", database)
            except:
                pass

            print_debug("time expend writting to disk", time.time() - start)
            Pref.writing_to_disk = False


class BufferScroll(sublime_plugin.EventListener):
    def init_(self):
        # ST BUG https://github.com/SublimeTextIssues/Core/issues/5
        # the application is not sending on_load when opening/restoring a window,
        # then there is this hack which will simulate or synthesize an on_load when you open the application
        # since this is just a hack, there is a terrible noticeable delay, which just sucks
        self.on_load(sublime.active_window().active_view())
        for window in sublime.windows():
            for view in reversed(window.views()):
                self.on_load(view)
        for window in sublime.windows():
            self.on_load(window.active_view())
            self.restore_scroll(window.active_view())

    # restore on load for new opened tabs or previews.
    def on_load(self, view):
        self.restore(view, "on_load")

    # ST BUG tps://github.com/SublimeTextIssues/Core/issues/9
    def on_reload(self, view):
        self.restore(view, "on_reload")

    # restore on load for cloned views
    def on_clone(self, view):
        # ST BUG https://github.com/SublimeTextIssues/Core/issues/8
        self.restore(sublime.active_window().active_view(), "on_clone")

    # save data on focus lost
    def on_deactivated(self, view):
        global last_focused_view_name
        last_focused_view_name = (
            view.name()
            + "-"
            + str(view.file_name())
            + "-"
            + str(view.settings().get("is_widget"))
        )

        # ST BUG https://github.com/SublimeTextIssues/Core/issues/10
        # unable to flush when the application is closed
        # ST BUG https://github.com/SublimeTextIssues/Core/issues/181
        # the application is not sending "on_close" event when closings
        # or switching the projects, then we need to save the data on focus lost

        window = view.window()
        if not window:
            window = sublime.active_window()
        index = window.get_view_index(view)
        if index != (-1, -1):  # if the view was not closed
            self.save(view, "on_deactivated")
            self.synch_data(view)

    # track the current_view. See next event listener
    def on_activated(self, view):

        global already_restored
        window = view.window()
        if not window:
            window = sublime.active_window()
        view = window.active_view()
        if not view.settings().get("is_widget"):
            Pref.current_view_id = view.id()
            Pref.synch_scroll_current_view_object = view
        if view.id() not in already_restored:
            self.restore(view, "on_activated")
        if view.id() not in scroll_already_restored:
            self.restore_scroll(view)

    # save the data when background tabs are closed
    # these that don't receive "on_deactivated"
    # on_pre_close does not have a "get_view_index" ?
    def on_pre_close(self, view):
        self.save(view, "on_pre_close")

    # save data for focused tab when saving
    def on_pre_save(self, view):
        self.save(view, "on_pre_save")

    # typewriter scrolling
    def on_modified(self, view):
        if (
            not view.settings().get("is_widget")
            and not view.is_scratch()
            and len(view.sel()) == 1
            and Pref.get("typewriter_scrolling", view)
        ):
            # TODO STBUG if the view is in a column, for some reason the parameter view, is not correct. This fix it
            window = view.window()
            if not window:
                window = sublime.active_window()
            view = window.active_view()

            print_line()
            print_debug("TYPEWRITER_SCROLLING")
            line, col = view.rowcol(view.sel()[0].b)
            line = line - Pref.typewriter_scrolling_shift
            if line < 1:
                line = 0
            point = view.text_point(line, col)
            position_prev = view.viewport_position()  # save the horizontal scroll
            view.show_at_center(point)
            position_next = view.viewport_position()  # restore the horizontal scroll
            view.set_viewport_position((position_prev[0], position_next[1]))

    # saving
    def save(self, view, where="unknow"):
        if view is None or not view.file_name() or view.settings().get("is_widget"):
            return

        if view.is_loading():
            sublime.set_timeout(lambda: self.save(view, where), 0)
        else:

            id, index = self.view_id(view)

            print_line()
            print_debug("SAVE() ")
            print_debug("from: " + where)
            print_debug("file: " + view.file_name())
            print_debug("id: " + id)
            print_debug("position: " + index)

            # creates an object for this view, if it is unknow to the package
            if id not in db:
                db[id] = {}

            # if the result of the new collected data is different
            # from the old data, then will write to disk
            # this will hold the old value for comparation
            old_db = dict(db[id])

            # if the size of the view change outside the application skip restoration
            # if not we will restore folds in funny positions, etc...
            db[id]["id"] = int(view.size())

            # scroll
            if "l" not in db[id]:
                db[id]["l"] = {}
            # save the scroll with "index" as the id ( for cloned views )
            db[id]["l"][index] = list(view.viewport_position())
            # also save as default if no exists
            if index != "0":
                db[id]["l"]["0"] = list(view.viewport_position())
            print_debug("viewport_position: " + str(db[id]["l"]["0"]))

            # selections
            db[id]["s"] = [[item.a, item.b] for item in view.sel()]
            print_debug("selections: " + str(db[id]["s"]))

            # marks
            db[id]["m"] = [[item.a, item.b] for item in view.get_regions("mark")]
            print_debug("marks: " + str(db[id]["m"]))

            # bookmarks
            db[id]["b"] = [[item.a, item.b] for item in view.get_regions("bookmarks")]
            print_debug("bookmarks: " + str(db[id]["b"]))

            # previous folding save, to be able to refold
            if "f" in db[id] and list(db[id]["f"]) != []:
                db[id]["pf"] = list(db[id]["f"])

            # folding
            db[id]["f"] = [[item.a, item.b] for item in view.folded_regions()]
            print_debug("fold: " + str(db[id]["f"]))

            # color_scheme http://www.sublimetext.com/forum/viewtopic.php?p=25624#p25624
            if Pref.get("remember_color_scheme", view):
                db[id]["c"] = view.settings().get("color_scheme")
                print_debug("color_scheme: " + str(db[id]["c"]))

            # syntax
            if Pref.get("remember_syntax", view):
                db[id]["x"] = view.settings().get("syntax")
                print_debug("syntax: " + str(db[id]["x"]))

            # settings list
            settings = Pref.get("remember_settings_list", view)
            db[id]["p"] = []
            for item in settings:
                if item:
                    value = view.settings().get(item, "waaaaaa")
                    if value != "waaaaaa":
                        db[id]["p"].append({"k": item, "v": value})

            # write to disk only if something changed
            if old_db != db[id] or where == "on_deactivated":
                db.move_to_end(id)
                BufferScrollSaveThread().start()

    def view_id(self, view):
        if not view.settings().has("buffer_scroll_name"):
            view.settings().set(
                "buffer_scroll_name",
                sha1(normpath(str(view.file_name()).encode("utf-8"))).hexdigest()[:8],
            )
        return (view.settings().get("buffer_scroll_name"), self.view_index(view))

    def view_index(self, view):
        window = view.window()
        if not window:
            window = sublime.active_window()
        index = window.get_view_index(view)
        return str(window.id()) + str(index)

    def restore_scroll(self, view, where="unknow"):
        global scroll_already_restored, last_focused_view_name, last_focused_goto_definition
        if (
            view is None
            or not view.file_name()
            or view.settings().get("is_widget")
            or view.id() in scroll_already_restored
            or view not in sublime.active_window().views()
        ):
            return

        if view.is_loading():
            sublime.set_timeout(lambda: self.restore_scroll(view, where), 0)
        else:
            scroll_already_restored[view.id()] = True
            if (
                last_focused_view_name == "-None-None"
                or last_focused_view_name == "None"
                or last_focused_view_name == "Find Results-None-None"
                or last_focused_goto_definition
                or last_focused_view_name.endswith("-True")
            ):
                last_focused_goto_definition = False
            else:
                id, index = self.view_id(view)

                print_line()
                print_debug("RESTORE_SCROLL()")
                print_debug("from: " + where)
                print_debug("last_focused_view_name: " + last_focused_view_name)
                print_debug("file: " + view.file_name())
                print_debug("id: " + id)
                print_debug("position: " + index)

                if id in db and Pref.get("restore_scroll", view):
                    print_debug("DOING...")
                    # scroll
                    if Pref.get("i_use_cloned_views", view) and index in db[id]["l"]:
                        position = tuple(db[id]["l"][index])
                        view.set_viewport_position(position, Pref.use_animations)
                    else:
                        position = tuple(db[id]["l"]["0"])
                        view.set_viewport_position(position, Pref.use_animations)
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    # ugly hack
                    sublime.set_timeout(lambda: self.stupid_scroll(view, position), 0)

                    print_debug("scroll set: " + str(position))
                    print_debug(
                        "supposed current scroll: " + str(view.viewport_position())
                    )
                    # THIS LIES
                else:
                    print_debug("SKIPPED...")

    def restore(self, view, where="unknow"):
        global already_restored

        if (
            view is None
            or not view.file_name()
            or view.settings().get("is_widget")
            or view.id() in already_restored
        ):
            return

        if view.is_loading():
            sublime.set_timeout(lambda: self.restore(view, where), 0)
        else:
            already_restored[view.id()] = True
            id, index = self.view_id(view)

            print_line()
            print_debug("RESTORE()")
            print_debug("from: " + where)
            print_debug("last_focused_view_name: " + last_focused_view_name)
            print_debug("file: " + view.file_name())
            print_debug("id: " + id)
            print_debug("position: " + index)

            if id in db:
                print_debug("DOING...")

                # if the view changed outside of the application, don't restore folds etc
                if db[id]["id"] == int(view.size()):

                    # fold
                    rs = []
                    for r in db[id]["f"]:
                        rs.append(sublime.Region(int(r[0]), int(r[1])))
                    if len(rs):
                        view.fold(rs)
                        print_debug("fold: " + str(rs))

                    # selection
                    if len(db[id]["s"]) > 0:
                        view.sel().clear()
                        for r in db[id]["s"]:
                            view.sel().add(sublime.Region(int(r[0]), int(r[1])))
                        print_debug("selection: " + str(db[id]["s"]))

                    # marks
                    rs = []
                    for r in db[id]["m"]:
                        rs.append(sublime.Region(int(r[0]), int(r[1])))
                    if len(rs):
                        view.add_regions(
                            "mark",
                            rs,
                            "mark",
                            "dot",
                            sublime.HIDDEN | sublime.PERSISTENT,
                        )
                        print_debug("marks: " + str(db[id]["m"]))

                    # bookmarks
                    rs = []
                    for r in db[id]["b"]:
                        rs.append(sublime.Region(int(r[0]), int(r[1])))
                    if len(rs):
                        view.add_regions(
                            "bookmarks",
                            rs,
                            "bookmarks",
                            "bookmark",
                            sublime.HIDDEN | sublime.PERSISTENT,
                        )
                        print_debug("bookmarks: " + str(db[id]["b"]))

                # color scheme
                if (
                    Pref.get("remember_color_scheme", view)
                    and "c" in db[id]
                    and view.settings().get("color_scheme") != db[id]["c"]
                ):
                    view.settings().set("color_scheme", db[id]["c"])
                    print_debug("color scheme: " + str(db[id]["c"]))

                # syntax
                if (
                    Pref.get("remember_syntax", view)
                    and "x" in db[id]
                    and view.settings().get("syntax") != db[id]["x"]
                    and lexists(dirname(sublime.packages_path()) + "/" + db[id]["x"])
                ):
                    view.settings().set("syntax", db[id]["x"])
                    print_debug("syntax: " + str(db[id]["x"]))

                if "p" in db[id]:
                    for item in Pref.get("remember_settings_list", view):
                        for i in db[id]["p"]:
                            if "k" in i and i["k"] == item:
                                view.settings().set(i["k"], i["v"])
                                break

                # scroll
                if (
                    Pref.get("restore_scroll", view)
                    and Pref.get("i_use_cloned_views", view)
                    and index in db[id]["l"]
                ):
                    position = tuple(db[id]["l"][index])
                    view.set_viewport_position(position, Pref.use_animations)
                elif Pref.get("restore_scroll", view):
                    position = tuple(db[id]["l"]["0"])
                    view.set_viewport_position(position, Pref.use_animations)

                print_debug("scroll set: " + str(position))
                print_debug("supposed current scroll: " + str(view.viewport_position()))
                # THIS LIES
            else:
                print_debug("SKIPPED...")

    def stupid_scroll(self, view, position):
        view.set_viewport_position(position, Pref.use_animations)

    def print_stupid_scroll(self, view):
        print_debug("current scroll for: " + str(view.file_name()))
        print_debug("current scroll: " + str(view.viewport_position()))

    def synch_data(self, view=None, where="unknow"):
        if view is None:
            view = Pref.synch_scroll_current_view_object

        if view is None or view.settings().get("is_widget"):
            return

        # if there is something to synch
        if (
            not Pref.get("synch_bookmarks", view)
            and not Pref.get("synch_marks", view)
            and not Pref.get("synch_folds", view)
        ):
            return
        Pref.synch_data_running = True

        if view.is_loading():
            Pref.synch_data_running = False
            sublime.set_timeout(lambda: self.synch_data(view, where), 0)
        else:

            self.save(view, "synch")

            # if there is clones
            clones = []
            for window in sublime.windows():
                for _view in window.views():
                    if (
                        _view.buffer_id() == view.buffer_id()
                        and view.id() != _view.id()
                    ):
                        clones.append(_view)
            if not clones:
                Pref.synch_data_running = False
                return

            print_line()
            print_debug("SYNCH_DATA()")

            id, index = self.view_id(view)

            if Pref.get("synch_bookmarks", view):
                bookmarks = []
                for r in db[id]["b"]:
                    bookmarks.append(sublime.Region(int(r[0]), int(r[1])))

            if Pref.get("synch_marks", view):
                marks = []
                for r in db[id]["m"]:
                    marks.append(sublime.Region(int(r[0]), int(r[1])))

            if Pref.get("synch_folds", view):
                folds = []
                for r in db[id]["f"]:
                    folds.append(sublime.Region(int(r[0]), int(r[1])))

            for _view in clones:

                # bookmarks
                if Pref.get("synch_bookmarks", _view):
                    if bookmarks:
                        if bookmarks != _view.get_regions("bookmarks"):
                            _view.erase_regions("bookmarks")
                            print_debug("synching bookmarks")
                            _view.add_regions(
                                "bookmarks",
                                bookmarks,
                                "bookmarks",
                                "bookmark",
                                sublime.HIDDEN | sublime.PERSISTENT,
                            )
                        else:
                            print_debug("skipping synch of bookmarks these are equal")
                    else:
                        _view.erase_regions("bookmarks")

                # marks
                if Pref.get("synch_marks", _view):
                    if marks:
                        if marks != _view.get_regions("mark"):
                            _view.erase_regions("mark")
                            print_debug("synching marks")
                            _view.add_regions(
                                "mark",
                                marks,
                                "mark",
                                "dot",
                                sublime.HIDDEN | sublime.PERSISTENT,
                            )
                        else:
                            print_debug("skipping synch of marks these are equal")
                    else:
                        _view.erase_regions("mark")

                # folds
                if Pref.get("synch_folds", _view):
                    if folds:
                        if folds != _view.folded_regions():
                            print_debug("synching folds")
                            _view.unfold(sublime.Region(0, _view.size()))
                            _view.fold(folds)
                        else:
                            print_debug("skipping synch of folds these are equal")
                    else:
                        _view.unfold(sublime.Region(0, _view.size()))

        Pref.synch_data_running = False

    def synch_scroll(self):

        Pref.synch_scroll_running = True

        # find current view
        view = Pref.synch_scroll_current_view_object
        if view is None or view.is_loading() or not Pref.get("synch_scroll", view):
            Pref.synch_scroll_running = False
            return

        # if something changed
        if Pref.synch_scroll_last_view_id != Pref.current_view_id:
            Pref.synch_scroll_last_view_id = Pref.current_view_id
            Pref.synch_scroll_last_view_position = 0
        last_view_position = str(
            [view.visible_region(), view.viewport_position(), view.viewport_extent()]
        )
        if Pref.synch_scroll_last_view_position == last_view_position:
            Pref.synch_scroll_running = False
            return
        Pref.synch_scroll_last_view_position = last_view_position

        # if there is clones
        clones = {}
        clones_positions = []
        for window in sublime.windows():
            for _view in window.views():
                if (
                    not _view.is_loading()
                    and _view.buffer_id() == view.buffer_id()
                    and view.id() != _view.id()
                ):
                    id, index = self.view_id(_view)
                    clones[index] = _view
                    clones_positions.append(index)
        if not clones_positions:
            Pref.synch_scroll_running = False
            return

        print_line()
        print_debug("SYNCH_SCROLL()")

        # current view
        id, index = self.view_id(view)

        # append current view to list of clones
        clones[index] = view
        clones_positions.append(index)
        clones_positions.sort()

        # find current view index
        i = [i for i, x in enumerate(clones_positions) if x == index][0]

        lenght = len(clones_positions)
        line = view.line_height()
        # synch scroll for views to the left
        b = i - 1
        previous_view = view
        while b > -1:
            current_view = clones[clones_positions[b]]
            ppl, ppt = current_view.text_to_layout(
                previous_view.line(previous_view.visible_region().a).b
            )
            cpw, cph = current_view.viewport_extent()
            left, old_top = current_view.viewport_position()
            top = (ppt - cph) + line
            if abs(old_top - top) >= line:
                current_view.set_viewport_position((left, top), Pref.use_animations)
            previous_view = current_view
            b -= 1

        # synch scroll for views to the right
        i += 1
        previous_view = view
        while i < lenght:
            current_view = clones[clones_positions[i]]
            top = current_view.text_to_layout(
                previous_view.line(previous_view.visible_region().b).a
            )
            left, old_top = current_view.viewport_position()
            top = (
                top[1] - 3
            )  # 3 is the approximated height of the shadow of the tabbar. Removing the shadow Makes the text more readable
            if abs(old_top - top) >= line:
                current_view.set_viewport_position((left, top), Pref.use_animations)
            previous_view = current_view
            i += 1

        Pref.synch_scroll_running = False


class BufferScrollForget(sublime_plugin.ApplicationCommand):
    def run(self, what):
        if what == "color_scheme":
            sublime.active_window().active_view().settings().erase("color_scheme")


class BufferScrollReFold(sublime_plugin.WindowCommand):
    def run(self):
        view = sublime.active_window().active_view()
        if view is not None:
            id, index = BufferScrollAPI.view_id(view)
            if id in db:
                if "pf" in db[id]:
                    rs = []
                    for r in db[id]["pf"]:
                        rs.append(sublime.Region(int(r[0]), int(r[1])))
                    if len(rs):
                        view.fold(rs)

                    # update the minimap
                    position = view.viewport_position()
                    view.set_viewport_position(
                        (position[0] - 1, position[1] - 1), Pref.use_animations
                    )
                    view.set_viewport_position(position, Pref.use_animations)

    def is_enabled(self):
        view = sublime.active_window().active_view()
        if view is not None and view.file_name():
            id, index = BufferScrollAPI.view_id(view)
            if id in db:
                if "pf" in db[id] and len(db[id]["pf"]):
                    return True
        return False


class BufferScrollFoldSelectFolded(sublime_plugin.WindowCommand):
    def run(self):
        view = sublime.active_window().active_view()
        if view is not None:
            folds = [[item.a, item.b] for item in view.folded_regions()]
            if folds:
                view.sel().clear()
                for fold in folds:
                    view.sel().add(sublime.Region(int(fold[0]), int(fold[1])))


class BufferScrollFoldSelectUnfolded(sublime_plugin.WindowCommand):
    def run(self):
        view = sublime.active_window().active_view()
        folds = [[item.a, item.b] for item in view.folded_regions()]
        if folds:
            view.sel().clear()
            prev = 0
            for fold in folds:
                view.sel().add(sublime.Region(prev, int(fold[0])))
                if view.substr(fold[1]) == "\n":
                    prev = int(fold[1]) + 1
                else:
                    prev = int(fold[1])
            view.sel().add(sublime.Region(prev, view.size()))


def synch_scroll_loop():
    synch_scroll = BufferScrollAPI.synch_scroll
    while True:
        if not Pref.synch_scroll_running:
            Pref.synch_scroll_running = True
            sublime.set_timeout(lambda: synch_scroll(), 0)
        time.sleep(0.08)


def synch_data_loop():
    synch_data = BufferScrollAPI.synch_data
    while True:
        if not Pref.synch_data_running:
            sublime.set_timeout(lambda: synch_data(None, "thread"), 0)
        time.sleep(0.5)


class BufferScrollListener(sublime_plugin.EventListener):
    def on_text_command(self, view, command_name, args):
        global last_focused_view_name, last_focused_goto_definition
        if (
            command_name == "goto_definition"
            or command_name == "navigate_to_definition"
        ):
            last_focused_view_name = "None"
            last_focused_goto_definition = True

    def on_window_command(self, window, command_name, args):
        global last_focused_view_name, last_focused_goto_definition
        if (
            command_name == "goto_definition"
            or command_name == "navigate_to_definition"
        ):
            last_focused_view_name = "None"
            last_focused_goto_definition = True

    def on_post_text_command(self, view, command_name, args):
        # typewriter_scrolling
        if (command_name == "move" or command_name == "move_to") and Pref.get(
            "typewriter_scrolling_follow_cursor_movement", view
        ):
            BufferScrollAPI.on_modified(view)

    def on_post_window_command(self, window, command_name, args):
        pass