TabStack/plugin/session.py at 5c2633adefe9b1a6912fb0221ad8c032b53ea77f · SublimeText/TabStack · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
from __future__ import annotations

from ._compat import sublime
from .constants import KIND_MODIFIED
from .ctrl_release import CtrlReleasePoller
from .sheets import apply_group_selection
from .state import TabStackWindowState

SHOW_PANEL_DELAY_MS = 150


def _ensure_ctrl_release_poller(window, state) -> None:
    if state.ctrl_release_poller:
        return

    def on_release() -> None:
        if state.session_active:
            _commit_session(window, state)
        elif state.session_pending:
            _commit_pending_session(window, state)

    state.ctrl_release_poller = CtrlReleasePoller(on_release, 25)
    state.ctrl_release_poller.start()


def show_panel(window, state) -> None:
    if not state.session_active or not state.session_entries:
        return

    items = [
        sublime.QuickPanelItem(
            trigger=entry.caption[0],
            details=entry.caption[1],
            kind=KIND_MODIFIED if entry.dirty else sublime.KIND_AMBIGUOUS,
        )
        for entry in state.session_entries
    ]

    def on_select(index: int) -> None:
        if index < 0:
            handle_panel_closed(window, state)
            return
        state.session_selected_index = index
        _commit_session(window, state)

    def on_highlight(index: int) -> None:
        if index < 0 or index >= len(state.session_entries):
            return
        state.session_selected_index = index
        preview_entry(window, state)

    window.show_quick_panel(
        items,
        on_select,
        selected_index=state.session_selected_index,
        on_highlight=on_highlight,
        placeholder="Release ctrl to close; Hit ctrl+escape to abort",
    )

    _ensure_ctrl_release_poller(window, state)


def schedule_panel(window, state, *, token: int) -> None:
    _ensure_ctrl_release_poller(window, state)

    def open_if_still_pending() -> None:
        if not state.session_pending or state.session_pending_token != token:
            return
        if state.ctrl_release_poller is not None and not state.ctrl_release_poller.is_ctrl_down():
            state.clear_session()
            return
        state.session_active = True
        state.session_pending = False
        show_panel(window, state)

    sublime.set_timeout(open_if_still_pending, SHOW_PANEL_DELAY_MS)


def preview_entry(window, state: TabStackWindowState) -> None:
    if state.session_entries is None:
        return
    if not 0 <= state.session_selected_index < len(state.session_entries):
        return
    entry = state.session_entries[state.session_selected_index]
    apply_group_selection(window, entry.selection, state.session_group)


def _commit_pending_session(window, state) -> None:
    entries = state.session_entries
    if not entries:
        state.clear_session()
        return

    index = clamp_index(state.session_selected_index, len(entries))
    selection = entries[index].selection
    apply_group_selection(window, selection, state.session_group)
    state.clear_session()


def _commit_session(window, state) -> None:
    if not state.session_active:
        return

    entries = state.session_entries
    if not entries:
        cancel_session(window, state)
        return

    index = clamp_index(state.session_selected_index, len(entries))
    selection = entries[index].selection
    if not apply_group_selection(window, selection, state.session_group):
        cancel_session(window, state)
        return

    window.run_command("hide_overlay", {"cancel": True})
    state.clear_session()


def cancel_session(window, state) -> None:
    if not state.session_active:
        if not state.session_pending:
            return
        state.clear_session()
        return

    origin = state.session_origin_selection
    window.run_command("hide_overlay", {"cancel": True})
    if origin is not None:
        apply_group_selection(window, origin, state.session_group)
    state.clear_session()


def clamp_index(index: int, size: int) -> int:
    return max(0, min(index, size - 1))


def reopen_panel_at_index(window, state: TabStackWindowState, index: int) -> None:
    if not state.session_active or state.session_panel_reopening:
        return

    entries = state.session_entries
    if not entries or len(entries) < 2:
        return

    state.session_selected_index = clamp_index(index, len(entries))
    state.session_panel_reopening = True
    window.run_command("hide_overlay", {"cancel": True})
    sublime.set_timeout(lambda: show_panel(window, state), 0)


def handle_panel_closed(window, state) -> None:
    if state.session_panel_reopening:
        state.session_panel_reopening = False
        return

    cancel_session(window, state)