Layout.py

import os
import json
import sublime
import sublime_plugin


PLUGIN_NAME = 'Layout'
PLUGIN_PATH = os.path.join(sublime.packages_path(), PLUGIN_NAME)
LAYOUTS_PATH = os.path.join(PLUGIN_PATH, 'layouts')

X_MIN, Y_MIN, X_MAX, Y_MAX = (0, 1, 2, 3)


def plugin_loaded():
    if not os.path.isdir(LAYOUTS_PATH):
        os.makedirs(LAYOUTS_PATH)


def Settings():
    return sublime.load_settings('%s.sublime-settings' % PLUGIN_NAME)


class PaneCommand(sublime_plugin.WindowCommand):
    @property
    def layout(self):
        return self.window.get_layout()

    @property
    def cells(self):
        return self.window.get_layout()['cells']

    @property
    def current_group(self):
        return self.window.active_group()

    @classmethod
    def get_layout_path(cls, filename):
        return os.path.join(LAYOUTS_PATH, filename + '.layout')

    def fixed_set_layout(self, layout):
        # A bug was introduced in Sublime Text 3, sometime before 3053,
        # in that it changes the active group to 0 when the layout is changed.
        group = min(self.current_group, self.window.num_groups() - 1)
        self.window.set_layout(layout)
        self.fixed_focus_group(group)

    def fixed_focus_group(self, group):
        # I have no idea why this is work instead of
        # `self.window.focus_group(group)`
        sublime.set_timeout(lambda : self.window.focus_group(group), 0)
        sublime.set_timeout(lambda : self.window.focus_group(group), 0)

    def layout_to_json(self):
        layout = self.layout
        layout['views_in_group'] = []
        layout['active_group'] = self.current_group

        def view_to_jsonable(view):
            return dict(
                file_name=view.file_name(),
                name=view.name(),
                is_read_only=view.is_read_only(),
                is_scratch=view.is_scratch()
            )

        for i in range(len(layout['cells'])):
            views = self.window.views_in_group(i)
            views = [view_to_jsonable(view) for view in views]
            layout['views_in_group'].append(views)

        return json.dumps(layout, indent=2)

    def load_layout_from_json(self, layout):
        layout = json.loads(layout)
        self.fixed_set_layout(layout)

        def dict_to_view(view_dict, group, index):
            view = self.window.open_file(view_dict['file_name'])
            view.set_scratch(view_dict['is_scratch'])
            view.set_name(view_dict['name'])
            view.set_read_only(view_dict['is_read_only'])
            self.window.set_view_index(view, group, index)
            return view

        for group in range(len(layout['cells'])):
            views = layout['views_in_group'][group]
            views = [dict_to_view(views[i], group, i) for i in range(len(views))]

        self.fixed_focus_group(0)

    def get_adjacent_cells(self, group):
        cells = self.cells
        adjacent_cells = {
            'left': [],
            'right': [],
            'up': [],
            'down': [],
        }
        c = cells.pop(group)
        x1, y1, x2, y2 = c[X_MIN], c[Y_MIN], c[X_MAX], c[Y_MAX]

        for ac in cells:
            direction = None
            ax1, ay1, ax2, ay2 = ac[X_MIN], ac[Y_MIN], ac[X_MAX], ac[Y_MAX]
            if (ax1 <= x1 < ax2) or (ax1 < x2 <= ax2):
                if y1 == ay2:
                    direction = 'up'
                elif y2 == ay1:
                    direction = 'down'
            if (ay1 <= y1 < ay2) or (ay1 < y2 <= ay2):
                if x1 == ax2:
                    direction = 'left'
                elif x2 == ax1:
                    direction = 'right'
            if direction:
                adjacent_cells[direction].append(ac)

        return adjacent_cells

    def layout_to_value_cells(self, layout):
        value_cells = []
        rows = layout['rows']
        cols = layout['cols']
        for x1, y1, x2, y2 in layout['cells']:
            value_cells.append([cols[x1], rows[y1], cols[x2], rows[y2]])
        return value_cells

    def value_cells_to_layout(self, value_cells):
        rows = set()
        cols = set()
        for c1, r1, c2, r2 in value_cells:
            cols.add(c1)
            rows.add(r1)
            cols.add(c2)
            rows.add(r2)
        cols = list(cols)
        rows = list(rows)
        cols.sort()
        rows.sort()

        max_x = 0
        cells = []
        for c1, r1, c2, r2 in value_cells:
            x1, y1, x2, y2 = cols.index(c1), rows.index(r1), cols.index(c2), rows.index(r2)
            cells.append([x1, y1, x2, y2])
            if max_x < x2:
                max_x = x2
        # cells arrange by y1 first then x1
        cells.sort(key=lambda c: c[Y_MIN] * (max_x + 1) + c[X_MIN])

        layout = {'cols': cols, 'rows': rows, 'cells': cells}
        return layout

    def resize_pane(self, group, direction, step):
        MIN_GAP = 0.15

        layout = self.layout
        rows = layout['rows']
        cols = layout['cols']
        cells = layout['cells']
        x1, y1, x2, y2 = cells[group]
        max_x, max_y = len(cols) - 1, len(rows) - 1

        # resize by adjust ruler
        if direction == 'left':
            # if is border
            if x1 == 0 and x2 == max_x:
                return
            # littler x
            lx = 0 if x1 - 1 < 0 else x1 - 1
            if x1 > 0 and cols[x1] - cols[lx] > MIN_GAP:
                cols[x1] -= step
            if x1 == 0 and cols[x2] - cols[x1] > MIN_GAP:
                cols[x2] -= step
        elif direction == 'right':
            if x2 == max_x and x1 == 0:
                return
            # greater x
            gx = 1 if x2 + 1 > max_x else x2 + 1
            if x2 < max_x and cols[gx] - cols[x2] > MIN_GAP:
                cols[x2] += step
            if x2 == max_x and cols[x2] - cols[x1] > MIN_GAP:
                cols[x1] += step
        elif direction == 'up':
            if y1 == 0 and y2 == max_y:
                return
            ly = 0 if y1 - 1 < 0 else y1 - 1
            if y1 > 0 and rows[y1] - rows[ly] > MIN_GAP:
                rows[y1] -= step
            if y1 == 0 and rows[y2] - rows[y1] > MIN_GAP:
                rows[y2] -= step
        elif direction == 'down':
            if y2 == max_y and y1 == 0:
                return
            gy = 1 if y2 + 1 > max_y else y2 + 1
            if y2 < max_y and rows[gy] - rows[y2] > MIN_GAP:
                rows[y2] += step
            if y2 == max_y and rows[y2] - rows[y1] > MIN_GAP:
                rows[y1] += step
        else:
            return
        layout = {'rows': rows, 'cols': cols, 'cells': cells}
        self.fixed_set_layout(layout)

    def split_pane(self, group, pattern, scale):
        rows = self.layout['rows']
        cols = self.layout['cols']
        coord_cells = self.layout['cells']

        try:
            # (x1, y1) is top left point, (x2, y2) is bottom right point
            x1, y1, x2, y2 = coord_cells.pop(group)
            c1, r1, c2, r2 = cols[x1], rows[y1], cols[x2], rows[y2]
        except:
            return
        value_cells = self.layout_to_value_cells({
            'rows': rows,
            'cols': cols,
            'cells': coord_cells
        })

        # vertical
        if pattern == 'v':
            c = (c2 - c1) * scale + c1
            old_cell = [c1, r1, c, r2]
            new_cell = [c, r1, c2, r2]
        # horizontal
        elif pattern == 'h':
            r = (r2 - r1) * scale + r1
            old_cell = [c1, r1, c2, r]
            new_cell = [c1, r, c2, r2]
        else:
            return

        value_cells.append(old_cell)
        value_cells.append(new_cell)
        layout = self.value_cells_to_layout(value_cells)
        self.fixed_set_layout(layout)

    def destroy_pane(self, group):
        layout = self.layout
        cells = layout['cells']
        try:
            x1, y1, x2, y2 = cells.pop(group)
        except:
            return
        adjacent_cells = self.get_adjacent_cells(group)
        adjacent_cells['left'].sort(key=lambda c: c[Y_MIN])
        adjacent_cells['right'].sort(key=lambda c: c[Y_MIN])
        adjacent_cells['up'].sort(key=lambda c: c[X_MIN])
        adjacent_cells['down'].sort(key=lambda c: c[X_MIN])

        extend_direction = None
        for dir, cs in adjacent_cells.items():
            if not cs:
                continue
            if ((y1 == cs[0][Y_MIN] and y2 == cs[-1][Y_MAX]) or
                    (x1 == cs[0][X_MIN] and x2 == cs[-1][X_MAX])):
                extend_direction = dir

        if extend_direction:
            pair = {
                'left': (X_MAX, x2),
                'right': (X_MIN, x1),
                'up': (Y_MAX, y2),
                'down': (Y_MIN, y1),
            }[extend_direction]
        else:
            return

        for extend_cell in adjacent_cells[extend_direction]:
            try:
                i = cells.index(extend_cell)
            except:
                continue
            cells[i][pair[0]] = pair[1]

        layout['cells'] = cells
        # remove extra rulers of column or row and reset cells
        value_cells = self.layout_to_value_cells(layout)
        layout = self.value_cells_to_layout(value_cells)
        # kill all views in pane
        if Settings().get('auto_close_view'):
            self.window.run_command('close')
        self.fixed_set_layout(layout)

    def get_closest_group(self, direction):
        adjacent_cells = self.get_adjacent_cells(self.current_group)
        try:
            group = self.cells.index(adjacent_cells[direction][0])
        except:
            group = -1
        return group

    def move_to_pane(self, direction):
        group = self.get_closest_group(direction)
        if group == -1:
            return
        self.fixed_focus_group(group)

    def carry_file_to_pane(self, direction):
        group = self.get_closest_group(direction)
        view = self.window.active_view()
        if not (view and group >= 0):
            return
        self.window.set_view_index(view, group, 0)
        self.fixed_focus_group(group)

    def clone_file_to_pane(self, direction):
        view = self.window.active_view()
        self.window.run_command("clone_file")
        self.carry_file_to_pane(direction)
        self.window.focus_view(view)

    def get_options(self, command):
        command = command.lower()
        if 'v' in command:
            pattern = 'v'
        elif 'h' in command:
            pattern = 'h'
        else:
            raise Exception(': Invalid command string' % PLUGIN_NAME)
        i = command.find(pattern)
        group = int(command[:i] or self.current_group)
        scale = int(command[i + 1:] or 50) / 100
        return group, pattern, scale


class Recordable(object):
    def do_run(self, *args, **kwargs):
        raise NotImplemented

    @classmethod
    def add_history(cls, item):
        if len(cls.history) > cls.max_history_num:
            cls.history.pop(0)
        cls.history.append(item)

    @classmethod
    def add_redo_history(cls, item):
        if len(cls.redo_history) > cls.max_history_num:
            cls.redo_history.pop(0)
        cls.redo_history.append(item)

    @classmethod
    def next_record(cls):
        item = cls.history.pop()
        return item

    @classmethod
    def prev_record(cls):
        item = cls.redo_history.pop()
        return item

    @classmethod
    def clear_history(cls):
        cls.history = []
        cls.redo_history = []


class MoveableCommand(PaneCommand, Recordable):
    # history of move between panes
    history = []
    redo_history = []
    max_history_num = Settings().get('max_move_history') or 100

    def run(self, *args, **kwargs):
        self.add_history(self.current_group)
        self.do_run(*args, **kwargs)


class RevocableCommand(PaneCommand, Recordable):
    # history of move between panes
    history = []
    redo_history = []
    max_history_num = Settings().get('max_layout_history') or 10

    def run(self, *args, **kwargs):
        self.add_history(self.layout_to_json())
        # Clear move history every time
        MoveableCommand.clear_history()
        self.do_run(*args, **kwargs)


class MoveToPaneCommand(MoveableCommand):
    def do_run(self, direction):
        self.move_to_pane(direction)


class CycleBetweenPanesCommand(MoveableCommand):
    def do_run(self):
        num_groups = self.window.num_groups()
        next_group = self.current_group + 1
        if next_group > num_groups - 1:
            next_group = 0
        self.fixed_focus_group(next_group)


class ReverseCycleBetweenPanesCommand(MoveableCommand):
    def do_run(self):
        num_groups = self.window.num_groups()
        prev_group = self.current_group - 1
        if prev_group < 0:
            prev_group = num_groups - 1
        self.fixed_focus_group(prev_group)


class SplitPaneCommand(RevocableCommand):
    def do_run(self, commands):
        for command in commands:
            group, pattern, scale = self.get_options(command)
            self.split_pane(group, pattern, scale)


class CombineAllPanesCommand(RevocableCommand):
    def do_run(self):
        self.fixed_set_layout({
            'rows': [0, 1],
            'cols': [0, 1],
            'cells': [[0, 0, 1, 1]]
        })


class DestroyCurrentPaneCommand(RevocableCommand):
    def do_run(self):
        self.destroy_pane(self.current_group)


class CloneFileToPaneCommand(RevocableCommand):
    def do_run(self, direction):
        self.clone_file_to_pane(direction)


class CarryFileToPaneCommand(RevocableCommand):
    def do_run(self, direction):
        self.carry_file_to_pane(direction)


class ResizePaneCommand(PaneCommand):
    def run(self, direction, step=1):
        self.resize_pane(self.current_group, direction, step / 100)


class LoadLayoutFromCommand(PaneCommand):
    def load_layout_from_file(self, filename):
        layout = open(self.get_layout_path(filename), 'r').read()
        self.load_layout_from_json(layout)

    def run(self, filename=None):
        if filename:
            self.load_layout_from_file(filename)
        else:
            view = self.window.show_input_panel(
                caption='Load from Layout File',
                initial_text='',
                on_done=self.load_layout_from_file,
                on_change=None,
                on_cancel=None
            )
        sublime.status_message('Load Layout named `%s`' % filename)


class SaveLayoutAsCommand(PaneCommand):
    def save_layout_to_file(self, filename):
        layout = self.layout_to_json()
        with open(self.get_layout_path(filename), 'w') as fp:
            fp.write(layout)

    def run(self, filename=None):
        if filename:
            self.save_layout_to_file(filename)
        else:
            view = self.window.show_input_panel(
                caption='Save as Layout File',
                initial_text='',
                on_done=self.save_layout_to_file,
                on_change=None,
                on_cancel=None
            )
        sublime.status_message('Saved Current Layout as `%s`' % filename)


class UndoMoveToPaneCommand(PaneCommand):
    def run(self):
        MoveableCommand.add_redo_history(self.current_group)
        group = MoveableCommand.next_record()
        self.fixed_focus_group(group)


class RedoMoveToPaneCommand(PaneCommand):
    def run(self):
        MoveableCommand.add_history(self.current_group)
        group = MoveableCommand.prev_record()
        self.fixed_focus_group(group)


class UndoLayoutPaneCommand(PaneCommand):
    def run(self):
        RevocableCommand.add_redo_history(self.layout_to_json())
        layout = RevocableCommand.next_record()
        self.load_layout_from_json(layout)


class RedoLayoutPaneCommand(PaneCommand):
    def run(self):
        RevocableCommand.add_history(self.layout_to_json())
        layout = RevocableCommand.prev_record()
        self.load_layout_from_json(layout)