1244 lines
38 KiB
Python
1244 lines
38 KiB
Python
import sys
|
|
|
|
import sublime_api
|
|
|
|
|
|
class _LogWriter:
|
|
def flush(self):
|
|
pass
|
|
|
|
def write(self, s):
|
|
sublime_api.log_message(s)
|
|
|
|
|
|
sys.stdout = _LogWriter()
|
|
sys.stderr = _LogWriter()
|
|
|
|
HOVER_TEXT = 1
|
|
HOVER_GUTTER = 2
|
|
HOVER_MARGIN = 3
|
|
|
|
ENCODED_POSITION = 1
|
|
TRANSIENT = 4
|
|
FORCE_GROUP = 8
|
|
IGNORECASE = 2
|
|
LITERAL = 1
|
|
MONOSPACE_FONT = 1
|
|
KEEP_OPEN_ON_FOCUS_LOST = 2
|
|
HTML = 1
|
|
COOPERATE_WITH_AUTO_COMPLETE = 2
|
|
HIDE_ON_MOUSE_MOVE = 4
|
|
HIDE_ON_MOUSE_MOVE_AWAY = 8
|
|
|
|
DRAW_EMPTY = 1
|
|
HIDE_ON_MINIMAP = 2
|
|
DRAW_EMPTY_AS_OVERWRITE = 4
|
|
PERSISTENT = 16
|
|
# Deprecated, use DRAW_NO_FILL instead
|
|
DRAW_OUTLINED = 32
|
|
DRAW_NO_FILL = 32
|
|
DRAW_NO_OUTLINE = 256
|
|
DRAW_SOLID_UNDERLINE = 512
|
|
DRAW_STIPPLED_UNDERLINE = 1024
|
|
DRAW_SQUIGGLY_UNDERLINE = 2048
|
|
HIDDEN = 128
|
|
|
|
OP_EQUAL = 0
|
|
OP_NOT_EQUAL = 1
|
|
OP_REGEX_MATCH = 2
|
|
OP_NOT_REGEX_MATCH = 3
|
|
OP_REGEX_CONTAINS = 4
|
|
OP_NOT_REGEX_CONTAINS = 5
|
|
CLASS_WORD_START = 1
|
|
CLASS_WORD_END = 2
|
|
CLASS_PUNCTUATION_START = 4
|
|
CLASS_PUNCTUATION_END = 8
|
|
CLASS_SUB_WORD_START = 16
|
|
CLASS_SUB_WORD_END = 32
|
|
CLASS_LINE_START = 64
|
|
CLASS_LINE_END = 128
|
|
CLASS_EMPTY_LINE = 256
|
|
INHIBIT_WORD_COMPLETIONS = 8
|
|
INHIBIT_EXPLICIT_COMPLETIONS = 16
|
|
|
|
DIALOG_CANCEL = 0
|
|
DIALOG_YES = 1
|
|
DIALOG_NO = 2
|
|
|
|
UI_ELEMENT_SIDE_BAR = 1
|
|
UI_ELEMENT_MINIMAP = 2
|
|
UI_ELEMENT_TABS = 4
|
|
UI_ELEMENT_STATUS_BAR = 8
|
|
UI_ELEMENT_MENU = 16
|
|
UI_ELEMENT_OPEN_FILES = 32
|
|
|
|
LAYOUT_INLINE = 0
|
|
LAYOUT_BELOW = 1
|
|
LAYOUT_BLOCK = 2
|
|
|
|
|
|
def version():
|
|
return sublime_api.version()
|
|
|
|
|
|
def platform():
|
|
return sublime_api.platform()
|
|
|
|
|
|
def arch():
|
|
return sublime_api.architecture()
|
|
|
|
|
|
def channel():
|
|
return sublime_api.channel()
|
|
|
|
|
|
def executable_path():
|
|
return sublime_api.executable_path()
|
|
|
|
|
|
def executable_hash():
|
|
import hashlib
|
|
return (
|
|
version(), platform() + '_' + arch(),
|
|
hashlib.md5(open(executable_path(), 'rb').read()).hexdigest())
|
|
|
|
|
|
def packages_path():
|
|
return sublime_api.packages_path()
|
|
|
|
|
|
def installed_packages_path():
|
|
return sublime_api.installed_packages_path()
|
|
|
|
|
|
def cache_path():
|
|
""" Returns the path where Sublime Text stores cache files """
|
|
return sublime_api.cache_path()
|
|
|
|
|
|
def status_message(msg):
|
|
sublime_api.status_message(msg)
|
|
|
|
|
|
def error_message(msg):
|
|
sublime_api.error_message(msg)
|
|
|
|
|
|
def message_dialog(msg):
|
|
sublime_api.message_dialog(msg)
|
|
|
|
|
|
def ok_cancel_dialog(msg, ok_title=""):
|
|
return sublime_api.ok_cancel_dialog(msg, ok_title)
|
|
|
|
|
|
def yes_no_cancel_dialog(msg, yes_title="", no_title=""):
|
|
return sublime_api.yes_no_cancel_dialog(msg, yes_title, no_title)
|
|
|
|
|
|
def run_command(cmd, args=None):
|
|
sublime_api.run_command(cmd, args)
|
|
|
|
|
|
def get_clipboard(size_limit=16777216):
|
|
"""
|
|
Returns the content of the clipboard, for performance reason if the size
|
|
of the clipboard content is bigger than size_limit, an empty string will be
|
|
returned
|
|
"""
|
|
return sublime_api.get_clipboard(size_limit)
|
|
|
|
|
|
def set_clipboard(text):
|
|
return sublime_api.set_clipboard(text)
|
|
|
|
|
|
def log_commands(flag):
|
|
sublime_api.log_commands(flag)
|
|
|
|
|
|
def log_input(flag):
|
|
"""
|
|
Enables or disables input logging. This is useful to find the names of
|
|
certain keys on the keyboard
|
|
"""
|
|
sublime_api.log_input(flag)
|
|
|
|
|
|
def log_result_regex(flag):
|
|
"""
|
|
Enables or disables result regex logging. This is useful when trying to
|
|
debug file_regex and line_regex in build systems
|
|
"""
|
|
sublime_api.log_result_regex(flag)
|
|
|
|
|
|
def log_indexing(flag):
|
|
sublime_api.log_indexing(flag)
|
|
|
|
|
|
def log_build_systems(flag):
|
|
sublime_api.log_build_systems(flag)
|
|
|
|
|
|
def score_selector(scope_name, selector):
|
|
return sublime_api.score_selector(scope_name, selector)
|
|
|
|
|
|
def load_resource(name):
|
|
s = sublime_api.load_resource(name)
|
|
if s is None:
|
|
raise IOError("resource not found")
|
|
return s
|
|
|
|
|
|
def load_binary_resource(name):
|
|
bytes = sublime_api.load_binary_resource(name)
|
|
if bytes is None:
|
|
raise IOError("resource not found")
|
|
return bytes
|
|
|
|
|
|
def find_resources(pattern):
|
|
return sublime_api.find_resources(pattern)
|
|
|
|
|
|
def encode_value(val, pretty=False):
|
|
return sublime_api.encode_value(val, pretty)
|
|
|
|
|
|
def decode_value(data):
|
|
val, err = sublime_api.decode_value(data)
|
|
|
|
if err:
|
|
raise ValueError(err)
|
|
|
|
return val
|
|
|
|
|
|
def expand_variables(val, variables):
|
|
return sublime_api.expand_variables(val, variables)
|
|
|
|
|
|
def load_settings(base_name):
|
|
settings_id = sublime_api.load_settings(base_name)
|
|
return Settings(settings_id)
|
|
|
|
|
|
def save_settings(base_name):
|
|
sublime_api.save_settings(base_name)
|
|
|
|
|
|
def set_timeout(f, timeout_ms=0):
|
|
"""
|
|
Schedules a function to be called in the future. Sublime Text will block
|
|
while the function is running
|
|
"""
|
|
sublime_api.set_timeout(f, timeout_ms)
|
|
|
|
|
|
def set_timeout_async(f, timeout_ms=0):
|
|
"""
|
|
Schedules a function to be called in the future. The function will be
|
|
called in a worker thread, and Sublime Text will not block while the
|
|
function is running
|
|
"""
|
|
sublime_api.set_timeout_async(f, timeout_ms)
|
|
|
|
|
|
def active_window():
|
|
return Window(sublime_api.active_window())
|
|
|
|
|
|
def windows():
|
|
return [Window(id) for id in sublime_api.windows()]
|
|
|
|
|
|
def get_macro():
|
|
return sublime_api.get_macro()
|
|
|
|
|
|
class Window(object):
|
|
def __init__(self, id):
|
|
self.window_id = id
|
|
self.settings_object = None
|
|
self.template_settings_object = None
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, Window) and other.window_id == self.window_id
|
|
|
|
def __bool__(self):
|
|
return self.window_id != 0
|
|
|
|
def id(self):
|
|
return self.window_id
|
|
|
|
def is_valid(self):
|
|
return sublime_api.window_num_groups(self.window_id) != 0
|
|
|
|
def hwnd(self):
|
|
""" Platform specific window handle, only returns a meaningful result under Windows """
|
|
return sublime_api.window_system_handle(self.window_id)
|
|
|
|
def active_sheet(self):
|
|
sheet_id = sublime_api.window_active_sheet(self.window_id)
|
|
if sheet_id == 0:
|
|
return None
|
|
else:
|
|
return Sheet(sheet_id)
|
|
|
|
def active_view(self):
|
|
view_id = sublime_api.window_active_view(self.window_id)
|
|
if view_id == 0:
|
|
return None
|
|
else:
|
|
return View(view_id)
|
|
|
|
def run_command(self, cmd, args=None):
|
|
sublime_api.window_run_command(self.window_id, cmd, args)
|
|
|
|
def new_file(self, flags=0, syntax=""):
|
|
""" flags must be either 0 or TRANSIENT """
|
|
return View(sublime_api.window_new_file(self.window_id, flags, syntax))
|
|
|
|
def open_file(self, fname, flags=0, group=-1):
|
|
"""
|
|
valid bits for flags are:
|
|
ENCODED_POSITION: fname name may have :row:col or :row suffix
|
|
TRASIENT: don't add the file to the list of open buffers
|
|
FORCE_GROUP: don't select the file if it's opened in a different group
|
|
"""
|
|
return View(sublime_api.window_open_file(self.window_id, fname, flags, group))
|
|
|
|
def find_open_file(self, fname):
|
|
view_id = sublime_api.window_find_open_file(self.window_id, fname)
|
|
if view_id == 0:
|
|
return None
|
|
else:
|
|
return View(view_id)
|
|
|
|
def num_groups(self):
|
|
return sublime_api.window_num_groups(self.window_id)
|
|
|
|
def active_group(self):
|
|
return sublime_api.window_active_group(self.window_id)
|
|
|
|
def focus_group(self, idx):
|
|
sublime_api.window_focus_group(self.window_id, idx)
|
|
|
|
def focus_sheet(self, sheet):
|
|
if sheet:
|
|
sublime_api.window_focus_sheet(self.window_id, sheet.sheet_id)
|
|
|
|
def focus_view(self, view):
|
|
if view:
|
|
sublime_api.window_focus_view(self.window_id, view.view_id)
|
|
|
|
def get_sheet_index(self, sheet):
|
|
if sheet:
|
|
return sublime_api.window_get_sheet_index(self.window_id, sheet.sheet_id)
|
|
else:
|
|
return (-1, -1)
|
|
|
|
def get_view_index(self, view):
|
|
if view:
|
|
return sublime_api.window_get_view_index(self.window_id, view.view_id)
|
|
else:
|
|
return (-1, -1)
|
|
|
|
def set_sheet_index(self, sheet, group, idx):
|
|
sublime_api.window_set_sheet_index(self.window_id, sheet.sheet_id, group, idx)
|
|
|
|
def set_view_index(self, view, group, idx):
|
|
sublime_api.window_set_view_index(self.window_id, view.view_id, group, idx)
|
|
|
|
def sheets(self):
|
|
sheet_ids = sublime_api.window_sheets(self.window_id)
|
|
return [Sheet(x) for x in sheet_ids]
|
|
|
|
def views(self):
|
|
view_ids = sublime_api.window_views(self.window_id)
|
|
return [View(x) for x in view_ids]
|
|
|
|
def active_sheet_in_group(self, group):
|
|
sheet_id = sublime_api.window_active_sheet_in_group(self.window_id, group)
|
|
if sheet_id == 0:
|
|
return None
|
|
else:
|
|
return Sheet(sheet_id)
|
|
|
|
def active_view_in_group(self, group):
|
|
view_id = sublime_api.window_active_view_in_group(self.window_id, group)
|
|
if view_id == 0:
|
|
return None
|
|
else:
|
|
return View(view_id)
|
|
|
|
def sheets_in_group(self, group):
|
|
sheet_ids = sublime_api.window_sheets_in_group(self.window_id, group)
|
|
return [Sheet(x) for x in sheet_ids]
|
|
|
|
def views_in_group(self, group):
|
|
view_ids = sublime_api.window_views_in_group(self.window_id, group)
|
|
return [View(x) for x in view_ids]
|
|
|
|
def transient_sheet_in_group(self, group):
|
|
sheet_id = sublime_api.window_transient_sheet_in_group(self.window_id, group)
|
|
if sheet_id != 0:
|
|
return Sheet(sheet_id)
|
|
else:
|
|
return None
|
|
|
|
def transient_view_in_group(self, group):
|
|
view_id = sublime_api.window_transient_view_in_group(self.window_id, group)
|
|
if view_id != 0:
|
|
return View(view_id)
|
|
else:
|
|
return None
|
|
|
|
def layout(self):
|
|
return sublime_api.window_get_layout(self.window_id)
|
|
|
|
def get_layout(self):
|
|
""" get_layout() is deprecated, use layout() """
|
|
return sublime_api.window_get_layout(self.window_id)
|
|
|
|
def set_layout(self, layout):
|
|
sublime_api.window_set_layout(self.window_id, layout)
|
|
|
|
def create_output_panel(self, name, unlisted=False):
|
|
return View(sublime_api.window_create_output_panel(self.window_id, name, unlisted))
|
|
|
|
def find_output_panel(self, name):
|
|
view_id = sublime_api.window_find_output_panel(self.window_id, name)
|
|
return View(view_id) if view_id else None
|
|
|
|
def destroy_output_panel(self, name):
|
|
sublime_api.window_destroy_output_panel(self.window_id, name)
|
|
|
|
def active_panel(self):
|
|
name = sublime_api.window_active_panel(self.window_id)
|
|
return name or None
|
|
|
|
def panels(self):
|
|
return sublime_api.window_panels(self.window_id)
|
|
|
|
def get_output_panel(self, name):
|
|
""" deprecated, use create_output_panel """
|
|
return self.create_output_panel(name)
|
|
|
|
def show_input_panel(self, caption, initial_text, on_done, on_change, on_cancel):
|
|
""" on_done and on_change should accept a string argument, on_cancel should have no arguments """
|
|
return View(sublime_api.window_show_input_panel(
|
|
self.window_id, caption, initial_text, on_done, on_change, on_cancel))
|
|
|
|
def show_quick_panel(self, items, on_select, flags=0, selected_index=-1, on_highlight=None):
|
|
"""
|
|
on_select is called when the the quick panel is finished, and should
|
|
accept a single integer, specifying which item was selected, or -1 for none
|
|
|
|
on_highlight is called when the quick panel is still active, and
|
|
indicates the current highlighted index
|
|
|
|
flags is a bitwise OR of MONOSPACE_FONT, and KEEP_OPEN_ON_FOCUS_LOST
|
|
"""
|
|
items_per_row = 1
|
|
flat_items = items
|
|
if len(items) > 0 and isinstance(items[0], list):
|
|
items_per_row = len(items[0])
|
|
flat_items = []
|
|
|
|
for i in range(len(items)):
|
|
if isinstance(items[i], str):
|
|
flat_items.append(items[i])
|
|
for j in range(1, items_per_row):
|
|
flat_items.append("")
|
|
else:
|
|
for j in range(items_per_row):
|
|
flat_items.append(items[i][j])
|
|
|
|
sublime_api.window_show_quick_panel(
|
|
self.window_id, flat_items, items_per_row, on_select, on_highlight,
|
|
flags, selected_index)
|
|
|
|
def is_sidebar_visible(self):
|
|
return sublime_api.window_is_ui_element_visible(self.window_id, UI_ELEMENT_SIDE_BAR)
|
|
|
|
def set_sidebar_visible(self, flag):
|
|
sublime_api.window_set_ui_element_visible(self.window_id, UI_ELEMENT_SIDE_BAR, flag)
|
|
|
|
def is_minimap_visible(self):
|
|
return sublime_api.window_is_ui_element_visible(self.window_id, UI_ELEMENT_MINIMAP)
|
|
|
|
def set_minimap_visible(self, flag):
|
|
sublime_api.window_set_ui_element_visible(self.window_id, UI_ELEMENT_MINIMAP, flag)
|
|
|
|
def is_status_bar_visible(self):
|
|
return sublime_api.window_is_ui_element_visible(self.window_id, UI_ELEMENT_STATUS_BAR)
|
|
|
|
def set_status_bar_visible(self, flag):
|
|
sublime_api.window_set_ui_element_visible(self.window_id, UI_ELEMENT_STATUS_BAR, flag)
|
|
|
|
def get_tabs_visible(self):
|
|
return sublime_api.window_is_ui_element_visible(self.window_id, UI_ELEMENT_TABS)
|
|
|
|
def set_tabs_visible(self, flag):
|
|
sublime_api.window_set_ui_element_visible(self.window_id, UI_ELEMENT_TABS, flag)
|
|
|
|
def is_menu_visible(self):
|
|
return sublime_api.window_is_ui_element_visible(self.window_id, UI_ELEMENT_MENU)
|
|
|
|
def set_menu_visible(self, flag):
|
|
sublime_api.window_set_ui_element_visible(self.window_id, UI_ELEMENT_MENU, flag)
|
|
|
|
def folders(self):
|
|
return sublime_api.window_folders(self.window_id)
|
|
|
|
def project_file_name(self):
|
|
name = sublime_api.window_project_file_name(self.window_id)
|
|
if len(name) == 0:
|
|
return None
|
|
else:
|
|
return name
|
|
|
|
def project_data(self):
|
|
return sublime_api.window_get_project_data(self.window_id)
|
|
|
|
def set_project_data(self, v):
|
|
sublime_api.window_set_project_data(self.window_id, v)
|
|
|
|
def settings(self):
|
|
""" Per-window settings, the contents are persisted in the session """
|
|
if not self.settings_object:
|
|
self.settings_object = Settings(
|
|
sublime_api.window_settings(self.window_id))
|
|
|
|
return self.settings_object
|
|
|
|
def template_settings(self):
|
|
""" Per-window settings that are persisted in the session, and duplicated into new windows """
|
|
if not self.template_settings_object:
|
|
self.template_settings_object = Settings(
|
|
sublime_api.window_template_settings(self.window_id))
|
|
|
|
return self.template_settings_object
|
|
|
|
def lookup_symbol_in_index(self, sym):
|
|
""" Finds all files and locations where sym is defined, using the symbol index """
|
|
return sublime_api.window_lookup_symbol(self.window_id, sym)
|
|
|
|
def lookup_symbol_in_open_files(self, sym):
|
|
""" Finds all files and locations where sym is defined, searching through open files """
|
|
return sublime_api.window_lookup_symbol_in_open_files(self.window_id, sym)
|
|
|
|
def lookup_references_in_index(self, sym):
|
|
""" Finds all files and locations where sym is referenced, using the symbol index """
|
|
return sublime_api.window_lookup_references(self.window_id, sym)
|
|
|
|
def lookup_references_in_open_files(self, sym):
|
|
""" Finds all files and locations where sym is referenced, searching through open files """
|
|
return sublime_api.window_lookup_references_in_open_files(self.window_id, sym)
|
|
|
|
def extract_variables(self):
|
|
return sublime_api.window_extract_variables(self.window_id)
|
|
|
|
def status_message(self, msg):
|
|
sublime_api.window_status_message(self.window_id, msg)
|
|
|
|
|
|
class Edit(object):
|
|
def __init__(self, token):
|
|
self.edit_token = token
|
|
|
|
|
|
class Region(object):
|
|
__slots__ = ['a', 'b', 'xpos']
|
|
|
|
def __init__(self, a, b=None, xpos=-1):
|
|
if b is None:
|
|
b = a
|
|
self.a = a
|
|
self.b = b
|
|
self.xpos = xpos
|
|
|
|
def __str__(self):
|
|
return "(" + str(self.a) + ", " + str(self.b) + ")"
|
|
|
|
def __repr__(self):
|
|
return "(" + str(self.a) + ", " + str(self.b) + ")"
|
|
|
|
def __len__(self):
|
|
return self.size()
|
|
|
|
def __eq__(self, rhs):
|
|
return isinstance(rhs, Region) and self.a == rhs.a and self.b == rhs.b
|
|
|
|
def __lt__(self, rhs):
|
|
lhs_begin = self.begin()
|
|
rhs_begin = rhs.begin()
|
|
|
|
if lhs_begin == rhs_begin:
|
|
return self.end() < rhs.end()
|
|
else:
|
|
return lhs_begin < rhs_begin
|
|
|
|
def empty(self):
|
|
return self.a == self.b
|
|
|
|
def begin(self):
|
|
if self.a < self.b:
|
|
return self.a
|
|
else:
|
|
return self.b
|
|
|
|
def end(self):
|
|
if self.a < self.b:
|
|
return self.b
|
|
else:
|
|
return self.a
|
|
|
|
def size(self):
|
|
return abs(self.a - self.b)
|
|
|
|
def contains(self, x):
|
|
if isinstance(x, Region):
|
|
return self.contains(x.a) and self.contains(x.b)
|
|
else:
|
|
return x >= self.begin() and x <= self.end()
|
|
|
|
def cover(self, rhs):
|
|
a = min(self.begin(), rhs.begin())
|
|
b = max(self.end(), rhs.end())
|
|
|
|
if self.a < self.b:
|
|
return Region(a, b)
|
|
else:
|
|
return Region(b, a)
|
|
|
|
def intersection(self, rhs):
|
|
if self.end() <= rhs.begin():
|
|
return Region(0)
|
|
if self.begin() >= rhs.end():
|
|
return Region(0)
|
|
|
|
return Region(max(self.begin(), rhs.begin()), min(self.end(), rhs.end()))
|
|
|
|
def intersects(self, rhs):
|
|
lb = self.begin()
|
|
le = self.end()
|
|
rb = rhs.begin()
|
|
re = rhs.end()
|
|
|
|
return (
|
|
(lb == rb and le == re) or
|
|
(rb > lb and rb < le) or (re > lb and re < le) or
|
|
(lb > rb and lb < re) or (le > rb and le < re))
|
|
|
|
|
|
class Selection(object):
|
|
def __init__(self, id):
|
|
self.view_id = id
|
|
|
|
def __len__(self):
|
|
return sublime_api.view_selection_size(self.view_id)
|
|
|
|
def __getitem__(self, index):
|
|
r = sublime_api.view_selection_get(self.view_id, index)
|
|
if r.a == -1:
|
|
raise IndexError()
|
|
return r
|
|
|
|
def __delitem__(self, index):
|
|
sublime_api.view_selection_erase(self.view_id, index)
|
|
|
|
def __eq__(self, rhs):
|
|
return rhs is not None and list(self) == list(rhs)
|
|
|
|
def __lt__(self, rhs):
|
|
return rhs is not None and list(self) < list(rhs)
|
|
|
|
def __bool__(self):
|
|
return self.view_id != 0
|
|
|
|
def is_valid(self):
|
|
return sublime_api.view_buffer_id(self.view_id) != 0
|
|
|
|
def clear(self):
|
|
sublime_api.view_selection_clear(self.view_id)
|
|
|
|
def add(self, x):
|
|
if isinstance(x, Region):
|
|
sublime_api.view_selection_add_region(self.view_id, x.a, x.b, x.xpos)
|
|
else:
|
|
sublime_api.view_selection_add_point(self.view_id, x)
|
|
|
|
def add_all(self, regions):
|
|
for r in regions:
|
|
self.add(r)
|
|
|
|
def subtract(self, region):
|
|
sublime_api.view_selection_subtract_region(self.view_id, region.a, region.b)
|
|
|
|
def contains(self, region):
|
|
return sublime_api.view_selection_contains(self.view_id, region.a, region.b)
|
|
|
|
|
|
class Sheet(object):
|
|
def __init__(self, id):
|
|
self.sheet_id = id
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, Sheet) and other.sheet_id == self.sheet_id
|
|
|
|
def id(self):
|
|
return self.sheet_id
|
|
|
|
def window(self):
|
|
window_id = sublime_api.sheet_window(self.sheet_id)
|
|
if window_id == 0:
|
|
return None
|
|
else:
|
|
return Window(window_id)
|
|
|
|
def view(self):
|
|
view_id = sublime_api.sheet_view(self.sheet_id)
|
|
if view_id == 0:
|
|
return None
|
|
else:
|
|
return View(view_id)
|
|
|
|
|
|
class View(object):
|
|
def __init__(self, id):
|
|
self.view_id = id
|
|
self.selection = Selection(id)
|
|
self.settings_object = None
|
|
|
|
def __len__(self):
|
|
return self.size()
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, View) and other.view_id == self.view_id
|
|
|
|
def __bool__(self):
|
|
return self.view_id != 0
|
|
|
|
def id(self):
|
|
return self.view_id
|
|
|
|
def buffer_id(self):
|
|
return sublime_api.view_buffer_id(self.view_id)
|
|
|
|
def is_valid(self):
|
|
""" Returns true if the View is still a valid handle. Will return False for a closed view, for example. """
|
|
return sublime_api.view_buffer_id(self.view_id) != 0
|
|
|
|
def is_primary(self):
|
|
return sublime_api.view_is_primary(self.view_id)
|
|
|
|
def window(self):
|
|
window_id = sublime_api.view_window(self.view_id)
|
|
if window_id == 0:
|
|
return None
|
|
else:
|
|
return Window(window_id)
|
|
|
|
def file_name(self):
|
|
name = sublime_api.view_file_name(self.view_id)
|
|
if len(name) == 0:
|
|
return None
|
|
else:
|
|
return name
|
|
|
|
def close(self):
|
|
window_id = sublime_api.view_window(self.view_id)
|
|
return sublime_api.window_close_file(window_id, self.view_id)
|
|
|
|
def retarget(self, new_fname):
|
|
sublime_api.view_retarget(self.view_id, new_fname)
|
|
|
|
def name(self):
|
|
return sublime_api.view_get_name(self.view_id)
|
|
|
|
def set_name(self, name):
|
|
sublime_api.view_set_name(self.view_id, name)
|
|
|
|
def reset_reference_document(self):
|
|
sublime_api.view_reset_reference_document(self.view_id)
|
|
|
|
def set_reference_document(self, reference):
|
|
sublime_api.view_set_reference_document(self.view_id, reference)
|
|
|
|
def is_loading(self):
|
|
return sublime_api.view_is_loading(self.view_id)
|
|
|
|
def is_dirty(self):
|
|
return sublime_api.view_is_dirty(self.view_id)
|
|
|
|
def is_read_only(self):
|
|
return sublime_api.view_is_read_only(self.view_id)
|
|
|
|
def set_read_only(self, read_only):
|
|
return sublime_api.view_set_read_only(self.view_id, read_only)
|
|
|
|
def is_scratch(self):
|
|
return sublime_api.view_is_scratch(self.view_id)
|
|
|
|
def set_scratch(self, scratch):
|
|
"""
|
|
Sets the scratch flag on the text buffer. When a modified scratch buffer
|
|
is closed, it will be closed without prompting to save.
|
|
"""
|
|
return sublime_api.view_set_scratch(self.view_id, scratch)
|
|
|
|
def encoding(self):
|
|
return sublime_api.view_encoding(self.view_id)
|
|
|
|
def set_encoding(self, encoding_name):
|
|
return sublime_api.view_set_encoding(self.view_id, encoding_name)
|
|
|
|
def line_endings(self):
|
|
return sublime_api.view_line_endings(self.view_id)
|
|
|
|
def set_line_endings(self, line_ending_name):
|
|
return sublime_api.view_set_line_endings(self.view_id, line_ending_name)
|
|
|
|
def size(self):
|
|
return sublime_api.view_size(self.view_id)
|
|
|
|
def begin_edit(self, edit_token, cmd, args=None):
|
|
sublime_api.view_begin_edit(self.view_id, edit_token, cmd, args)
|
|
return Edit(edit_token)
|
|
|
|
def end_edit(self, edit):
|
|
sublime_api.view_end_edit(self.view_id, edit.edit_token)
|
|
edit.edit_token = 0
|
|
|
|
def is_in_edit(self):
|
|
return sublime_api.view_is_in_edit(self.view_id)
|
|
|
|
def insert(self, edit, pt, text):
|
|
if edit.edit_token == 0:
|
|
raise ValueError("Edit objects may not be used after the TextCommand's run method has returned")
|
|
|
|
return sublime_api.view_insert(self.view_id, edit.edit_token, pt, text)
|
|
|
|
def erase(self, edit, r):
|
|
if edit.edit_token == 0:
|
|
raise ValueError("Edit objects may not be used after the TextCommand's run method has returned")
|
|
|
|
sublime_api.view_erase(self.view_id, edit.edit_token, r)
|
|
|
|
def replace(self, edit, r, text):
|
|
if edit.edit_token == 0:
|
|
raise ValueError("Edit objects may not be used after the TextCommand's run method has returned")
|
|
|
|
sublime_api.view_replace(self.view_id, edit.edit_token, r, text)
|
|
|
|
def change_count(self):
|
|
""" The change_count is incremented whenever the underlying buffer is modified """
|
|
return sublime_api.view_change_count(self.view_id)
|
|
|
|
def run_command(self, cmd, args=None):
|
|
sublime_api.view_run_command(self.view_id, cmd, args)
|
|
|
|
def sel(self):
|
|
return self.selection
|
|
|
|
def substr(self, x):
|
|
if isinstance(x, Region):
|
|
return sublime_api.view_cached_substr(self.view_id, x.a, x.b)
|
|
else:
|
|
s = sublime_api.view_cached_substr(self.view_id, x, x + 1)
|
|
# S2 backwards compat
|
|
if len(s) == 0:
|
|
return "\x00"
|
|
else:
|
|
return s
|
|
|
|
def find(self, pattern, start_pt, flags=0):
|
|
return sublime_api.view_find(self.view_id, pattern, start_pt, flags)
|
|
|
|
def find_all(self, pattern, flags=0, fmt=None, extractions=None):
|
|
if fmt is None:
|
|
return sublime_api.view_find_all(self.view_id, pattern, flags)
|
|
else:
|
|
results = sublime_api.view_find_all_with_contents(self.view_id, pattern, flags, fmt)
|
|
ret = []
|
|
for region, contents in results:
|
|
ret.append(region)
|
|
extractions.append(contents)
|
|
return ret
|
|
|
|
def settings(self):
|
|
if not self.settings_object:
|
|
self.settings_object = Settings(sublime_api.view_settings(self.view_id))
|
|
|
|
return self.settings_object
|
|
|
|
def meta_info(self, key, pt):
|
|
return sublime_api.view_meta_info(self.view_id, key, pt)
|
|
|
|
def extract_tokens_with_scopes(self, r):
|
|
return sublime_api.view_extract_tokens_with_scopes(self.view_id, r.begin(), r.end())
|
|
|
|
def extract_scope(self, pt):
|
|
return sublime_api.view_extract_scope(self.view_id, pt)
|
|
|
|
def scope_name(self, pt):
|
|
return sublime_api.view_scope_name(self.view_id, pt)
|
|
|
|
def match_selector(self, pt, selector):
|
|
return sublime_api.view_match_selector(self.view_id, pt, selector)
|
|
|
|
def score_selector(self, pt, selector):
|
|
return sublime_api.view_score_selector(self.view_id, pt, selector)
|
|
|
|
def find_by_selector(self, selector):
|
|
return sublime_api.view_find_by_selector(self.view_id, selector)
|
|
|
|
def style(self):
|
|
return sublime_api.view_style(self.view_id)
|
|
|
|
def style_for_scope(self, scope):
|
|
return sublime_api.view_style_for_scope(self.view_id, scope)
|
|
|
|
def indented_region(self, pt):
|
|
return sublime_api.view_indented_region(self.view_id, pt)
|
|
|
|
def indentation_level(self, pt):
|
|
return sublime_api.view_indentation_level(self.view_id, pt)
|
|
|
|
def has_non_empty_selection_region(self):
|
|
return sublime_api.view_has_non_empty_selection_region(self.view_id)
|
|
|
|
def lines(self, r):
|
|
return sublime_api.view_lines(self.view_id, r)
|
|
|
|
def split_by_newlines(self, r):
|
|
return sublime_api.view_split_by_newlines(self.view_id, r)
|
|
|
|
def line(self, x):
|
|
if isinstance(x, Region):
|
|
return sublime_api.view_line_from_region(self.view_id, x)
|
|
else:
|
|
return sublime_api.view_line_from_point(self.view_id, x)
|
|
|
|
def full_line(self, x):
|
|
if isinstance(x, Region):
|
|
return sublime_api.view_full_line_from_region(self.view_id, x)
|
|
else:
|
|
return sublime_api.view_full_line_from_point(self.view_id, x)
|
|
|
|
def word(self, x):
|
|
if isinstance(x, Region):
|
|
return sublime_api.view_word_from_region(self.view_id, x)
|
|
else:
|
|
return sublime_api.view_word_from_point(self.view_id, x)
|
|
|
|
def classify(self, pt):
|
|
""" Classifies pt, returning a bitwise OR of zero or more of these flags:
|
|
CLASS_WORD_START
|
|
CLASS_WORD_END
|
|
CLASS_PUNCTUATION_START
|
|
CLASS_PUNCTUATION_END
|
|
CLASS_SUB_WORD_START
|
|
CLASS_SUB_WORD_END
|
|
CLASS_LINE_START
|
|
CLASS_LINE_END
|
|
CLASS_EMPTY_LINE
|
|
"""
|
|
|
|
return sublime_api.view_classify(self.view_id, pt)
|
|
|
|
def find_by_class(self, pt, forward, classes, separators=""):
|
|
return sublime_api.view_find_by_class(self.view_id, pt, forward, classes, separators)
|
|
|
|
def expand_by_class(self, x, classes, separators=""):
|
|
if isinstance(x, Region):
|
|
return sublime_api.view_expand_by_class(self.view_id, x.a, x.b, classes, separators)
|
|
else:
|
|
return sublime_api.view_expand_by_class(self.view_id, x, x, classes, separators)
|
|
|
|
def rowcol(self, tp):
|
|
return sublime_api.view_row_col(self.view_id, tp)
|
|
|
|
def text_point(self, row, col):
|
|
""" Converts a row and column into a text point """
|
|
return sublime_api.view_text_point(self.view_id, row, col)
|
|
|
|
def visible_region(self):
|
|
""" Returns the approximate visible region """
|
|
return sublime_api.view_visible_region(self.view_id)
|
|
|
|
def show(self, x, show_surrounds=True):
|
|
""" Scrolls the view to reveal x, which may be a Region or point """
|
|
if isinstance(x, Region):
|
|
return sublime_api.view_show_region(self.view_id, x, show_surrounds)
|
|
if isinstance(x, Selection):
|
|
for i in x:
|
|
return sublime_api.view_show_region(self.view_id, i, show_surrounds)
|
|
else:
|
|
return sublime_api.view_show_point(self.view_id, x, show_surrounds)
|
|
|
|
def show_at_center(self, x):
|
|
""" Scrolls the view to center on x, which may be a Region or point """
|
|
if isinstance(x, Region):
|
|
return sublime_api.view_show_region_at_center(self.view_id, x)
|
|
else:
|
|
return sublime_api.view_show_point_at_center(self.view_id, x)
|
|
|
|
def viewport_position(self):
|
|
""" Returns the (x, y) scroll position of the view in layout coordinates """
|
|
return sublime_api.view_viewport_position(self.view_id)
|
|
|
|
def set_viewport_position(self, xy, animate=True):
|
|
""" Scrolls the view to the given position in layout coordinates """
|
|
return sublime_api.view_set_viewport_position(self.view_id, xy, animate)
|
|
|
|
def viewport_extent(self):
|
|
""" Returns the width and height of the viewport, in layout coordinates """
|
|
return sublime_api.view_viewport_extents(self.view_id)
|
|
|
|
def layout_extent(self):
|
|
""" Returns the total height and width of the document, in layout coordinates """
|
|
return sublime_api.view_layout_extents(self.view_id)
|
|
|
|
def text_to_layout(self, tp):
|
|
""" Converts a text point to layout coordinates """
|
|
return sublime_api.view_text_to_layout(self.view_id, tp)
|
|
|
|
def text_to_window(self, tp):
|
|
""" Converts a text point to window coordinates """
|
|
return self.layout_to_window(self.text_to_layout(tp))
|
|
|
|
def layout_to_text(self, xy):
|
|
""" Converts layout coordinates to a text point """
|
|
return sublime_api.view_layout_to_text(self.view_id, xy)
|
|
|
|
def layout_to_window(self, xy):
|
|
""" Converts layout coordinates to window coordinates """
|
|
return sublime_api.view_layout_to_window(self.view_id, xy)
|
|
|
|
def window_to_layout(self, xy):
|
|
""" Converts window coordinates to layout coordinates """
|
|
return sublime_api.view_window_to_layout(self.view_id, xy)
|
|
|
|
def window_to_text(self, xy):
|
|
""" Converts window coordinates to a text point """
|
|
return self.layout_to_text(self.window_to_layout(xy))
|
|
|
|
def line_height(self):
|
|
""" Returns the height of a line in layout coordinates """
|
|
return sublime_api.view_line_height(self.view_id)
|
|
|
|
def em_width(self):
|
|
""" Returns the em-width of the current font in layout coordinates """
|
|
return sublime_api.view_em_width(self.view_id)
|
|
|
|
def is_folded(self, sr):
|
|
return sublime_api.view_is_folded(self.view_id, sr)
|
|
|
|
def folded_regions(self):
|
|
return sublime_api.view_folded_regions(self.view_id)
|
|
|
|
def fold(self, x):
|
|
if isinstance(x, Region):
|
|
return sublime_api.view_fold_region(self.view_id, x)
|
|
else:
|
|
return sublime_api.view_fold_regions(self.view_id, x)
|
|
|
|
def unfold(self, x):
|
|
if isinstance(x, Region):
|
|
return sublime_api.view_unfold_region(self.view_id, x)
|
|
else:
|
|
return sublime_api.view_unfold_regions(self.view_id, x)
|
|
|
|
def add_regions(self, key, regions, scope="", icon="", flags=0):
|
|
# S2 has an add_regions overload that accepted flags as the 5th
|
|
# positional argument, however this usage is no longer supported
|
|
if not isinstance(icon, "".__class__):
|
|
raise ValueError("icon must be a string")
|
|
|
|
sublime_api.view_add_regions(self.view_id, key, regions, scope, icon, flags)
|
|
|
|
def get_regions(self, key):
|
|
return sublime_api.view_get_regions(self.view_id, key)
|
|
|
|
def erase_regions(self, key):
|
|
sublime_api.view_erase_regions(self.view_id, key)
|
|
|
|
def add_phantom(self, key, region, content, layout, on_navigate=None):
|
|
return sublime_api.view_add_phantom(self.view_id, key, region, content, layout, on_navigate)
|
|
|
|
def erase_phantoms(self, key):
|
|
sublime_api.view_erase_phantoms(self.view_id, key)
|
|
|
|
def erase_phantom_by_id(self, pid):
|
|
sublime_api.view_erase_phantom(self.view_id, pid)
|
|
|
|
def query_phantom(self, pid):
|
|
return sublime_api.view_query_phantoms(self.view_id, [pid])
|
|
|
|
def query_phantoms(self, pids):
|
|
return sublime_api.view_query_phantoms(self.view_id, pids)
|
|
|
|
def assign_syntax(self, syntax_file):
|
|
sublime_api.view_assign_syntax(self.view_id, syntax_file)
|
|
|
|
def set_syntax_file(self, syntax_file):
|
|
""" Deprecated, use assign_syntax instead """
|
|
self.assign_syntax(syntax_file)
|
|
|
|
def symbols(self):
|
|
return sublime_api.view_symbols(self.view_id)
|
|
|
|
def get_symbols(self):
|
|
""" Deprecated, use symbols """
|
|
return self.symbols()
|
|
|
|
def indexed_symbols(self):
|
|
return sublime_api.view_indexed_symbols(self.view_id)
|
|
|
|
def indexed_references(self):
|
|
return sublime_api.view_indexed_references(self.view_id)
|
|
|
|
def set_status(self, key, value):
|
|
sublime_api.view_set_status(self.view_id, key, value)
|
|
|
|
def get_status(self, key):
|
|
return sublime_api.view_get_status(self.view_id, key)
|
|
|
|
def erase_status(self, key):
|
|
sublime_api.view_erase_status(self.view_id, key)
|
|
|
|
def extract_completions(self, prefix, tp=-1):
|
|
return sublime_api.view_extract_completions(self.view_id, prefix, tp)
|
|
|
|
def find_all_results(self):
|
|
return sublime_api.view_find_all_results(self.view_id)
|
|
|
|
def find_all_results_with_text(self):
|
|
return sublime_api.view_find_all_results_with_text(self.view_id)
|
|
|
|
def command_history(self, delta, modifying_only=False):
|
|
return sublime_api.view_command_history(self.view_id, delta, modifying_only)
|
|
|
|
def overwrite_status(self):
|
|
return sublime_api.view_get_overwrite_status(self.view_id)
|
|
|
|
def set_overwrite_status(self, value):
|
|
sublime_api.view_set_overwrite_status(self.view_id, value)
|
|
|
|
def show_popup_menu(self, items, on_select, flags=0):
|
|
"""
|
|
on_select is called when the the quick panel is finished, and should accept a
|
|
single integer, specifying which item was selected, or -1 for none
|
|
"""
|
|
return sublime_api.view_show_popup_table(self.view_id, items, on_select, flags, -1)
|
|
|
|
def show_popup(self, content, flags=0, location=-1,
|
|
max_width=320, max_height=240,
|
|
on_navigate=None, on_hide=None):
|
|
sublime_api.view_show_popup(
|
|
self.view_id, location, content, flags, max_width, max_height,
|
|
on_navigate, on_hide)
|
|
|
|
def update_popup(self, content):
|
|
sublime_api.view_update_popup_content(self.view_id, content)
|
|
|
|
def is_popup_visible(self):
|
|
return sublime_api.view_is_popup_visible(self.view_id)
|
|
|
|
def hide_popup(self):
|
|
sublime_api.view_hide_popup(self.view_id)
|
|
|
|
def is_auto_complete_visible(self):
|
|
return sublime_api.view_is_auto_complete_visible(self.view_id)
|
|
|
|
|
|
class Settings(object):
|
|
def __init__(self, id):
|
|
self.settings_id = id
|
|
|
|
def get(self, key, default=None):
|
|
if default is not None:
|
|
return sublime_api.settings_get_default(self.settings_id, key, default)
|
|
else:
|
|
return sublime_api.settings_get(self.settings_id, key)
|
|
|
|
def has(self, key):
|
|
return sublime_api.settings_has(self.settings_id, key)
|
|
|
|
def set(self, key, value):
|
|
sublime_api.settings_set(self.settings_id, key, value)
|
|
|
|
def erase(self, key):
|
|
sublime_api.settings_erase(self.settings_id, key)
|
|
|
|
def add_on_change(self, tag, callback):
|
|
sublime_api.settings_add_on_change(self.settings_id, tag, callback)
|
|
|
|
def clear_on_change(self, tag):
|
|
sublime_api.settings_clear_on_change(self.settings_id, tag)
|
|
|
|
|
|
class Phantom(object):
|
|
def __init__(self, region, content, layout, on_navigate=None):
|
|
self.region = region
|
|
self.content = content
|
|
self.layout = layout
|
|
self.on_navigate = on_navigate
|
|
self.id = None
|
|
|
|
def __eq__(self, rhs):
|
|
# Note that self.id is not considered
|
|
return (self.region == rhs.region and self.content == rhs.content and
|
|
self.layout == rhs.layout and self.on_navigate == rhs.on_navigate)
|
|
|
|
|
|
class PhantomSet(object):
|
|
def __init__(self, view, key=""):
|
|
self.view = view
|
|
self.key = key
|
|
self.phantoms = []
|
|
|
|
def __del__(self):
|
|
for p in self.phantoms:
|
|
self.view.erase_phantom_by_id(p.id)
|
|
|
|
def update(self, new_phantoms):
|
|
# Update the list of phantoms that exist in the text buffer with their
|
|
# current location
|
|
regions = self.view.query_phantoms([p.id for p in self.phantoms])
|
|
for i in range(len(regions)):
|
|
self.phantoms[i].region = regions[i]
|
|
|
|
for p in new_phantoms:
|
|
try:
|
|
# Phantom already exists, copy the id from the current one
|
|
idx = self.phantoms.index(p)
|
|
p.id = self.phantoms[idx].id
|
|
except ValueError:
|
|
p.id = self.view.add_phantom(
|
|
self.key, p.region, p.content, p.layout, p.on_navigate)
|
|
|
|
for p in self.phantoms:
|
|
# if the region is -1, then it's already been deleted, no need to
|
|
# call erase
|
|
if p not in new_phantoms and p.region != Region(-1):
|
|
self.view.erase_phantom_by_id(p.id)
|
|
|
|
self.phantoms = new_phantoms
|
|
|
|
|
|
class Html(object):
|
|
__slots__ = ['data']
|
|
|
|
def __init__(self, data):
|
|
self.data = data
|
|
|
|
def __str__(self):
|
|
return "Html(" + str(self.data) + ")"
|