def theme_data(): settings = sublime.load_settings(pref) themr = sublime.load_settings('themr.sublime-settings') packages = os.listdir(sublime.packages_path()) ignored_packages = settings.get('ignored_packages') themes = [] commands = [] for package in (package for package in packages if package.startswith('Theme -') and package not in ignored_packages): theme = os.listdir(os.path.join(sublime.packages_path(), package)) for filename in (filenames for filenames in theme if filenames.endswith('.sublime-theme')): themes.append(filename) themr.set('discovered_themes', themes) sublime.save_settings('themr.sublime-settings') for theme in themes: commands.append({'caption': 'Themr: ' + os.path.splitext(theme)[0], 'command': 'switch_theme', 'args': { 't': theme }}) commands.append({'caption': 'Themr: Reload themes', 'command': 'reload_themes'}) c = open(os.path.join(sublime.packages_path(), 'Themr', 'Default.sublime-commands'), 'w') c.write(json.dumps(commands, indent = 4) + '\n') c.close sublime.status_message('Themr: ' + str(len(themes)) + ' theme(s) found.')
def update_language_extensions(ext_added): """ Process the extensions for each language """ for lang, exts in ext_added.items(): updated = False settings_file = lang + ".sublime-settings" lang_settings = sublime.load_settings(settings_file) extension_file = sublime.load_settings(EXT_SETTINGS) lang_ext = set(lang_settings.get("extensions", [])) apsy_ext = set(extension_file.get(lang, [])) for ext in list(exts): if ext not in lang_ext: # Append extension to current sublime extension list lang_ext.add(ext) # Track which extensions were specifically added by apply syntax apsy_ext.add(ext) updated = True if updated: devlog("============" + settings_file + "============") devlog("Updated Extensions: %s" % str(lang_ext)) lang_settings.set("extensions", list(lang_ext)) if len(apsy_ext): extension_file.set(lang, sorted(list(apsy_ext))) else: extension_file.erase(sorted(lang)) sublime.save_settings(settings_file) sublime.save_settings(EXT_SETTINGS)
def api_key(self): settings = sublime.load_settings('Thesaurus.sublime-settings') if settings.get("api_key"): return settings.get("api_key") else: settings = sublime.load_settings('Preferences.sublime-settings') return settings.get("thesaurus_api_key")
def apply_setting(self, name): """Directly apply the provided theme or color scheme.""" if any(sublime.find_resources(os.path.basename(name))): sublime.load_settings(self.PREFS_FILE).set(self.KEY, name) sublime.save_settings(self.PREFS_FILE) else: sublime.status_message(name + " does not exist!")
def run_command(self, command, callback=None, show_status=True, filter_empty_args=True, no_save=False, **kwargs): if filter_empty_args: command = [arg for arg in command if arg] if 'working_dir' not in kwargs: kwargs[str('working_dir')] = str(self.get_working_dir()) if 'fallback_encoding' not in kwargs and self.active_view() and self.active_view().settings().get('fallback_encoding'): kwargs[str('fallback_encoding')] = str(self.active_view().settings().get('fallback_encoding').rpartition('(')[2].rpartition(')')[0]) s = sublime.load_settings("Git.sublime-settings") if s.get('save_first') and self.active_view() and self.active_view().is_dirty() and not no_save: self.active_view().run_command('save') if command[0] == 'git': us = sublime.load_settings('Preferences.sublime-settings') if s.get('git_command') or us.get('git_binary'): command[0] = s.get('git_command') or us.get('git_binary') elif GIT: command[0] = GIT if command[0] == 'gitk' and s.get('gitk_command'): if s.get('gitk_command'): command[0] = s.get('gitk_command') elif GITK: command[0] = GITK if command[0] == 'git' and command[1] == 'flow' and s.get('git_flow_command'): command[0] = s.get('git_flow_command') del(command[1]) if not callback: callback = self.generic_done thread = CommandThread(command, callback, **kwargs) thread.start() if show_status: message = kwargs.get('status_message', False) or ' '.join(command) sublime.status_message(message)
def plugin_loaded(): global settings settings = sublime.load_settings('LocalHistory.sublime-settings') settings.add_on_change('reload', sublime.load_settings('LocalHistory.sublime-settings')) status_msg('Target directory: "' + get_history_root() + '"')
def run(self, edit, key=None): assert(not key is None) list_to_map = lambda seq: dict([(el["from"], el["to"]) for el in seq]) if not hasattr(self, "_settings"): default_settings = sublime.load_settings("MetaSubstitution.sublime-settings") user_settings = sublime.load_settings("Preferences.sublime-settings") meta_substitutions = list_to_map(default_settings.get("meta_substitutions", [])) meta_substitutions.update(list_to_map(user_settings.get("meta_substitutions", []))) setattr(self, "_settings", meta_substitutions) selection = self.view.sel() stored_cursor_positions = [] substitute_for = None for k, v in self._settings.items(): if k == key: substitute_for = v if substitute_for is None: return for subselection in selection: if subselection.empty(): self.view.insert(edit, subselection.a, substitute_for) else: stored_cursor_positions.append(sublime.Region(subselection.begin() + 1)) self.view.replace(edit, subselection, substitute_for) if stored_cursor_positions: selection.clear() for cursor_position in new_cursor_positions: selection.add(cursor_position)
def init_plugin(): """Setup plugin variables and objects.""" global sh_thread global sh_settings # Preferences Settings pref_settings = sublime.load_settings('Preferences.sublime-settings') # Setup settings sh_settings = sublime.load_settings('scope_hunter.sublime-settings') # Setup color scheme init_color_scheme() pref_settings.clear_on_change('scopehunter_reload') pref_settings.add_on_change('scopehunter_reload', reinit_plugin) sh_settings.clear_on_change('reload') # Setup thread if sh_thread is not None: # This shouldn't be needed, but just in case sh_thread.kill() sh_thread = ShThread() sh_thread.start()
def init(self, isST2): self.isST2 = isST2 self.projects_index_cache = {} self.index_cache_location = os.path.join( sublime.packages_path(), 'User', 'AngularJS.cache' ) self.is_indexing = False self.attributes = [] self.settings = sublime.load_settings('AngularJS-sublime-package.sublime-settings') self.settings_completions = sublime.load_settings('AngularJS-completions.sublime-settings') self.settings_js_completions = sublime.load_settings('AngularJS-js-completions.sublime-settings') try: json_data = open(self.index_cache_location, 'r').read() self.projects_index_cache = json.loads(json_data) json_data.close() except: pass self.settings_completions.add_on_change('core_attribute_list', self.process_attributes) self.settings_completions.add_on_change('extended_attribute_list', self.process_attributes) self.settings_completions.add_on_change('AngularUI_attribute_list', self.process_attributes) self.settings.add_on_change('enable_data_prefix', self.process_attributes) self.settings.add_on_change('enable_AngularUI_directives', self.process_attributes) self.process_attributes()
def init(self): if self.inited: return sets = sublime.load_settings(settings_file) if get_version() < 3000: if sets.get("ha_style").startswith("underlined"): sets.set("ha_style", "outlined") if sets.get("icons"): sets.set("icons", False) if sets.get("icons_all"): sets.set("icons_all", False) sublime.save_settings(settings_file) for k in ["enabled", "style", "ha_style", "icons_all", "icons", "color_formats"]: self.settings[k] = sets.get(k) self.settings["color_fmts"] = list(map(get_format, self.settings["color_formats"])) sets.clear_on_change("ColorHighlighter") sets.add_on_change("ColorHighlighter", lambda: self.on_ch_settings_change()) sets = sublime.load_settings("Preferences.sublime-settings") self.settings["color_scheme"] = sets.get("color_scheme") sets.clear_on_change("ColorHighlighter") sets.add_on_change("ColorHighlighter", lambda: self.on_g_settings_change()) self.inited = True for w in sublime.windows(): for v in w.views(): self.init_view(v)
def is_enabled(self, save_to_file=False): enabled = True if save_to_file and not bool(sublime.load_settings(self.settings).get("enable_save_to_file_commands", False)): enabled = False elif not save_to_file and not bool(sublime.load_settings(self.settings).get("enable_show_in_buffer_commands", False)): enabled = False return enabled
def run(self): """Run command.""" errors = False full_name = path.join(FuzzyFileNavCommand.cwd, FuzzyPanelText.get_content()) FuzzyPanelText.clear_content() multi_file = ( bool(sublime.load_settings(FUZZY_SETTINGS).get("keep_panel_open_after_action", False)) and "delete" not in sublime.load_settings(FUZZY_SETTINGS).get("keep_panel_open_exceptions", []) ) if not multi_file: self.window.run_command("hide_overlay") FuzzyFileNavCommand.reset() else: FuzzyFileNavCommand.fuzzy_reload = True if sublime.ok_cancel_dialog("Delete %s?\n\nWarning: this is permanent!" % full_name): try: if path.isdir(full_name): shutil.rmtree(full_name) else: os.remove(full_name) except Exception: errors = True error("Error deleting %d!" % full_name) if multi_file: if errors: FuzzyFileNavCommand.reset() else: self.window.run_command("hide_overlay") self.window.run_command("fuzzy_file_nav", {"start": FuzzyFileNavCommand.cwd})
def run(self): """Run command.""" errors = False full_name = path.join(FuzzyFileNavCommand.cwd, FuzzyPanelText.get_content()) FuzzyPanelText.clear_content() multi_file = ( bool(sublime.load_settings(FUZZY_SETTINGS).get("keep_panel_open_after_action", False)) and "mkdir" not in sublime.load_settings(FUZZY_SETTINGS).get("keep_panel_open_exceptions", []) ) if not multi_file: self.window.run_command("hide_overlay") FuzzyFileNavCommand.reset() else: FuzzyFileNavCommand.fuzzy_reload = True try: os.makedirs(full_name) except Exception: errors = True error("Could not create %d!" % full_name) if multi_file: if errors: FuzzyFileNavCommand.reset() else: self.window.run_command("hide_overlay") self.window.run_command("fuzzy_file_nav", {"start": FuzzyFileNavCommand.cwd})
def run(self): """Run the command.""" file_name = FuzzyPanelText.get_content() FuzzyPanelText.clear_content() proj_file = self.window.project_file_name() data = self.window.project_data() if data is None: data = {} new_folder = path.join(FuzzyFileNavCommand.cwd, file_name) if not path.exists(new_folder): return if not path.isdir(new_folder): new_folder = path.dirname(new_folder) if "folders" not in data: data["folders"] = [] already_exists = self.compare(data["folders"], new_folder, proj_file) if not already_exists: true_path = get_path_true_case(new_folder) if true_path is not None: if ( sublime.load_settings(FUZZY_SETTINGS).get("add_folder_to_project_relative", False) and proj_file is not None ): new_folder = path.relpath(new_folder, path.dirname(proj_file)) follow_sym = sublime.load_settings(FUZZY_SETTINGS).get("add_folder_to_project_follow_symlink", True) data["folders"].append({'follow_symlinks': follow_sym, 'path': new_folder}) self.window.set_project_data(data) else: error("Couldn't resolve case for path %s!" % new_folder)
def paste(self): """Paste files.""" errors = False self.to_path = path.join(FuzzyFileNavCommand.cwd, FuzzyPanelText.get_content()) FuzzyPanelText.clear_content() move = (self.cls.action == "cut") self.from_path = self.cls.clips[0] self.cls.clear_entries() multi_file = ( bool(sublime.load_settings(FUZZY_SETTINGS).get("keep_panel_open_after_action", False)) and "paste" not in sublime.load_settings(FUZZY_SETTINGS).get("keep_panel_open_exceptions", []) ) if not multi_file: self.window.run_command("hide_overlay") FuzzyFileNavCommand.reset() else: FuzzyFileNavCommand.fuzzy_reload = True if path.exists(self.from_path): if path.isdir(self.from_path): self.action = shutil.copytree if not bool(move) else shutil.move errors = self.dir_copy() else: self.action = shutil.copyfile if not bool(move) else shutil.move errors = self.file_copy() if multi_file: if errors: FuzzyFileNavCommand.reset() else: self.window.run_command("hide_overlay") self.window.run_command("fuzzy_file_nav", {"start": FuzzyFileNavCommand.cwd})
def run(self, edit, option): s = sublime.load_settings('phpfmt.sublime-settings') options = { "autocomplete":"autocomplete", "autoimport":"dependency autoimport", "enable_auto_align":"auto align", "format_on_save":"format on save", "psr1":"PSR1", "psr1_naming":"PSR1 Class and Method Naming", "psr2":"PSR2", "readini":"look for .php.tools.ini", "smart_linebreak_after_curly":"smart linebreak after curly", "skip_if_ini_missing":"skip if ini file is missing", "visibility_order":"visibility order", "yoda":"yoda mode", } s = sublime.load_settings('phpfmt.sublime-settings') value = s.get(option, False) if value: s.set(option, False) msg = "phpfmt: "+options[option]+" disabled" print_debug(msg) sublime.status_message(msg) else: s.set(option, True) msg = "phpfmt: "+options[option]+" enabled" print_debug(msg) sublime.status_message(msg) sublime.save_settings('phpfmt.sublime-settings')
def run(self, edit): sortorder = '' self.settings = sublime.load_settings("CSScomb.sublime-settings") if not self.settings.has('sorter'): self.settings.set('sorter', 'local') sublime.save_settings('CSScomb.sublime-settings') if self.settings.get('custom_sort_order') == True: self.order_settings = sublime.load_settings("Order.sublime-settings") sortorder = self.order_settings.get('sort_order') sublime.status_message('Sorting with custom sort order...') selections = self.get_selections() SorterCall = self.get_sorter() threads = [] for sel in selections: selbody = self.view.substr(sel) selbody = selbody.encode('utf-8') thread = SorterCall(sel, selbody, sortorder) threads.append(thread) thread.start() self.handle_threads(edit, threads, selections, offset=0, i=0)
def do(renderer, keymap_counter): default_packages = ['Default'] user_packages = ['User'] global_settings = sublime.load_settings("Preferences.sublime-settings") ignored_packages = global_settings.get("ignored_packages", []) package_control_settings = sublime.load_settings("Package Control.sublime-settings") installed_packages = package_control_settings.get("installed_packages", []) if len(installed_packages) == 0: includes = ('.sublime-package') os_packages = [] for (root, dirs, files) in os.walk(sublime.installed_packages_path()): for file in files: if file.endswith(includes): os_packages.append(file.replace(includes, '')) for (root, dirs, files) in os.walk(sublime.packages_path()): for dir in dirs: os_packages.append(dir) break # just the top level installed_packages = [] [installed_packages.append(package) for package in os_packages if package not in installed_packages] diff = lambda l1,l2: [x for x in l1 if x not in l2] active_packages = diff( default_packages + installed_packages + user_packages, ignored_packages) keymapsExtractor = KeymapsExtractor(active_packages, keymap_counter) worker_thread = WorkerThread(keymapsExtractor, renderer) worker_thread.start() ThreadProgress(worker_thread, 'Searching ' + MY_NAME, 'Done.', keymap_counter)
def load_settings(self): self.settings = sublime.load_settings('GitGutter.sublime-settings') self.user_settings = sublime.load_settings( 'Preferences.sublime-settings') # Git Binary Setting self.git_binary_path = 'git' git_binary = self.user_settings.get( 'git_binary') or self.settings.get('git_binary') if git_binary: self.git_binary_path = git_binary # Ignore White Space Setting self.ignore_whitespace = self.settings.get('ignore_whitespace') if self.ignore_whitespace == 'all': self.ignore_whitespace = '-w' elif self.ignore_whitespace == 'eol': self.ignore_whitespace = '--ignore-space-at-eol' else: self.ignore_whitespace = '' # Patience Setting self.patience_switch = '' patience = self.settings.get('patience') if patience: self.patience_switch = '--patience' # Untracked files self.show_untracked = self.settings.get( 'show_markers_on_untracked_file')
def plugin_loaded(): global settings_base global Pref settings = sublime.load_settings('Word Highlight.sublime-settings') if int(sublime.version()) >= 2174: settings_base = sublime.load_settings('Preferences.sublime-settings') else: settings_base = sublime.load_settings('Base File.sublime-settings') class Pref: def load(self): Pref.color_scope_name = settings.get('color_scope_name', "comment") Pref.highlight_delay = settings.get('highlight_delay', 0) Pref.case_sensitive = (not bool(settings.get('case_sensitive', True))) * sublime.IGNORECASE Pref.draw_outlined = bool(settings.get('draw_outlined', True)) * sublime.DRAW_OUTLINED Pref.mark_occurrences_on_gutter = bool(settings.get('mark_occurrences_on_gutter', False)) Pref.icon_type_on_gutter = settings.get("icon_type_on_gutter", "dot") Pref.highlight_when_selection_is_empty = bool(settings.get('highlight_when_selection_is_empty', False)) Pref.highlight_word_under_cursor_when_selection_is_empty = bool(settings.get('highlight_word_under_cursor_when_selection_is_empty', False)) Pref.word_separators = settings_base.get('word_separators') Pref.show_status_bar_message = bool(settings.get('show_word_highlight_status_bar_message', True)) Pref.file_size_limit = int(settings.get('file_size_limit', 4194304)) Pref.when_file_size_limit_search_this_num_of_characters = int(settings.get('when_file_size_limit_search_this_num_of_characters', 20000)) Pref.timing = time.time() Pref.enabled = True Pref.prev_selections = None Pref.prev_regions = None Pref = Pref() Pref.load() settings.add_on_change('reload', lambda:Pref.load()) settings_base.add_on_change('wordhighlight-reload', lambda:Pref.load())
def run(self): mm_response = None args = self.get_arguments() global_config.debug('>>> running thread arguments on next line!') global_config.debug(args) if self.debug_mode or 'darwin' not in sys.platform: print(self.payload) python_path = sublime.load_settings('mavensmate.sublime-settings').get('mm_python_location') if 'darwin' in sys.platform or sublime.load_settings('mavensmate.sublime-settings').get('mm_debug_location') != None: mm_loc = sublime.load_settings('mavensmate.sublime-settings').get('mm_debug_location') else: mm_loc = os.path.join(config.mm_dir,"mm","mm.py") #p = subprocess.Popen("{0} {1} {2}".format(python_path, pipes.quote(mm_loc), args), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True) if 'linux' in sys.platform or 'darwin' in sys.platform: #osx, linux p = subprocess.Popen('\'{0}\' \'{1}\' {2}'.format(python_path, mm_loc, self.get_arguments()), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True) else: #windows if sublime.load_settings('mavensmate.sublime-settings').get('mm_debug_mode', False): #user wishes to use system python python_path = sublime.load_settings('mavensmate.sublime-settings').get('mm_python_location') p = subprocess.Popen('"{0}" "{1}" {2}'.format(python_path, mm_loc, self.get_arguments()), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True) else: python_path = os.path.join(os.environ["ProgramFiles"],"MavensMate","App","python.exe") if not os.path.isfile(python_path): python_path = python_path.replace("Program Files", "Program Files (x86)") p = subprocess.Popen('"{0}" -E "{1}" {2}'.format(python_path, mm_loc, self.get_arguments()), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True) #process = subprocess.Popen("{0} {1} {2}".format(python_path, pipes.quote(mm_loc), self.get_arguments()), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True) else: p = subprocess.Popen("{0} {1}".format(pipes.quote(self.mm_path), args), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True) #print("PAYLOAD: ",self.payload) #print("PAYLOAD TYPE: ",type(self.payload)) if self.payload != None and type(self.payload) is str: self.payload = self.payload.encode('utf-8') p.stdin.write(self.payload) p.stdin.close() if p.stdout is not None: mm_response = p.stdout.readlines() elif p.stderr is not None: mm_response = p.stderr.readlines() #response_body = '\n'.join(mm_response.decode('utf-8')) strs = [] for line in mm_response: strs.append(line.decode('utf-8')) response_body = '\n'.join(strs) global_config.debug('>>> got a response body') global_config.debug(response_body) if '--html' not in args: try: valid_json = json.loads(response_body) except: response_body = generate_error_response(response_body) self.response = response_body
def on_loaded(): global hostplatform_settings, host_settings, platform_settings, user_settings global _plugin_loaded if _plugin_loaded: debug.log("Plugin already loaded") return hostplatform_settings = sublime.load_settings( get_hostplatform_settings_filename()) host_settings = sublime.load_settings( get_host_settings_filename()) platform_settings = sublime.load_settings( get_platform_settings_filename()) user_settings = sublime.load_settings( get_settings_filename()) on_debug_change() debug.log('Registering Settings Callbacks') hostplatform_settings.add_on_change('debug', on_debug_change) user_settings.add_on_change('debug', on_debug_change) platform_settings.add_on_change('debug', on_debug_change) host_settings.add_on_change('debug', on_debug_change) if _on_plugin_loaded_callbacks is not None: for callback in _on_plugin_loaded_callbacks: callback() _plugin_loaded = True del _on_plugin_loaded_callbacks[:]
def post_match(view, name, style, first, second, center, bfr, threshold): """ Given two brackets, determine if they contain a tag. Decide whether it is an opening or closing, and then find its respective closing or opening. """ # We need to know the mode during the highlight event, so track the last mode. global last_mode left, right = first, second threshold = [0, len(bfr)] if threshold is None else threshold bh_settings = sublime.load_settings("bh_core.sublime-settings") tag_settings = sublime.load_settings("bh_tag.sublime-settings") tag_mode = get_tag_mode(view, tag_settings.get("tag_mode", [])) tag_style = tag_settings.get("tag_style", {}).get(tag_mode, '?') last_mode = tag_mode outside_adj = bh_settings.get("bracket_outside_adjacent", False) bracket_style = style if first is not None and tag_mode is not None: matcher = TagMatch(view, bfr, threshold, first, second, center, outside_adj, tag_mode) left, right = matcher.match() if not matcher.no_tag: bracket_style = tag_style return left, right, bracket_style
def run(self): error = False full_name = path.join(FuzzyFileNavCommand.cwd, FuzzyPanelText.get_content()) FuzzyPanelText.clear_content() multi_file = ( bool(sublime.load_settings(FUZZY_SETTINGS).get("keep_panel_open_after_action", False)) and "mkfile" not in sublime.load_settings(FUZZY_SETTINGS).get("keep_panel_open_exceptions", []) ) if not multi_file: self.window.run_command("hide_overlay") FuzzyFileNavCommand.reset() else: FuzzyFileNavCommand.fuzzy_reload = True try: with open(full_name, "a"): pass self.window.open_file(full_name) except: error = True sublime.error_message("Could not create %s!" % full_name) if multi_file: if error: FuzzyFileNavCommand.reset() else: self.window.run_command("fuzzy_file_nav", {"start": FuzzyFileNavCommand.cwd})
def run(self, edit, parser='markdown', target='browser'): settings = sublime.load_settings('MarkdownPreview.sublime-settings') # backup parser+target for later saves self.view.settings().set('parser', parser) self.view.settings().set('target', target) html, body = compiler.run(self.view, parser) if target in ['disk', 'browser']: # check if LiveReload ST2 extension installed and add its script to the resulting HTML livereload_installed = ('LiveReload' in os.listdir(sublime.packages_path())) # build the html if livereload_installed: port = sublime.load_settings('LiveReload.sublime-settings').get('port', 35729) html += '<script>document.write(\'<script src="http://\' + (location.host || \'localhost\').split(\':\')[0] + \':%d/livereload.js?snipver=1"></\' + \'script>\')</script>' % port # update output html file tmp_fullpath = getTempMarkdownPreviewPath(self.view) save_utf8(tmp_fullpath, html) # now opens in browser if needed if target == 'browser': self.__class__.open_in_browser(tmp_fullpath, settings.get('browser', 'default')) elif target == 'sublime': # create a new buffer and paste the output HTML embed_css = settings.get('embed_css_for_sublime_output', True) if embed_css: new_scratch_view(self.view.window(), html) else: new_scratch_view(self.view.window(), body) sublime.status_message('Markdown preview launched in sublime') elif target == 'clipboard': # clipboard copy the full HTML sublime.set_clipboard(html) sublime.status_message('Markdown export copied to clipboard')
def _toggle_debug_mode(setting=None): if setting is not None: if isinstance(setting, tuple): settings_name = setting[0] + '.sublime-settings' preferences = load_settings(settings_name) setting = setting[1] else: settings_name = 'Preferences.sublime-settings' preferences = load_settings(settings_name) flag = not preferences.get(setting) if flag: preferences.set(setting, True) else: preferences.erase(setting) save_settings(settings_name) return flag else: global _DEBUG _DEBUG = not _DEBUG _set_debug_mode(_DEBUG) return _DEBUG
def load_settings(self): self.settings = sublime.load_settings('GitGutter.sublime-settings') self.user_settings = sublime.load_settings('Preferences.sublime-settings') self.git_binary_path = 'git' git_binary = self.user_settings.get('git_binary') or self.settings.get('git_binary') if git_binary: self.git_binary_path = git_binary
def __init__(self, window): RdioCommand.__init__(self,window) self.just_opened = True self.typed = "" self.last_content = "" self.suggestion_selector = "→" self.selected_suggestion_index = None self.input_view_width = 0 # Two way producer / consumer self.last_sent_query = "" self.query_q = Queue() self.suggestion_q = Queue() self.suggestions = [] self.END_OF_SUGGESTIONS = '' self.STOP_THREAD_MESSAGE = 'END_OF_THREAD_TIME' # passed as a query to stop the thread settings = sublime.load_settings("Preferences.sublime-settings") self.user_tab_complete_value = settings.get("tab_completion", None) rdio_settings = sublime.load_settings("Rdio.sublime-settings") self.enable_search_suggestions = rdio_settings.get("enable_search_suggestions")
def update_url_highlights(self, view, force): settings = sublime.load_settings(UrlHighlighter.SETTINGS_FILENAME) if not force and not settings.get('auto_find_urls', True): return should_highlight_urls = settings.get('highlight_urls', True) max_url_limit = settings.get('max_url_limit', UrlHighlighter.DEFAULT_MAX_URLS) file_folder_regex = settings.get('file_folder_regex', '') combined_regex = '({})|({})'.format(UrlHighlighter.URL_REGEX, file_folder_regex) if file_folder_regex else UrlHighlighter.URL_REGEX if view.id() in UrlHighlighter.ignored_views: return urls = view.find_all(combined_regex) # Avoid slowdowns for views with too much URLs if len(urls) > max_url_limit: print("UrlHighlighter: ignoring view with %u URLs" % len(urls)) UrlHighlighter.ignored_views.append(view.id()) return UrlHighlighter.urls_for_view[view.id()] = urls should_highlight_urls = sublime.load_settings(UrlHighlighter.SETTINGS_FILENAME).get('highlight_urls', True) if (should_highlight_urls): self.highlight_urls(view, urls)
def run(self, version="default"): AutoHotKeyExePath = "" AutoHotKeyExePath = sublime.load_settings("AutoHotkey.sublime-settings").get("AutoHotKeyExePath")[version] # Also try old settings format where path is stored as a named-key in a dictionary. if not os.path.isfile(AutoHotKeyExePath): print("AutoHotkey ahkexec.py run(): Trying default version, because could not find AutoHotKeyExePath for version=" + str(version)) AutoHotKeyExePath = sublime.load_settings("AutoHotkey.sublime-settings").get("AutoHotKeyExePath")["default"] # Also try old settings format where path is stored as a list of paths if not os.path.isfile(AutoHotKeyExePath): print("AutoHotkey ahkexec.py run(): Trying string list (without dictionary key-pairs old format), because could not find AutoHotKeyExePath for version=" + str(version) + " or version=default") AutoHotKeyExePathList = sublime.load_settings("AutoHotkey.sublime-settings").get("AutoHotKeyExePath") for AutoHotKeyExePath in AutoHotKeyExePathList: if os.path.isfile(AutoHotKeyExePath): print ("Not valid AutoHotKeyExePath=" + AutoHotKeyExePath) break else: print ("Not valid AutoHotKeyExePath=" + AutoHotKeyExePath) continue if not os.path.isfile(AutoHotKeyExePath): print(r"ERROR: AutoHotkey ahkexec.py run(): Could not find AutoHotKeyExePath. Please create a Data\Packages\User\AutoHotkey.sublime-settings file to specify your custom path.") else: filepath = self.window.active_view().file_name() cmd = [AutoHotKeyExePath, "/ErrorStdOut", filepath] regex = "(.*) \(([0-9]*)\)() : ==> (.*)" self.window.run_command("exec", {"cmd": cmd, "file_regex": regex})
def get_ignored_packages(): __settings = sublime.load_settings(SETTINGS_USER_FILE) custom_packages = [] for ignored_package in __settings.get('ignore_packages'): custom_packages.append(ignored_package) return custom_packages
def run(self, edit): prefs = sublime.load_settings('Preferences.sublime-settings') prefs.set('tailwind_completion_enabled', False) prefs.save_settings('Preferences.sublime-settings')
def is_installed_by_package_control(): """Check if installed by package control.""" settings = sublime.load_settings('Package Control.sublime-settings') return str(__pc_name__ in set(settings.get('installed_packages', [])))
def disable_packages(self, packages, type='upgrade'): """ Disables one or more packages before installing or upgrading to prevent errors where Sublime Text tries to read files that no longer exist, or read a half-written file. :param packages: The string package name, or an array of strings :param type: The type of operation that caused the package to be disabled: - "upgrade" - "remove" - "install" - "disable" - "loader" """ if not isinstance(packages, list): packages = [packages] disabled = [] settings = sublime.load_settings(preferences_filename()) ignored = load_list_setting(settings, 'ignored_packages') pc_settings = sublime.load_settings(pc_settings_filename()) in_process = load_list_setting(pc_settings, 'in_process_packages') self.old_syntaxes = {} self.old_color_schemes = {} for package in packages: if not package in ignored: in_process.append(package) ignored.append(package) disabled.append(package) if type in ['upgrade', 'remove']: version = self.get_version(package) tracker_type = 'pre_upgrade' if type == 'upgrade' else type events.add(tracker_type, package, version) for window in sublime.windows(): for view in window.views(): view_settings = view.settings() syntax = view_settings.get('syntax') if syntax.find('Packages/' + package + '/') != -1: if package not in self.old_syntaxes: self.old_syntaxes[package] = [] self.old_syntaxes[package].append([view, syntax]) view_settings.set('syntax', 'Packages/Text/Plain text.tmLanguage') scheme = view_settings.get('color_scheme') if scheme.find('Packages/' + package + '/') != -1: if package not in self.old_color_schemes: self.old_color_schemes[package] = [] self.old_color_schemes[package].append([view, scheme]) view_settings.set('color_scheme', 'Packages/Color Scheme - Default/Monokai.tmTheme') # Change the color scheme before disabling the package containing it if settings.get('color_scheme').find('Packages/' + package + '/') != -1: self.old_color_scheme_package = package self.old_color_scheme = settings.get('color_scheme') settings.set('color_scheme', 'Packages/Color Scheme - Default/Monokai.tmTheme') # Change the theme before disabling the package containing it if package_file_exists(package, settings.get('theme')): self.old_theme_package = package self.old_theme = settings.get('theme') settings.set('theme', 'Default.sublime-theme') # We don't mark a package as in-process when disabling it, otherwise # it automatically gets re-enabled the next time Sublime Text starts if type != 'disable': pc_settings.set('in_process_packages', in_process) sublime.save_settings(pc_settings_filename()) settings.set('ignored_packages', ignored) sublime.save_settings(preferences_filename()) return disabled
def reenable_package(self, package, type='upgrade'): """ Re-enables a package after it has been installed or upgraded :param package: The string package name :param type: The type of operation that caused the package to be re-enabled: - "upgrade" - "remove" - "install" - "enable" - "loader" """ settings = sublime.load_settings(preferences_filename()) ignored = load_list_setting(settings, 'ignored_packages') if package in ignored: if type in ['install', 'upgrade']: version = self.get_version(package) tracker_type = 'post_upgrade' if type == 'upgrade' else type events.add(tracker_type, package, version) events.clear(tracker_type, package, future=True) if type == 'upgrade': events.clear('pre_upgrade', package) elif type == 'remove': events.clear('remove', package) settings.set('ignored_packages', list(set(ignored) - set([package]))) sublime.save_settings(preferences_filename()) if type == 'remove' and self.old_theme_package == package: sublime.message_dialog(u"Package Control\n\n" + u"Your active theme was just removed and the Default " + u"theme was enabled in its place. You may see some " + u"graphical corruption until you restart Sublime Text.") # By delaying the restore, we give Sublime Text some time to # re-enable the package, making errors less likely def delayed_settings_restore(): if type == 'upgrade' and package in self.old_syntaxes: for view_syntax in self.old_syntaxes[package]: view, syntax = view_syntax view.settings().set('syntax', syntax) if type == 'upgrade' and package in self.old_color_schemes: for view_scheme in self.old_color_schemes[package]: view, scheme = view_scheme view.settings().set('color_scheme', scheme) if type == 'upgrade' and self.old_theme_package == package: settings.set('theme', self.old_theme) sublime.message_dialog(u"Package Control\n\n" + u"Your active theme was just upgraded. You may see some " + u"graphical corruption until you restart Sublime Text.") if type == 'upgrade' and self.old_color_scheme_package == package: settings.set('color_scheme', self.old_color_scheme) sublime.save_settings(preferences_filename()) sublime.set_timeout(delayed_settings_restore, 1000) pc_settings = sublime.load_settings(pc_settings_filename()) in_process = load_list_setting(pc_settings, 'in_process_packages') if package in in_process: in_process.remove(package) pc_settings.set('in_process_packages', in_process) sublime.save_settings(pc_settings_filename())
def plugin_loaded(): Schemr.preferences = sublime.load_settings('Preferences.sublime-settings') Schemr.favorites = sublime.load_settings('SchemrFavorites.sublime-settings') print('schemr ready')
def get_setting(self,string,view=None): if view and view.settings().get(string): return view.settings().get(string) else: return sublime.load_settings('autofilename.sublime-settings').get(string)
def on_done(i): if i >= 0: settings = sublime.load_settings( "Preferences.sublime-settings") settings.set("dictionary", items[i]) sublime.save_settings("Preferences.sublime-settings")
def settings(self): '''plugin settings, lazy loading for API readiness''' if self.__settings is None: self.__settings = sublime.load_settings(SETTINGS_FILE) return self.__settings
def get_setting(self, attr): settings = sublime.load_settings('MarkdownTOC.sublime-settings') return settings.get(attr)
def is_enabled(self): return not sublime.load_settings("Preferences.sublime-settings").get( 'show_definitions')
class HighlightDodgyChars(sublime_plugin.EventListener): def getSettings(): global users_whitelist settings = sublime.load_settings('HighlightDodgyChars.sublime-settings') users_whitelist = settings.get('whitelist_chars')
def get_settings(): ret = sublime.load_settings("sublime-open-command.sublime-settings") return ret
def complete_auto_match(self, view, edit, insert_char): ''' Completes brackets if auto_match is enabled; also implements the "smart_bracket_auto_trigger" logic, which tries to complete the nearest open bracket intelligently. :param view: the current view :param edit: the current edit :param insert_char: the character to try to automatch ''' if sublime.load_settings('Preferences.sublime-settings').get( 'auto_match_enabled', True): # simple case: we have an insert char, insert closing char, # if its defined if insert_char: self.insert_at_end(view, edit, self.get_match_char(insert_char)) # if the insert_char is a bracket, move cursor to middle of # bracket and return if insert_char in self.MATCH_CHARS: new_regions = [] for sel in view.sel(): if not sel.empty(): new_regions.append(sel) else: new_point = sel.end() - 1 new_regions.append(getRegion(new_point, new_point)) self.update_selections(view, new_regions) return elif get_setting('smart_bracket_auto_trigger', True): # more complex: if we do not have an insert_char, try to close # the nearest bracket that occurs before each selection new_regions = [] for sel in view.sel(): word_region = self.get_current_word(view, sel) close_bracket = self.get_closing_bracket(view, word_region) # we should close the bracket if close_bracket: # insert the closing bracket view.insert(edit, word_region.end(), close_bracket) if sel.empty(): if word_region.empty(): new_regions.append( getRegion(word_region.end(), word_region.end())) else: new_point = word_region.end() + len( close_bracket) new_regions.append( getRegion(new_point, new_point)) else: new_regions.append( getRegion( sel.begin(), word_region.end() + len(close_bracket))) else: new_regions.append(sel) self.update_selections(view, new_regions)
def on_pre_save(self, view): settings = sublime.load_settings("Rubyfmt.sublime-settings") if settings.get("format_on_save", False): view.run_command("format_code")
def run(self): sublime.active_window().run_command('hide_popup') s = sublime.load_settings("Preferences.sublime-settings") toggle_setting(s, 'show_definitions') sublime.save_settings("Preferences.sublime-settings")
def get_setting(view_settings, key, default_value): defaults = sublime.load_settings('Breadcrumbs.sublime-settings') return view_settings.get(key, defaults.get(key, default_value))
def __init__(self, view): self.settings = sublime.load_settings("Rubyfmt.sublime-settings") self.view = view
def run( self, cmd=None, shell_cmd=None, file_regex="", line_regex="", working_dir="", encoding="utf-8", env={}, quiet=False, kill=False, update_phantoms_only=False, hide_phantoms_only=False, word_wrap=True, syntax="Packages/Text/Plain text.tmLanguage", # Catches "path" and "shell" **kwargs): if update_phantoms_only: if self.show_errors_inline: self.update_phantoms() return if hide_phantoms_only: self.hide_phantoms() return # clear the text_queue self.text_queue_lock.acquire() try: self.text_queue.clear() self.text_queue_proc = None finally: self.text_queue_lock.release() if kill: if self.proc: self.proc.kill() self.proc = None self.append_string(None, "[Cancelled]") return if not hasattr(self, 'output_view'): # Try not to call get_output_panel until the regexes are assigned self.output_view = self.window.create_output_panel("exec") # Default the to the current files directory if no working directory was given if working_dir == "" and self.window.active_view( ) and self.window.active_view().file_name(): working_dir = os.path.dirname( self.window.active_view().file_name()) self.output_view.settings().set("result_file_regex", file_regex) self.output_view.settings().set("result_line_regex", line_regex) self.output_view.settings().set("result_base_dir", working_dir) self.output_view.settings().set("word_wrap", word_wrap) self.output_view.settings().set("line_numbers", False) self.output_view.settings().set("gutter", False) self.output_view.settings().set("scroll_past_end", False) self.output_view.assign_syntax(syntax) # Call create_output_panel a second time after assigning the above # settings, so that it'll be picked up as a result buffer self.window.create_output_panel("exec") self.encoding = encoding self.quiet = quiet self.proc = None if not self.quiet: if shell_cmd: print("Running " + shell_cmd) elif cmd: print("Running " + " ".join(cmd)) sublime.status_message("Building") show_panel_on_build = sublime.load_settings( "Preferences.sublime-settings").get("show_panel_on_build", True) if show_panel_on_build: self.window.run_command("show_panel", {"panel": "output.exec"}) self.hide_phantoms() self.show_errors_inline = sublime.load_settings( "Preferences.sublime-settings").get("show_errors_inline", True) merged_env = env.copy() if self.window.active_view(): user_env = self.window.active_view().settings().get('build_env') if user_env: merged_env.update(user_env) # Change to the working dir, rather than spawning the process with it, # so that emitted working dir relative path names make sense if working_dir != "": os.chdir(working_dir) self.debug_text = "" if shell_cmd: self.debug_text += "[shell_cmd: " + shell_cmd + "]\n" else: self.debug_text += "[cmd: " + str(cmd) + "]\n" self.debug_text += "[dir: " + str(os.getcwd()) + "]\n" if "PATH" in merged_env: self.debug_text += "[path: " + str(merged_env["PATH"]) + "]" else: self.debug_text += "[path: " + str(os.environ["PATH"]) + "]" try: # Forward kwargs to AsyncProcess self.proc = AsyncProcess(cmd, shell_cmd, merged_env, self, **kwargs) self.text_queue_lock.acquire() try: self.text_queue_proc = self.proc finally: self.text_queue_lock.release() except Exception as e: self.append_string(None, str(e) + "\n") self.append_string(None, self.debug_text + "\n") if not self.quiet: self.append_string(None, "[Finished]")
def make_breadcrumbs(view, current_row, shorten=False): if len(view.sel()) == 0: return [] tab_size = get_tab_size(view) settings = sublime.load_settings('Breadcrumbs.sublime-settings') breadcrumb_length_limit = settings.get('breadcrumb_length_limit', 100) def get_row_start(row): return view.text_point(row, 0) def get_points_by_row(row): return xrange(get_row_start(row), get_row_start(row + 1)) if is_white_row(view, get_points_by_row(current_row)): while 0 <= current_row and is_white_row(view, get_points_by_row(current_row)): current_row -= 1 if current_row < 0: return [] indentation = get_row_indentation(get_row_start(current_row), view, tab_size) + 1 else: indentation = get_row_indentation(get_row_start(current_row), view, tab_size) current_row -= 1 breadcrumbs = [] last_line_start = view.text_point(current_row + 1, 0) while 0 <= current_row and 0 < indentation: line_start = get_row_start(current_row) line_end = last_line_start last_line_start = line_start current_indentation = get_row_indentation(line_start, view, tab_size, indentation) if current_indentation < indentation and not is_white_row(view, xrange(line_start, line_end)): indentation = current_indentation this_breadcrumb = get_breadcrumb(view, line_start, line_end, get_regex(view.settings()), breadcrumb_length_limit) if this_breadcrumb is not None: breadcrumbs.append(this_breadcrumb) current_row -= 1 breadcrumbs.reverse() if shorten: total_breadcrumbs_length_limit = settings.get('total_breadcrumbs_length_limit', 200) lengths = [len(breadcrumb) for breadcrumb in breadcrumbs] sorted_lengths = sorted(lengths) previous_length = 0 number_of_characters_left = max(0, total_breadcrumbs_length_limit - len(lengths) * len(get_separator(view.settings()))) for (number_of_shorter, current_length) in enumerate(sorted_lengths): if previous_length < current_length: previous_length = current_length number_of_not_shorter = len(breadcrumbs) - number_of_shorter if number_of_characters_left < current_length * number_of_not_shorter: length_of_short_trim = number_of_characters_left // number_of_not_shorter length_of_long_trim = length_of_short_trim + 1 number_of_long_trimmed = number_of_characters_left % number_of_not_shorter number_of_short_trimmed = number_of_not_shorter - number_of_long_trimmed for (index_of_breadcrumb, breadcrum_length) in enumerate(lengths): if current_length <= breadcrum_length: if 0 < number_of_short_trimmed: length_of_trim = length_of_short_trim number_of_short_trimmed -= 1 else: length_of_trim = length_of_long_trim breadcrumbs[index_of_breadcrumb] = breadcrumbs[index_of_breadcrumb][0:length_of_trim] break number_of_characters_left -= current_length return breadcrumbs
def Settings(): """ 动态获取配置文件 """ return sublime.load_settings("Pandoc.sublime-settings")
def get_settings(): return sublime.load_settings('FocusGroup.sublime-settings')
def load_last_run(self): self.load_config() s = sublime.load_settings("RubyTest.last-run") return (s.get("last_test_run"), s.get("last_test_working_dir"))
def run(self, settings): s = sublime.load_settings(settings) s.set('color_pick_return', True)
def __init__(self): self.settings = sublime.load_settings("RubyTest.sublime-settings")
def plugin_loaded(): global s s = sublime.load_settings("JsFormat.sublime-settings")
def plugin_unloaded(): # noqa: D401 """Called when plugin is getting unloaded.""" if Settings(sublime.load_settings(COLOR_HIGHLIGHTER_SETTINGS_NAME)).debug: print("ColorHighlighter: action=stop st=%s" % (st_helper.st_version())) ColorHighlighterPlugin.deinit()
def save_test_run(self, command, working_dir): s = sublime.load_settings("RubyTest.last-run") s.set("last_test_run", command) s.set("last_test_working_dir", working_dir) sublime.save_settings("RubyTest.last-run")
def provide_color_scheme(self): # pylint: disable=no-self-use """Provide a current color scheme.""" settings = sublime.load_settings(PREFERENCES_SETTINGS_NAME) # pylint: disable=assignment-from-none color_scheme = settings.get("color_scheme", None) return color_scheme
def run(self): self.settings = sublime.load_settings('Help.sublime-settings') if not self.settings.has('urls'): self.settings.set('urls',defaultSettings) sublime.save_settings('Help.sublime-settings') self.list_urls();