def __init__(self): if not hasattr(self, "setting") is None: self.setting = {} if platform.system() == 'Windows': self.dirSep = "\\" else: self.dirSep = '/' self.setting['file_path'] = self.dirSep + "User" + self.dirSep + "memTask.json" self.stopTimer = True self.fileName = False self.fileView = False self.totalTime = { 'fromLastCommit': 0 } self.finish = False if not sublime.version() or int(sublime.version()) > 3000: # Sublime Text 3 timeout = 1000 else: timeout = 0 sublime.set_timeout(lambda: self.finish_init(), timeout)
def __init__(self, view, syntax=None): self.platform = sublime.platform() self.classmap = {} self.st_version = 2 if sublime.version() == '' or int(sublime.version()) > 3000: self.st_version = 3 self.file_name = view.file_name() self.settings = sublime.load_settings('CodeFormatter.sublime-settings') self.packages_path = sublime.packages_path() self.syntax_file = view.settings().get('syntax') self.syntax = syntax or self.get_syntax() # map of settings names with related class map_settings_formatter = [ ('codeformatter_php_options', PhpFormatter), ('codeformatter_js_options', JsFormatter), ('codeformatter_css_options', CssFormatter), ('codeformatter_html_options', HtmlFormatter), ('codeformatter_python_options', PyFormatter), ('codeformatter_vbscript_options', VbscriptFormatter), ('codeformatter_scss_options', ScssFormatter), ('codeformatter_coldfusion_options', ColdfusionFormatter), ] for name, _class in map_settings_formatter: syntaxes = self.settings.get(name, {}).get('syntaxes') if not syntaxes or not isinstance(syntaxes, str): continue for _formatter in syntaxes.split(','): self.classmap[_formatter.strip()] = _class
def __init__(self, view=False, file_name=False, syntax=False): self.platform = sublime.platform() self.classmap = { "php": PhpFormatter, "javascript": JsFormatter, "json": JsFormatter, "html": HtmlFormatter, "asp": HtmlFormatter, "xml": HtmlFormatter, "css": CssFormatter, "less": CssFormatter, "python": PyFormatter, } self.st_version = 2 if sublime.version() == "" or int(sublime.version()) > 3000: self.st_version = 3 self.syntax_file = view.settings().get("syntax") if syntax == False: self.syntax = self.getSyntax() else: self.syntax = syntax self.file_name = file_name self.settings = sublime.load_settings("CodeFormatter.sublime-settings") self.packages_path = sublime.packages_path()
def run(self, edit): if int(sublime.version()) >= 3000: org_sel = list(self.view.sel()) for region in self.view.sel(): expand_selection_around(self.view, region, r'(".*?"|\'.*?\'|%Q{.*?})') for region in self.view.sel(): if region.size() == 0: continue selected = self.view.substr(region) if selected[0] == '"': inner = selected[1:-1] inner = re.sub(r"[^\\]\'", lambda m: re.sub("'", "\\'", m.group(0)), inner) inner = re.sub(r'\\"', '"', inner) replace = "'" + inner + "'" elif selected[0] == "'": inner = selected[1:-1] inner = re.sub(r"\\'", "'", inner) inner = re.sub(r'\\"', '"', inner) replace = "%Q{" + inner + "}" elif selected[0] == "%": inner = selected[3:-1] inner = re.sub(r'[^\\]"', lambda m: re.sub('"', '\\"', m.group(0)), inner) inner = re.sub(r"\\'", "'", inner) replace = '"' + inner + '"' else: return self.view.replace(edit, region, replace) if int(sublime.version()) >= 3000: self.view.sel().clear() self.view.sel().add_all(org_sel)
def check_dependencies(): if sublime.version() > "3000" and 'Package Control' in sys.modules: package_control = sys.modules['Package Control'].package_control elif sublime.version() < "3000" and 'package_control' in sys.modules: package_control = sys.modules['package_control'] else: sublime.set_timeout(check_dependencies, 20) return manager = package_control.package_manager.PackageManager() required_dependencies = set(manager.find_required_dependencies()) class myPackageCleanup(package_control.package_cleanup.PackageCleanup): def finish(self, installed_packages, found_packages, found_dependencies): missing_dependencies = required_dependencies - set(found_dependencies) if len(missing_dependencies) == 0: touch("success") kill_subl() else: sublime.set_timeout(_check_dependencies, 20) def _check_dependencies(): myPackageCleanup().run() _check_dependencies()
def run(self, package_name, source, items): # Reload current file first if not in root dir if os.path.dirname(source): if sublime.version()[0] == "3": modulename = package_name + "." + (source.replace(os.sep, ".")[:-3] if source[-11:] != "__init__.py" else source.replace(os.sep, ".")[:-12]) else: modulename = os.path.join(package_dir, source) # Reload the file sublime_plugin.reload_plugin(modulename) print("Package Reloader - Reloading %s" % package_name) # Load modules for item in items: if sublime.version()[0] == "3": modulename = package_name + "." + (item.replace("/", ".")[:-3] if item[-11:] != "__init__.py" else item.replace("/", ".")[:-12]) else: modulename = os.path.join(package_dir, item) sublime_plugin.reload_plugin(modulename) # Clean up multiple callbacks for key, value in sublime_plugin.all_callbacks.items(): items = {} for item in value: name = item.__module__ + '.' + item.__class__.__name__ # Save item connected with the name if name in items: items[name] += [item] else: items[name] = [item] sublime_plugin.all_callbacks[key] = [value[0] for key, value in items.items()]
def run(self, edit): if int(sublime.version()) >= 3000: org_sel = list(self.view.sel()) for region in self.view.sel(): expand_selection_around(self.view, region, r'(".*?"|\'.*?\'|:\w+)') for region in self.view.sel(): if region.size() == 0: continue selected = self.view.substr(region) if selected[0] == '"': inner = selected[1:-1] replace = ":" + inner elif selected[0] == "'": inner = selected[1:-1] replace = ":" + inner elif selected[0] == ":": inner = selected[1:] replace = '"' + inner + '"' else: return self.view.replace(edit, region, replace) if int(sublime.version()) >= 3000: self.view.sel().clear() self.view.sel().add_all(org_sel)
def __init__(self, view=False, file_name=False, syntax=False): self.platform = sublime.platform() self.classmap = { 'php': PhpFormatter, 'javascript': JsFormatter, 'json': JsFormatter, 'html': HtmlFormatter, 'asp': HtmlFormatter, 'xml': HtmlFormatter, 'css': CssFormatter, 'less': CssFormatter, 'python': PyFormatter } self.st_version = 2 if sublime.version() == '' or int(sublime.version()) > 3000: self.st_version = 3 self.syntax_file = view.settings().get('syntax') if syntax == False: self.syntax = self.getSyntax() else: self.syntax = syntax self.file_name = file_name self.settings = sublime.load_settings('CodeFormatter.sublime-settings') self.packages_path = sublime.packages_path()
def get_gutter_mark(self): """ Returns gutter mark icon or empty string if marks are disabled. """ # ST does not expect platform specific paths here, but only # forward-slash separated paths relative to "Packages" self.gutter_mark_success = '/'.join( [settings.mark_themes_dir, 'success'] ) if int(sublime.version()) >= 3014: self.gutter_mark_success += '.png' self.gutter_mark = '' mark_type = settings.gutter_marks if mark_type in ('dot', 'circle', 'bookmark', 'cross'): self.gutter_mark = mark_type elif mark_type.startswith('theme-'): theme = mark_type[6:] if theme not in ('alpha', 'bright', 'dark', 'hard', 'simple'): log("unknown gutter mark theme: '{0}'".format(mark_type)) return # ST does not expect platform specific paths here, but only # forward-slash separated paths relative to "Packages" self.gutter_mark = '/'.join( [settings.mark_themes_dir, '{0}-{{0}}'.format(theme)] ) if int(sublime.version()) >= 3014: self.gutter_mark += '.png'
def backup_with_prompt_on_done(path): global prompt_parameters if os.path.exists(path) == True: if sublime.version()[0] == "2": if sublime.ok_cancel_dialog( "Backup already exists @ %s \nReplace it?" % path, "Continue") == True: prompt_parameters["operation_to_perform"](path) else: tools.packagesync_cancelled() else: confirm_override = sublime.yes_no_cancel_dialog( "Backup already exists @ %s \nReplace it?" % path, "Continue") if confirm_override == sublime.DIALOG_YES: prompt_parameters["operation_to_perform"](path) elif sublime.version()[0] == "3" and confirm_override == sublime.DIALOG_NO: prompt_parameters["initial_text"] = path prompt_for_location() else: tools.packagesync_cancelled() elif os.path.isabs(os.path.dirname(path)) == True: prompt_parameters["operation_to_perform"](path) else: sublime.error_message("Please provide a valid path for backup.") prompt_parameters["initial_text"] = path prompt_for_location()
def __init__(self, view=False, file_name=False, syntax=False, saving=False): self.platform = sublime.platform() self.classmap = {} self.st_version = 2 if sublime.version() == "" or int(sublime.version()) > 3000: self.st_version = 3 self.file_name = file_name self.settings = sublime.load_settings("CodeFormatter.sublime-settings") self.packages_path = sublime.packages_path() self.syntax_file = view.settings().get("syntax") if syntax == False: self.syntax = self.getSyntax() else: self.syntax = syntax self.saving = saving # PHP opts = self.settings.get("codeformatter_php_options") if "syntaxes" in opts and opts["syntaxes"]: for _formatter in opts["syntaxes"].split(","): self.classmap[_formatter.strip()] = PhpFormatter # Javascript opts = self.settings.get("codeformatter_js_options") if "syntaxes" in opts and opts["syntaxes"]: for _formatter in opts["syntaxes"].split(","): self.classmap[_formatter.strip()] = JsFormatter # CSS opts = self.settings.get("codeformatter_css_options") if "syntaxes" in opts and opts["syntaxes"]: for _formatter in opts["syntaxes"].split(","): self.classmap[_formatter.strip()] = CssFormatter # HTML opts = self.settings.get("codeformatter_html_options") if "syntaxes" in opts and opts["syntaxes"]: for _formatter in opts["syntaxes"].split(","): self.classmap[_formatter.strip()] = HtmlFormatter # Python opts = self.settings.get("codeformatter_python_options") if "syntaxes" in opts and opts["syntaxes"]: for _formatter in opts["syntaxes"].split(","): self.classmap[_formatter.strip()] = PyFormatter # VBScript opts = self.settings.get("codeformatter_vbscript_options") if "syntaxes" in opts and opts["syntaxes"]: for _formatter in opts["syntaxes"].split(","): self.classmap[_formatter.strip()] = VbscriptFormatter # SCSS opts = self.settings.get("codeformatter_scss_options") if "syntaxes" in opts and opts["syntaxes"]: for _formatter in opts["syntaxes"].split(","): self.classmap[_formatter.strip()] = PyFormatter
def is_compatible_version(version_range): min_version = float("-inf") max_version = float("inf") if version_range == '*': return True gt_match = re.match('>(\d+)$', version_range) ge_match = re.match('>=(\d+)$', version_range) lt_match = re.match('<(\d+)$', version_range) le_match = re.match('<=(\d+)$', version_range) range_match = re.match('(\d+) - (\d+)$', version_range) if gt_match: min_version = int(gt_match.group(1)) + 1 elif ge_match: min_version = int(ge_match.group(1)) elif lt_match: max_version = int(lt_match.group(1)) - 1 elif le_match: max_version = int(le_match.group(1)) elif range_match: min_version = int(range_match.group(1)) max_version = int(range_match.group(2)) else: return None if min_version > int(sublime.version()): return False if max_version < int(sublime.version()): return False return True
def run(self): self.window.run_command('hide_panel'); if int(sublime.version()) >= 2136: self.window.run_command("show_panel", {"panel": "find_in_files", "where":"<open folders>"}) elif int(sublime.version()) >= 2134: self.window.run_command("show_panel", {"panel": "find_in_files", "where":""}) else: self.window.run_command("show_panel", {"panel": "find_in_files", "location":"<open folders>"})
def __init__(me, cmd, env, listener, path="", shell=False): threading.Thread.__init__(me, name="cssondiet") me.finished = False me.exitcode = 0 me.listener = listener output = None try: idx = cmd.index("-o") output = cmd[idx+1] except: output = False minify = "-m" in cmd inputfile = cmd[-1] if output == False or output == inputfile: output = inputfile+".css" class an_argument(object): def __init__(me, input, output="-", minify=False ): me.cod_files = [ input ] me.output = output me.no_comments = False me.no_header = False me.minify_css = minify me.args = an_argument( inputfile, output, minify ) print("Actually running embedded COD script with inputfile=%s, " \ "output=%s, minify=%s from %s package\n" % \ ( inputfile, output, str(minify), PACKAGeDIR) ) me.start_time = time.time() try: if sublime.version()[0] == "2": script_dir = os.path.join( sublime.packages_path(), PACKAGeDIR ) #me.read_stderr("script_dir: %s\n" % script_dir ) fp, pathname, description = imp.find_module("cod", [ script_dir ] ) try: me.cod_module = imp.load_module("cod", fp, pathname, description) finally: if fp: fp.close() elif sublime.version()[0] == "3": sublimemodule = __import__("CSS-On-Diet") me.cod_module = sublimemodule.cod except ImportError: me.read_stderr("[Error loading embedded COD preprocessor]\n") me.finished = True if me.listener: me.listener.on_finished(me) return me.start()
def get_pygments(style): """ Get pygments style. Subllime CSS support is limited. It cannot handle well things like: `.class1 .class2`, but it can handle things like: `.class1.class2`. So we will not use things like `.highlight` in front. We will first find {...} which has no syntax class. This will contain our background and possibly foreground. If for whatever reason we have no background or foreground, we will use `#000000` or `#ffffff` respectively. """ try: # Lets see if we can find the pygments theme text = HtmlFormatter(style=style).get_style_defs(".dummy") text = re_missing_semi_colon.sub("; }", text) except Exception: return "" bg = None fg = None # Find {...} which has no syntax classes m = re_base_colors.search(text) if m: # Find background m1 = re_bgcolor.search(m.group(1)) if m1: # Use `background-color` as it works better # with Sublime CSS bg = m1.group(1).replace("background", "background-color") # Find foreground m1 = re_color.search(m.group(1)) if m1: fg = m1.group(1) # Use defaults if None found if bg is None: bg = "background-color: #ffffff" if fg is None: fg = "color: #000000" # Reassemble replacing .highlight {...} with .codehilite, .inlinehilite {...} # All other classes will be left bare with only their syntax class. code_blocks = CODE_BLOCKS_LEGACY if int(sublime.version()) < 3119 else CODE_BLOCKS if m: css = clean_css((text[: m.start(0)] + (code_blocks % (bg, fg)) + text[m.end(0) :] + "\n")) else: css = clean_css(((code_blocks % (bg, fg)) + "\n" + text + "\n")) if int(sublime.version()) < 3119: return css.replace(".dummy ", "") else: return re_pygments_selectors.sub(r".mdpopups .highlight \1, .mdpopups .inline-highlight \1", css)
def __init__(self, s): self.package = s['package'] self.output = s['output'] if 'output' in s else None if 'syntax_test' in s and sublime.version() >= "3000": self.syntax_test = s['syntax_test'] else: self.syntax_test = False if 'coverage' in s and sublime.version() >= "3103": self.coverage = s['coverage'] else: self.coverage = False
def run(self, edit): view = self.view window = sublime.active_window() if(int(sublime.version()) >= 3000): # ST3 - use project data project_data = window.project_data() utils = _projectPHPClassUtils( project_data.get('folders')[0].get('path') ) else: utils = _projectPHPClassUtils( window.folders()[0] ) if( utils.is_browser_view(view) != True ): return point = view.sel()[0] if(point.begin() == point.end()): return window.focus_view(view) word = view.substr(view.word(point)) line = view.substr(view.line(point)) methodname = None if( line.startswith('\t') or re.match('\s+', line, re.IGNORECASE) ): methodname = word regionbefore = sublime.Region(0,point.end()) lineregions = view.split_by_newlines(regionbefore) clindex = len( lineregions ) - 1 # for lineregion in lineregions: classname = None while( classname == None and clindex >= 0 ): line = view.substr(lineregions[clindex]) clindex -= 1 if(line.startswith('\t') == False and not re.match('\s+', line, re.IGNORECASE) ): classname = line else: classname = word classname = classname.split('\n')[0].strip() if(len(classname)>0): try: if(utils.get_num_panels() == 2): if(view.name() == 'PHP Class Methods'): # in methods view. open file definition self._open_file_definition(window, utils, classname, methodname) else: # in classes view. update methods view methodview = utils.find_methods_view() rootPath = window.folders()[0] if(int(sublime.version()) >= 3000): project_data = window.project_data() rootPath = project_data.get('folders')[0].get('path') args = {"rootPath" : rootPath, "group": 2, "classname": classname} methodview.run_command("fill_browser_view", { "args": args }) else: # all in one... go, go, go! self._open_file_definition(window, utils, classname, methodname) except: sublime.status_message('Unknown Class Name: '+str(classname))
def is_visible(self): st_version = 2 # Warn about out-dated versions of ST3 if sublime.version() == '': st_version = 3 print('Package Control: Please upgrade to Sublime Text 3 build 3012 or newer') elif int(sublime.version()) > 3000: st_version = 3 if st_version == 3 : return False return True
def sanity_check(env={}, error_log=False): if not env: env = sh.env() ns = '(not set)' sl = [ ('install state', _inst_state()), ('sublime.version', sublime.version()), ('sublime.channel', sublime.channel()), ('about.ann', gs.attr('about.ann', '')), ('about.version', gs.attr('about.version', '')), ('version', about.VERSION), ('platform', about.PLATFORM), ('~bin', '%s' % gs.home_dir_path('bin')), ('margo.exe', '%s (%s)' % _tp(_margo_bin())), ('go.exe', '%s (%s)' % _tp(sh.which('go') or 'go')), ('go.version', sh.GO_VERSION), ('GOROOT', '%s' % env.get('GOROOT', ns)), ('GOPATH', '%s' % env.get('GOPATH', ns)), ('GOBIN', '%s (should usually be `%s`)' % (env.get('GOBIN', ns), ns)), ('set.shell', str(gs.lst(gs.setting('shell')))), ('env.shell', env.get('SHELL', '')), ('shell.cmd', str(sh.cmd('${CMD}'))), ] if error_log: try: with open(gs.home_path('log.txt'), 'r') as f: s = f.read().strip() sl.append(('error log', s)) except Exception: pass return sl
def run_shell_command(self, command, working_dir): if not command: return False if BEFORE_CALLBACK: os.system(BEFORE_CALLBACK) if AFTER_CALLBACK: command += " ; " + AFTER_CALLBACK self.save_test_run(command, working_dir) if COMMAND_PREFIX: command = COMMAND_PREFIX + ' ' + command if int(sublime.version().split('.')[0]) <= 2: command = [command] if USE_TERMINAL: trm=OpenInTerminal() trm.run(working_dir, command) else: self.view.window().run_command("exec", { "cmd": command, "shell": True, "working_dir": working_dir, "file_regex": r"([^ ]*\.rb):?(\d*)", "encoding": TERMINAL_ENCODING }) self.display_results() return True
def plugin_loaded(): if DEBUG: UTC_TIME = datetime.utcnow() PYTHON = sys.version_info[:3] VERSION = sublime.version() PLATFORM = sublime.platform() ARCH = sublime.arch() PACKAGE = sublime.packages_path() INSTALL = sublime.installed_packages_path() message = ( 'Jekyll debugging mode enabled...\n' '\tUTC Time: {time}\n' '\tSystem Python: {python}\n' '\tSystem Platform: {plat}\n' '\tSystem Architecture: {arch}\n' '\tSublime Version: {ver}\n' '\tSublime Packages Path: {package}\n' '\tSublime Installed Packages Path: {install}\n' ).format(time=UTC_TIME, python=PYTHON, plat=PLATFORM, arch=ARCH, ver=VERSION, package=PACKAGE, install=INSTALL) sublime.status_message('Jekyll: Debugging enabled...') debug('Plugin successfully loaded.', prefix='\n\nJekyll', level='info') debug(message, prefix='Jekyll', level='info')
def prepare_data(self, view, data): """Prepare the returned data """ st_version = int(sublime.version()) show_tooltip = get_settings(view, 'enable_signatures_tooltip', True) show_doc = get_settings(view, 'merge_signatures_and_doc', True) if data['success'] and 'No docstring' not in data['doc']: if show_tooltip and show_doc and st_version >= 3070: self.doc = '<br>'.join(data['doc'].split('<br>')[2:]) if not show_tooltip or st_version < 3070: self.signature = data['doc'].splitlines()[2] else: self.signature = data['doc'].split('<br>')[0] if ('(' in self.signature and self.signature.split('(')[0].strip() not in self.exclude): if self.signature is not None and self.signature != '': if show_tooltip: return self._show_popup(view) return self._show_status(view) if st_version >= 3070: if view.is_popup_visible(): view.hide_popup() view.erase_status('anaconda_doc')
def is_enabled(self): try: import mdpopups except Exception: return False return (mdpopups.version() >= (1, 7, 3)) and (int(sublime.version()) >= 3118)
def sublime_text_3(): """Returns True if this is Sublime Text 3 """ try: return int(sublime.version()) >= 3000 except ValueError: return sys.hexversion >= 0x030000F0
def read_package_file(package, relative_path, binary=False): """ Reads the contents of a file that is part of a package :param package: The name of the package to read from :param relative_path: The path to the file, relative to the package root :param binary: If the contents should be read as a byte string instead of a unicode string :return: A unicode or byte string (depending on value if binary param) or False on error """ if relative_path is None: return False package_dir = _get_package_dir(package) if os.path.exists(package_dir) and _regular_file_exists(package, relative_path): return _read_regular_file(package, relative_path, binary) if int(sublime.version()) >= 3000: result = _read_zip_file(package, relative_path, binary) if result is not False: return result return False
def package_file_exists(package, relative_path): """ Determines if a file exists inside of the package specified. Handles both packed and unpacked packages. :param package: The name of the package to look in :param relative_path: The path to the file, relative to the package root :return: A bool - if the file exists """ if relative_path is None: return False package_dir = _get_package_dir(package) if os.path.exists(package_dir): result = _regular_file_exists(package, relative_path) if result: return result if int(sublime.version()) >= 3000: return _zip_file_exists(package, relative_path) return False
def list_packages(self, unpacked_only=False): """ :param unpacked_only: Only list packages that are not inside of .sublime-package files :return: A list of all installed, non-default, package names """ package_names = os.listdir(sublime.packages_path()) package_names = [path for path in package_names if os.path.isdir(os.path.join(sublime.packages_path(), path))] if int(sublime.version()) > 3000 and unpacked_only == False: package_files = os.listdir(sublime.installed_packages_path()) package_names += [f.replace('.sublime-package', '') for f in package_files if re.search('\.sublime-package$', f) != None] # Ignore things to be deleted ignored = ['User'] for package in package_names: cleanup_file = os.path.join(sublime.packages_path(), package, 'package-control.cleanup') if os.path.exists(cleanup_file): ignored.append(package) packages = list(set(package_names) - set(ignored) - set(self.list_default_packages())) packages = sorted(packages, key=lambda s: s.lower()) return packages
def run(self): self.old_view = ng.active_view() try: self.definition_List = ng.get_current_project_indexes().get('definitions') except: self.definition_List = None if ng.is_indexing: return if not self.definition_List: ng.active_window().run_command('angularjs_file_index') return self.current_window = ng.active_window() self.current_view = ng.active_view() self.current_file = self.current_view.file_name() self.current_file_location = self.current_view.sel()[0].end() formated_definition_list = [] for item in self.definition_List: current_definition = [ item[0], [item[1].replace(path,'') for path in ng.active_window().folders()][0][1:] ] formated_definition_list.append(current_definition); if int(sublime.version()) >= 3000 and ng.settings.get('show_file_preview'): self.current_window.show_quick_panel(formated_definition_list, self.on_done, False, -1, self.on_highlight) else: self.current_window.show_quick_panel(formated_definition_list, self.on_done)
def underline_regions(self, view, scope_name, regions): if sublime.version() >= '3019': # in Sublime Text 3, the regions are just underlined flags = ( sublime.DRAW_NO_FILL | sublime.DRAW_NO_OUTLINE | sublime.DRAW_SOLID_UNDERLINE ) view.add_regions( SCOPE_PREFIX + scope_name, regions, scope_name, flags=flags ) else: # in Sublime Text 2, the 'empty region underline' hack is used char_regions = [ sublime.Region(pos, pos) for region in regions for pos in range(region.a, region.b) ] view.add_regions( SCOPE_PREFIX + scope_name, char_regions, scope_name, sublime.DRAW_EMPTY_AS_OVERWRITE)
def _on_done(): buf = StringIO() for item in results: tabulate(item, output=buf) new_view = sublime.active_window().new_file() new_view.set_scratch(True) new_view.settings().set('word_wrap', False) new_view.settings().set('line_numbers', False) new_view.settings().set('gutter', False) new_view.set_name('LaTeXTools System Check') if sublime.version() < '3103': new_view.settings().set( 'syntax', 'Packages/LaTeXTools/system_check.hidden-tmLanguage' ) else: new_view.settings().set( 'syntax', 'Packages/LaTeXTools/system_check.sublime-syntax' ) new_view.set_encoding('UTF-8') new_view.run_command( 'latextools_insert_text', {'text': buf.getvalue().rstrip()} ) new_view.set_read_only(True) buf.close()
def __init__(self): if int(sublime.version()) < 4050: self._is_overlay_panel = self._is_overlay_panel_heuristic self._overlay_panel_open = False self._zip_view_awaiting_panel_close = None
def is_ST2(): return sublime.version().startswith('2')
'cli': '--jsx-bracket-same-line', 'default': 'false' }, { 'option': 'parser', 'cli': '--parser', 'default': 'babylon' }, { 'option': 'semi', 'cli': '--semi', 'default': 'true' }] ALLOWED_FILE_EXTENSIONS = [ 'js', 'jsx', ] IS_SUBLIME_TEXT_LATEST = int(sublime.version()) >= 3000 class JsPrettierCommand(sublime_plugin.TextCommand): _error_message = None @property def debug(self): return self.get_setting('debug', False) @property def has_error(self): if not self._error_message: return False return True
def is_st3(): return sublime.version()[0] == '3'
from collections import defaultdict, deque try: import sublime import sublime_plugin from sublime import status_message, error_message except ImportError: # running tests import sys from tests.sublime_fake import sublime from tests.sublime_fake import sublime_plugin sys.modules['sublime'] = sublime sys.modules['sublime_plugin'] = sublime_plugin if sublime.version().startswith('2'): import ctags from ctags import (FILENAME, parse_tag_lines, PATH_ORDER, SYMBOL, TagElements, TagFile) from helpers.edit import Edit else: # safe to assume if not ST2 then ST3 from CTags import ctags from CTags.ctags import (FILENAME, parse_tag_lines, PATH_ORDER, SYMBOL, TagElements, TagFile) from CTags.helpers.edit import Edit """ Contants """ OBJECT_PUNCTUATORS = { 'class': '.',
import sublime, sublime_plugin, time, os.path, json, threading, sys, socket, time from threading import Thread try: import socketserver except ImportError: import SocketServer as socketserver VERSION = "Takana plugin v0.4" DEBUG = False TAKANA_SERVER_PORT = 48628 st_ver = 3000 if sublime.version() == '' else int(sublime.version()) print("***************************************") print(VERSION) class Error: region_key = 'error_dot' def __init__(self, file, line): self.file = file self.line = line self.view = None def update_view(self, view): self.clear() self.view = view self.show() def show(self):
# coding: utf-8 import sublime import sys import os st_version = 2 if sublime.version() == '': st_version = 3 print('Joomla Pack: Please upgrade to Sublime Text 3 build 3012 or newer') elif int(sublime.version()) > 3000: st_version = 3 if st_version == 3: installed_dir, _ = __name__.split('.') elif st_version == 2: installed_dir = os.path.basename(os.getcwd()) # Ensure the user has installed Joomla Pack properly if installed_dir != 'JoomlaPack': message = ("Joomla Pack\n\nThis package appears to be installed " + "incorrectly.\n\nIt should be installed as \"JoomlaPack\", " + "but seems to be installed as \"%s\".\n\n" % installed_dir) # If installed unpacked if os.path.exists(os.path.join(sublime.packages_path(), installed_dir)): message += ("Please use the Preferences > Browse Packages... menu " + "entry to open the \"Packages/\" folder and rename" + "\"%s/\" to \"JoomlaPack/\" " % installed_dir) # If installed as a .sublime-package file else: message += ("Please use the Preferences > Browse Packages... menu " +
import sublime import sublime_plugin DEFAULT_MAX_FILE_SIZE = 1048576 DEFAULT_COLOR_SCOPE_NAME = "invalid" DEFAULT_IS_ENABLED = True DEFAULT_CHECK_SPACES = True DEFAULT_SINGLE_SPACE = False DEFAULT_CHECK_EOL = True DEFAULT_CHECK_TABS = True DEFAULT_CHECK_MIXED = True DEFAULT_LAST_WHITESPACE = False hws_toggled = False hws_v3 = (int(sublime.version()) >= 3000) def plugin_loaded(): global hws_v3 if is_enabled(True) and hws_v3: highlight_whitespaces(sublime.active_window().active_view()) def is_enabled(init=False): global hws_toggled if init: hws_toggled = bool(get_settings().get('highlight_whitespaces_enabled', DEFAULT_IS_ENABLED))
if os.path.isfile(file_path): os.remove(file_path) sublime.save_settings("Package Syncing.sublime-settings") sublime.status_message( "sync_folder successfully set to \"%s\"" % path) # sublime.run_command("pkg_sync", { "mode": ["pull", "push"], "override": override }) else: sublime.error_message("Invalid Path %s" % path) self.window.show_input_panel("Sync Folder", sync_folder, on_done, None, None) def plugin_loaded(): sublime.set_timeout( lambda: sublime.run_command("pkg_sync", {"mode": ["pull", "push"]}), 2000) def plugin_unloaded(): tools.stop_watcher() if sublime.version()[0] == "2": plugin_loaded()
import sublime import sublime_plugin ###---------------------------------------------------------------------------- st_version = int(sublime.version()) ###---------------------------------------------------------------------------- class OverrideAuditOpenFileCommand(sublime_plugin.WindowCommand): """ A proxy for the default open_file command that will hide itself from the menu/command palette in newer versions of Sublime Text. """ def run(self, **kwargs): self.window.run_command("open_file", kwargs) def is_visible(self, file, contents=None): return st_version < 3124 ###---------------------------------------------------------------------------- class OverrideAuditEditSettingsCommand(sublime_plugin.WindowCommand): """ A proxy for the default edit_settings command that will hide itself from
from __future__ import print_function import sublime import sublime_plugin import re if sublime.version() < '3000': _ST3 = False else: _ST3 = True SECTION_TYPES = ['part', 'chapter', 'section', 'subsection', 'subsubsection', 'paragraph', 'subparagraph'] def get_begin_mark_patter(sec_type): return r'\\' + sec_type + r'\*?(?:\[.*\])?\{.*\}(?:\s*%\s\(fold\))?' def get_end_mark_patter(sec_type): return r'%\s*' + sec_type + r'.*\s*\(end\)' # Find top level's mark name in this buffer # return None if find failed def find_top_level(view): top_level = None for i in SECTION_TYPES: regions = view.find_all(get_begin_mark_patter(i)) if len(regions) == 0: continue else: top_level = i break return top_level
def load(self): if not sublime.version().startswith('3'): raise Exception("Not Sublime 3!")
import zipfile PACKAGE_NAME = 'SublimeTmpl' TMLP_DIR = 'templates' KEY_SYNTAX = 'syntax' KEY_FILE_EXT = 'extension' BASE_PATH = os.path.abspath( os.path.dirname(__file__)) #Installed Packages/xx.sublime-package PACKAGES_PATH = sublime.packages_path() # for ST2 # sys.path += [BASE_PATH] # sys.path.append(BASE_PATH) # import sys;print(sys.path) IS_GTE_ST3 = int(sublime.version()[0]) >= 3 class SublimeTmplCommand(sublime_plugin.TextCommand): def run(self, edit, type='html'): view = self.view opts = self.get_settings(type) tmpl = self.get_code(type) # print(KEY_SYNTAX in opts) self.tab = self.creat_tab(view) self.set_syntax(opts) self.set_code(tmpl) def get_settings(self, type=None):
def generate_colour_scheme(self, view, generate=True): # make sure we have hex AND we're >= ST3 (load_resource doesn't work in ST2) colour_removed = sbs_settings().get('remove_colour', 'invalid.illegal') colour_added = sbs_settings().get('add_colour', 'string') colour_modified_deletion = sbs_settings().get( 'modified_colour_deletion', 'support.class') colour_modified_addition = sbs_settings().get( 'modified_colour_addition', 'support.class') colour_unmodified_deletion = sbs_settings().get( 'unmodified_colour_deletion', 'invalid.illegal') colour_unmodified_addition = sbs_settings().get( 'unmodified_colour_addition', 'string') colour_text = sbs_settings().get('text_colour', '') notHex = False for col in [ colour_removed, colour_added, colour_modified_deletion, colour_modified_addition, colour_unmodified_deletion, colour_unmodified_addition ]: if not '#' in col: notHex = True if int(sublime.version()) < 3000 or notHex: return { 'removed': colour_removed, 'added': colour_added, 'modified_deletion': colour_modified_deletion, 'modified_addition': colour_modified_addition, 'unmodified_deletion': colour_unmodified_deletion, 'unmodified_addition': colour_unmodified_addition } # generate theme strings colourStrings = {} colourHexes = {} for col in [['removed', colour_removed], ['added', colour_added], ['modified_deletion', colour_modified_deletion], ['modified_addition', colour_modified_addition], ['unmodified_deletion', colour_unmodified_deletion], ['unmodified_addition', colour_unmodified_addition]]: colourStrings[col[0]] = 'comparison.' + col[0] colourHexes[col[0]] = col[1] # generate modified theme if generate: # load current scheme current_scheme = view.settings().get('color_scheme') # no 'u' >:( try: scheme = sublime.load_resource(current_scheme) except: # sometimes load_resource can fail (seemingly on OSX when upgrading from ST2->ST3) # manually re-selecting the colour scheme once should fix this for good (see issue #31) sublime.message_dialog( 'Could not load colour scheme.\nFalling back to a blank colour scheme.\n\nTo fix this, please manually re-select your colour scheme in\n\tPreferences > Color Scheme\n\nThis should not happen again once action has been taken.\nSorry for the inconvenience.' ) scheme = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><dict><key>settings</key><array></array></dict></plist>' # determine if scheme is using the new .sublime-color-scheme json format scheme_json = False try: scheme = sublime.decode_value(scheme) scheme_json = True except: scheme_json = False # create format specific data if scheme_json: for name in colourStrings: string = colourStrings[name] chex = colourHexes[name] scheme['rules'].append({ "name": name, "scope": string, "background": chex, "foreground": colour_text }) data = json.dumps(scheme) else: xml = '' xml_tmpl = '<dict><key>name</key><string>{}</string><key>scope</key><string>{}</string><key>settings</key><dict><key>background</key><string>{}</string><key>foreground</key><string>{}</string></dict></dict>' dropzone = scheme.rfind('</array>') # loop through colours and generate their xml for name in colourStrings: string = colourStrings[name] chex = colourHexes[name] xml += xml_tmpl.format('Comparison ' + name, string, chex, colour_text) # combiiiiiiiiiiiiine data = scheme[:dropzone] + xml + scheme[dropzone:] # determine theme filename # relative for settings, absolute for writing to file # replacing slashes for relative path necessary on windows # completely separate filenames are necessary to avoid json erroneously taking precedence theme_name = 'SBSCompareTheme.tmTheme' if scheme_json: theme_name = 'SBSCompareScheme.sublime-color-scheme' abs_theme_file = os.path.join(sublime.packages_path(), 'User', theme_name) rel_theme_file = os.path.join( os.path.basename(sublime.packages_path()), 'User', theme_name) rel_theme_file = rel_theme_file.replace('\\', '/') # save new theme try: with open(abs_theme_file, 'w', encoding='utf-8') as f: f.write(data) except: sublime.message_dialog( 'Could not write theme file.\nPlease ensure that your Sublime config directory is writeable and restart Sublime.\n\nFull path:\n' + abs_theme_file) # save filename for later use (if we rerun this without regenerating) self.last_theme_file = rel_theme_file # set view settings to use new theme view.settings().set('color_scheme', self.last_theme_file) return colourStrings
# -*- coding: UTF-8 -*- import errno import sublime import sublime_plugin if int(sublime.version()) < 3000: from sublime_haskell_common import is_enabled_haskell_command, call_and_wait_with_input, SublimeHaskellTextCommand else: from SublimeHaskell.sublime_haskell_common import is_enabled_haskell_command, call_and_wait_with_input, SublimeHaskellTextCommand class SublimeHaskellStylish(SublimeHaskellTextCommand): def run(self, edit): try: regions = [] for region in self.view.sel(): regions.append(sublime.Region(region.a, region.b)) if region.empty(): selection = sublime.Region(0, self.view.size()) else: selection = region sel_str = self.view.substr(selection).replace('\r\n', '\n') exit_code, out, err = call_and_wait_with_input( ['stylish-haskell'], sel_str) out_str = out.replace('\r\n', '\n') if exit_code == 0 and out_str != sel_str: self.view.replace(edit, selection, out_str) self.view.sel().clear() for region in regions:
import sublime import os import sys if sublime.platform() == 'linux' and '3000' > sublime.version() > '2000': path = os.path.join(sublime.packages_path(), 'Codecs26', 'lib') if path not in sys.path: sys.path.append(path) else: print('Warning: Codecs26 is working for Sublime Text 2 on linux only')
# -*- coding: utf-8 -*- import os.path import sublime import sublime_plugin STVER = int(sublime.version()) ST3 = STVER >= 3000 def get(key, default=None): """Get a value from GitGutter.sublime-settings. This function provides secure access to the package settings by loading the settings file on demand. Arguments: key (string): The setting to read. default (any): The value to return if 'key' is not available. Returns: any: The value from settings file if loaded and key exists or the default value provided from the caller. """ try: settings = get.settings except AttributeError: settings = sublime.load_settings('GitGutter.sublime-settings') get.settings = settings return settings.get(key, default)
deleted = delete_trailing_regions(self.view, edit) if deleted: if ts_settings.get("trailing_spaces_save_after_trim") \ and not ts_settings.get("trailing_spaces_trim_on_save"): sublime.set_timeout(lambda: self.save(self.view), 10) msg_parts = { "nbRegions": deleted, "plural": 's' if deleted > 1 else '' } message = "Deleted %(nbRegions)s trailing spaces region%(plural)s" % msg_parts else: message = "No trailing spaces to delete!" sublime.status_message(message) def save(self, view): if view.file_name() is None: view.run_command('prompt_save_as') else: view.run_command('save') # ST3 features a plugin_loaded hook which is called when ST's API is ready. # # We must therefore call our init callback manually on ST2. It must be the last # thing in this plugin (thanks, beloved contributors!). if not int(sublime.version()) > 3000: plugin_loaded()
# -*- coding: utf-8 -*- import sublime_plugin import sublime import re import webbrowser from itertools import chain from .hyper_click.path_resolver import HyperClickPathResolver ST3118 = int(sublime.version()) >= 3118 if ST3118: class HyperClickAnnotator(sublime_plugin.ViewEventListener): @classmethod def is_applicable(cls, settings): syntax = settings.get('syntax', None) if not syntax: return False plugin_settings = sublime.load_settings( 'hyper_click.sublime-settings') annotations_enabled = plugin_settings.get('annotations_enabled') if not annotations_enabled: return False supported_syntaxes = plugin_settings.get('supported_syntaxes') aggregated_systaxes = list( chain.from_iterable(supported_syntaxes.values())) for s in aggregated_systaxes: if syntax.endswith(s): return True return False
'stippled_underline': sublime.DRAW_STIPPLED_UNDERLINE | UNDERLINE_FLAGS, 'none': sublime.HIDDEN } UNDERLINE_STYLES = ( 'solid_underline', 'squiggly_underline', 'stippled_underline' ) SOME_WS = re.compile(r'\s') FALLBACK_MARK_STYLE = 'outline' WS_ONLY = re.compile(r'^\s+$') MULTILINES = re.compile('\n') # Sublime > 4074 supports underline styles on white space # https://github.com/sublimehq/sublime_text/issues/137 SUBLIME_SUPPORTS_WS_SQUIGGLES = int(sublime.version()) > 4074 State = { 'active_view': None, 'current_sel': tuple(), 'idle_views': set(), 'quiet_views': set(), 'views': set() } # type: State_ def plugin_loaded(): State.update({ 'active_view': sublime.active_window().active_view(), 'idle_views': set() })
import sublime import sublime_plugin import re import sys import collections ST3 = sublime.version() >= '3000' try: from . import inflection except ValueError: # HACK: for ST2 compatability import inflection # SECTION: FUNCTIONS WITHOUT SIDE EFFECTS THAT ARE USED TO COMPOSE COMMANDS def isa(*types): return lambda x: isinstance(x, types) iterable = isa(collections.Iterable) def offset_region(region, offset): return sublime.Region(region.a + offset, region.b + offset) def order_regions(regions): order = lambda r: (r.begin(), r.end()) return sorted(regions, key=order)
# coding:utf-8 # import os import re import sublime from unittest import TestCase VERSION = sublime.version() class TestBase(TestCase): """Super class includes common settings and functions. This class doesn't include any tests.""" def setUp(self): self.view = sublime.active_window().new_file() # make sure we have a window to work with s = sublime.load_settings("Preferences.sublime-settings") s.set("close_windows_when_empty", False) def tearDown(self): if self.view: # close file self.view.set_scratch(True) self.view.window().focus_view(self.view) self.view.window().run_command("close_file") # ----- def setText(self, string): self.view.run_command("insert", {"characters": string}) def getRow(self, row): return self.view.substr(self.view.line(self.view.text_point(row, 0)))
import sys import sublime if int(sublime.version()) >= 3114: __all__ = ["AfiRevertCommand", "plugin_loaded", "plugin_unloaded"] # Clear module cache to force reloading all modules of this package. prefix = __package__ + "." # don't clear the base package for module_name in [ module_name for module_name in sys.modules if module_name.startswith(prefix) and module_name != __name__ ]: del sys.modules[module_name] prefix = None from .core.cleaning import AfiRevertCommand, clean_all from .core.settings import add_listener, clear_listener from .core.utils.overlay import disable_overlay, enable_overlay def plugin_loaded(): def plugin_loaded_async(): add_listener() enable_overlay() sublime.set_timeout_async(plugin_loaded_async) def plugin_unloaded(): is_upgrading = False was_removed = False
// Auto add extensions to language settings file in User folder. // Do not manually remove "apply_syntax_extensions" from the settings file. // "extenstions" are ignored by "match": "all" setting. "add_exts_to_lang_settings": true, // Control level of logging in the console. // (true|false|"verbose") "debug": true, // Put your custom syntax rules here: "syntaxes": [ ] } ''' USE_ST_SYNTAX = int(sublime.version()) >= 3084 PLUGIN_NAME = 'ApplySyntax' PLUGIN_DIR = "Packages/%s" % PLUGIN_NAME PLUGIN_SETTINGS = PLUGIN_NAME + '.sublime-settings' EXT_SETTINGS = PLUGIN_NAME + ".ext-list" ST_LANGUAGES = ('.sublime-syntax', '.tmLanguage') if USE_ST_SYNTAX else ('.tmLanguage',) SETTINGS = {} LANG_HASH = 0 # Call back for whether view(s) have been touched on_touched_callback = None def ensure_user_settings(): """Create a default 'User' settings file for ApplySyntax if it doesn't exist."""
import sublime import sublime_plugin try: from .format_date import FormatDate, UnknownTimeZoneError # ST3 except ValueError: from format_date import FormatDate, UnknownTimeZoneError # ST2 ST2 = int(sublime.version()) < 3000 if not ST2: basestring = str # Global variables fdate = FormatDate() # Global settings object s = None # Print tracebacks DEBUG = False def status(msg, e=None): msg = "[InsertDate] " + msg sublime.status_message(msg) if e is not None: msg += "\n%s: %s" % (type(e).__name__, e) print(msg) if e and DEBUG: import traceback traceback.print_exc()
import sublime from unittest import TestCase version = sublime.version() class TestJSExamples(TestCase): def setUp(self): self.view = sublime.active_window().new_file() # make sure we have a window to work with s = sublime.load_settings("Preferences.sublime-settings") s.set("close_windows_when_empty", False) def tearDown(self): if self.view: self.view.set_scratch(True) self.view.window().run_command("close_file") def setText(self, string): self.view.run_command("insert", {"characters": string}) def goToLine(self, line): self.view.run_command("goto_line", {"line": line}) def getRow(self, row): return self.view.substr( self.view.line(self.view.text_point(row - 1, 0))) def test_align_js1(self): string = """var x = { foo: "hello",
# ST2/ST3 compat from __future__ import print_function import sublime if sublime.version() < '3000': # we are on ST2 and Python 2.X _ST3 = False import getTeXRoot import parseTeXlog from latextools_plugin import (add_plugin_path, get_plugin, NoSuchPluginException, _classname_to_internal_name) from latextools_utils.is_tex_file import is_tex_file from latextools_utils import get_setting from latextools_utils.tex_directives import parse_tex_directives from latextools_utils.external_command import (execute_command, external_command, get_texpath, update_env) from latextools_utils.output_directory import (get_aux_directory, get_output_directory, get_jobname) from latextools_utils.progress_indicator import ProgressIndicator from latextools_utils.sublime_utils import (get_project_file_name, parse_json_with_comments) from latextools_utils.utils import run_on_main_thread strbase = basestring else: _ST3 = True from . import getTeXRoot from . import parseTeXlog
import os import json import re import shutil import codecs import string import random import MavensMate.config as config import MavensMate.lib.apex.apex_extensions as apex_extensions import sublime import subprocess from xml.dom.minidom import parse settings = sublime.load_settings('mavensmate.sublime-settings') packages_path = sublime.packages_path() sublime_version = int(float(sublime.version())) debug = config.debug def standard_object_names(): return [ "Account", "Opportunity", "Contact", "Lead", "Pricebook2", "Product" ] def get_friendly_platform_key(): friendly_platform_map = { 'darwin': 'osx', 'win32': 'windows', 'linux2': 'linux',
import re import time # Modules for expression evaluation import math import random import sublime import sublime_plugin # Compatability ST3 = int(sublime.version()) > 3000 if ST3: basestring = str module_name = "Insert Nums" # Utility functions #################### def int_or_float(value): try: return int(value) if value is not None else None except ValueError: return float(value) def num_to_alpha(num, length=0): res = ''
def create_comparison(view1_contents, view2_contents, syntax, name1_override=False, name2_override=False): view1_syntax = syntax view2_syntax = syntax # make new window active_window.run_command('new_window') new_window = sublime.active_window() new_window.set_layout({ "cols": [0.0, 0.5, 1.0], "rows": [0.0, 1.0], "cells": [[0, 0, 1, 1], [1, 0, 2, 1]] }) if int(sublime.version()) >= 3000: if sbs_settings().get('hide_sidebar', False): new_window.set_sidebar_visible(False) if sbs_settings().get('hide_menu', False): new_window.set_menu_visible(False) if sbs_settings().get('hide_minimap', False): new_window.set_minimap_visible(False) if sbs_settings().get('hide_status_bar', False): new_window.set_status_bar_visible(False) if sbs_settings().get('hide_tabs', False): new_window.set_tabs_visible(False) else: if sbs_settings().get('hide_sidebar', False): new_window.run_command('toggle_side_bar') if sbs_settings().get('hide_menu', False): new_window.run_command('toggle_menu') # view names view_prefix = sbs_settings().get('display_prefix', '') view2_name = name2_override view1_name = 'untitled' if active_view.file_name(): view1_name = active_view.file_name() elif active_view.name(): view1_name = active_view.name() if name1_override != False: view1_name = name1_override name1base = os.path.basename(view1_name) name2base = os.path.basename(view2_name) if name1base == name2base: dirname1 = os.path.dirname(view1_name) dirname2 = os.path.dirname(view2_name) path_prefix = os.path.commonprefix([dirname1, dirname2]) if path_prefix != '': path_prefix = path_prefix.replace('\\', '/') path_prefix = path_prefix.split( '/')[:-1] # leave last directory in path path_prefix = '/'.join(path_prefix) + '/' plen = len(path_prefix) dirname1 = dirname1[plen:] dirname2 = dirname2[plen:] separator = ' - ' if int(sublime.version()) >= 3000: separator = ' — ' view1_name = name1base + separator + dirname1 view2_name = name2base + separator + dirname2 if dirname1 == dirname2: view1_name = name1base view2_name = name2base else: view1_name = name1base view2_name = name2base view1_name += ' (active)' view2_name += ' (other)' # view 1 new_window.run_command('new_file') new_window.run_command('insert_view', {'string': view1_contents}) new_window.active_view().set_syntax_file(view1_syntax) new_window.active_view().set_name(view_prefix + view1_name) new_window.active_view().set_scratch(True) view1 = new_window.active_view() # view 2 new_window.run_command('new_file') new_window.run_command('insert_view', {'string': view2_contents}) new_window.active_view().set_syntax_file(view2_syntax) new_window.active_view().set_name(view_prefix + view2_name) # move view 2 to group 2 new_window.set_view_index(new_window.active_view(), 1, 0) new_window.active_view().set_scratch(True) view2 = new_window.active_view() # keep track of these views view1.settings().set("is_sbs_compare", True) view2.settings().set("is_sbs_compare", True) # disable word wrap view1.settings().set('word_wrap', 'false') view2.settings().set('word_wrap', 'false') # generate and set colour scheme self.colours = self.generate_colour_scheme(view1) self.generate_colour_scheme(view2, generate=False) # run diff self.compare_views(view1, view2) # make readonly new_window.focus_view(view1) if sbs_settings().get('read_only', False): new_window.active_view().set_read_only(True) new_window.focus_view(view2) if sbs_settings().get('read_only', False): new_window.active_view().set_read_only(True) # activate scroll syncer ViewScrollSyncer(new_window, [view1, view2]) # move views to top left view1.set_viewport_position((0, 0), False) view2.set_viewport_position((0, 0), False) # move cursors to top left origin = view.text_point(0, 0) view1.sel().clear() view1.sel().add(sublime.Region(origin)) view1.show(origin) view2.sel().clear() view2.sel().add(sublime.Region(origin)) view2.show(origin) # focus first view new_window.focus_view(view1)