def cycle(self): sublimeSettings = sublime.load_settings('Preferences.sublime-settings') config = getattr(self.settings, self.getDayOrNight()) if sublimeSettings is None: raise Exception('Preferences not loaded') sublimeSettingsChanged = False compareWith = newColorScheme = config.get('color_scheme') # color scheme name matching in Sublime Text 3 if pyVersion == 3 and newColorScheme.startswith(ST2_THEME_PREFIX) and newColorScheme.endswith(ST2_THEME_SUFFIX): compareWith = (ST3_THEME_PREFIX + newColorScheme.replace(ST2_THEME_PREFIX, '').replace(ST2_THEME_SUFFIX, '') + ST3_THEME_SUFFIX) if newColorScheme and compareWith != sublimeSettings.get('color_scheme'): logToConsole('Switching to {0}'.format(newColorScheme)) sublimeSettings.set('color_scheme', newColorScheme) sublimeSettingsChanged = True newTheme = config.get('theme') if newTheme and newTheme != sublimeSettings.get('theme'): logToConsole('Switching to {0}'.format(newTheme)) sublimeSettings.set('theme', newTheme) sublimeSettingsChanged = True if sublimeSettingsChanged: sublime.save_settings('Preferences.sublime-settings')
def on_done(self, index): saved_layouts = self.settings.get('saved_layouts') if index != -1: saved_layouts.pop(index) self.settings.set('saved_layouts', saved_layouts) sublime.save_settings('Origami.sublime-settings')
def generate(self, sourcePath): if not sourcePath: return if not os.path.isdir(sourcePath): sublime.error_message("'{0}' is not a valid path to a directory.".format(sourcePath)) return appKitPath = join(sourcePath, "AppKit") foundationPath = join(sourcePath, "Foundation") if not os.path.isdir(appKitPath) or not os.path.isdir(foundationPath): sublime.error_message("'{0}' does not appear to be a Cappuccino source directory.".format(sourcePath)) return self.parse_source_directory(appKitPath) self.parse_source_directory(foundationPath) self.write_instance_methods() self.write_class_methods() self.write_classes() self.write_functions() self.write_constants() # If we make it this far, save the path so next time the user does not have to enter it settings = sublime.load_settings(self.OBJECTIVEJ_SETTINGS) settings.set(self.CAPPUCCINO_SOURCE_PATH_SETTING, sourcePath) sublime.save_settings(self.OBJECTIVEJ_SETTINGS) sublime.error_message("Cappuccino completions successfully generated.")
def on_select_done(self, picked): entry = GetSearchEngineEntry(picked) settings = sublime.load_settings(__name__ + ".sublime-settings") settings.set("searchanywhere_searchengine", entry.get("name")) settings.set("searchanywhere_searchurl", entry.get("searchurl")) sublime.save_settings(__name__ + ".sublime-settings")
def cycle_scheme(backward=False, purge=False): settings = sublime.load_settings('Preferences.sublime-settings') current_scheme = settings.get('color_scheme') raw_path = sublime.packages_path() package_path = fix_path(raw_path) schemes = ['/'.join([ fix_path(dirpath[len(dirname(package_path)) + 1:]), filename, ]) for dirpath, _, filenames in os.walk(package_path) for filename in filenames if filename.endswith('.tmTheme') ] schemes.sort(key=lambda x: basename(x)) i = schemes.index(current_scheme) + (backward and -1 or 1) i = 0 if i == len(schemes) else len(schemes) - 1 if i == -1 else i scheme = schemes[i] if not scheme: return settings.set('color_scheme', scheme) sublime.save_settings('Preferences.sublime-settings') sublime.status_message( u'Color Scheme: ' + friendly_name(scheme) ) if purge: purge_scheme(raw_path.rstrip('Packages'), current_scheme)
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 modify_and_save_settings(self): settings = sublime.load_settings("Preferences.sublime-settings") settings.set("color_scheme", self.colors) settings.set("theme", self.theme) sublime.save_settings("Preferences.sublime-settings")
def on_done(self, input): """ Input panel handler - adds the provided URL as a channel :param input: A string of the URL to the new channel """ input = input.strip() if re.match("https?://", input, re.I) is None: show_error( u""" Unable to add the channel "%s" since it does not appear to be served via HTTP (http:// or https://). """, input, ) return settings = sublime.load_settings(pc_settings_filename()) channels = settings.get("channels", []) if not channels: channels = [] channels.append(input) settings.set("channels", channels) sublime.save_settings(pc_settings_filename()) sublime.status_message(("Channel %s successfully added") % input)
def save_config(self, filezilla_db_path): settings = sublime.load_settings("SublimeZilla.sublime-settings") settings.set("filezilla_db_path", filezilla_db_path) sublime.save_settings("SublimeZilla.sublime-settings") # Now, show the quick panel self.quick_panel()
def path_entered(self, path): path = os.path.abspath(os.path.expanduser(path)) s = sublime.load_settings("Subclim.sublime-settings") s.set("eclim_executable_location", path) sublime.save_settings("Subclim.sublime-settings") # re-initialize the eclim module with the new path initialize_eclim_module()
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(text.format( u''' Package Control Your active theme was just upgraded. You may see some 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())
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 run(self): try: debug('MavensMate Desktop installer running ...') ThreadProgress(self, "Installing MavensMate Desktop. This could take a few minutes.", '') self.install() settings = sublime.load_settings('mavensmate.sublime-settings') settings.set('mm_desktop_installed', True) sublime.save_settings('mavensmate.sublime-settings') self.result = 'MavensMate Desktop successfully installed. Happy coding!!' if self.printer != None: self.calculate_process_region() ThreadTracker.remove(self) except BaseException as e: import traceback import sys traceback.print_exc(file=sys.stdout) debug('[MAVENSMATE] could not install MavensMate Desktop') debug(e) self.result = '[OPERATION FAILED]: could not install MavensMate Desktop, please check the Sublime Text console for logs and post an issue.' if self.printer != None: self.calculate_process_region() ThreadTracker.remove(self)
def _save_test_run(self, command: str) -> None: """Save the last ran test """ s = sublime.load_settings('PythonTestRunner.last-run') s.set('last_test_run', command) sublime.save_settings('PythonTestRunner.last-run')
def on_done_filename(self, value): self.filename = value # get selected text, or the whole file if nothing selected if all([region.empty() for region in self.view.sel()]): text = self.view.substr(sublime.Region(0, self.view.size())) else: text = "\n".join([self.view.substr(region) for region in self.view.sel()]) try: gist = self.gistapi.create_gist(description=self.description, filename=self.filename, content=text, public=self.public) self.view.settings().set('gist', gist) sublime.set_clipboard(gist["html_url"]) sublime.status_message(self.MSG_SUCCESS) except GitHubApi.UnauthorizedException: # clear out the bad token so we can reset it self.settings.set("github_token", "") sublime.save_settings("GitHub.sublime-settings") sublime.error_message(self.ERR_UNAUTHORIZED_TOKEN) sublime.set_timeout(self.get_username, 50) except GitHubApi.UnknownException as e: sublime.error_message(e.message) except GitHubApi.ConnectionException as e: sublime.error_message(e.message)
def remove_wsdl(self): """ Removes all auto-completion entries, context menu entries, and WSDL settings entries. """ # Remove WSDL objects and fields from completions... # TODO: Update this with logic to support checking for file completions_path_list = ['User', 'NSOA', 'Wsdl.sublime-completions'] completions_path = os.path.join(sublime.packages_path(), os.path.join(*completions_path_list)) if os.path.exists(completions_path): os.remove(completions_path) # Remove WSDL objects and fields context menu... context_path_list = ['User', 'NSOA', 'Context.sublime-menu'] context_path = os.path.join(sublime.packages_path(), os.path.join(*context_path_list)) if os.path.exists(context_path): os.remove(context_path) # Remove WSDL objects and fields from settings settings = sublime.load_settings('NSOA.sublime-settings') if settings.has('wsdl_json'): settings.erase('wsdl_json') if settings.has('wsdl_last_updated'): settings.erase('wsdl_last_updated') sublime.save_settings('NSOA.sublime-settings') sublime.status_message('NSOA: All WSDL data has been removed.')
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 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 on_select_done(self, picked): entry = GetSearchEngineEntry(picked) settings = sublime.load_settings(__name__ + '.sublime-settings') settings.set('searchanywhere_searchengine', entry.get('name')) settings.set('searchanywhere_searchurl', entry.get('searchurl')) sublime.save_settings(__name__ + '.sublime-settings')
def onConfigDone(self, data): # print(self.window.project_data()) global SETTINGS global CONFIG_PATH CONFIG_PATH = data if CONFIG_PATH == "": sublime.error_message(u"需设置 UI 资源路径!") return isOk = sublime.ok_cancel_dialog(u"是否将 UI 资源路径设置为: " + CONFIG_PATH + " ?") if not isOk: self.window.show_input_panel(u"重新设置 UI 资源路径:", "", self.onConfigDone, None, self.onConfigCancel) else: # print(CONFIG_PATH) SETTINGS.set("UIResPath", CONFIG_PATH) #保存配置 在user目录下的 PUIEditor.sublime-settings文件 sublime.save_settings(SETTING_FILE) projectData = self.window.project_data() folders = projectData['folders'] folders.append({"path": CONFIG_PATH}) self.window.set_project_data(projectData) snippetsGenerate = SnippetsGenerate() snippetsGenerate.dealFiles()
def write_symbol_table_cache(self, member_id): # Get the symbol table from ApexClassMember query = "SELECT Id, SymbolTable " +\ "FROM ApexClassMember WHERE Id ='%s'" % member_id member = self.query(query, True) # Start to write symbol table to cache if not member["records"]: return symbol_table = member["records"][0]["SymbolTable"] # Get symbolTable from component_metadata.sublime-settings symbol_table_cache = sublime.load_settings("symbol_table.sublime-settings") symboltable_dict = symbol_table_cache.get(self.settings["username"], {}) # Outer completions outer = util.parse_symbol_table(symbol_table) symboltable_dict[symbol_table["name"].lower()] = { "outer" : outer, "name": symbol_table["name"] } # Inner completions inners = {} for inn in symbol_table["innerClasses"]: inner = util.parse_symbol_table(inn) inners[inn["name"].lower()] = inner symboltable_dict[symbol_table["name"].lower()]["inners"] = inners symbol_table_cache.set(self.settings["username"], symboltable_dict) sublime.save_settings("symbol_table.sublime-settings")
def handle_thread(thread, timeout): if thread.is_alive(): sublime.set_timeout(lambda: handle_thread(thread, timeout), timeout) return # If succeed, something may happen, # for example, user password is expired result = api.result if result == None: return if "status_code" in result and result["status_code"] > 399: return # Load COMPONENT_METADATA_SETTINGS Settings and put all result into it # Every org has one local repository component_metadata = result component_settings = sublime.load_settings(COMPONENT_METADATA_SETTINGS) component_settings.set(toolingapi_settings["username"], component_metadata) sublime.save_settings(COMPONENT_METADATA_SETTINGS) print (message.SEPRATE.format('All code are Downloaded.')) sublime.status_message(message.DOWNLOAD_ALL_SUCCESSFULLY) # After Refresh all succeed, start initiate sobject completions handle_initiate_sobjects_completions(120) # If get_static_resource_body is true, # start to get all binary body of static resource if toolingapi_settings["get_static_resource_body"]: handle_get_static_resource_body(toolingapi_settings)
def run(self, edit): self.settings = sublime.load_settings("GitHub.sublime-settings") self.github_user = None self.github_password = None self.github_one_time_password = None self.accounts = self.settings.get("accounts") self.active_account = self.settings.get("active_account") if not self.active_account: self.active_account = list(self.accounts.keys())[0] self.github_token = self.accounts[self.active_account]["github_token"] if not self.github_token: self.github_token = self.settings.get("github_token") if self.github_token: # migrate to new structure self.settings.set("accounts", {"GitHub": {"base_uri": "https://api.github.com", "github_token": self.github_token}}) self.settings.set("active_account", "GitHub") self.active_account = self.settings.get("active_account") self.settings.erase("github_token") sublime.save_settings("GitHub.sublime-settings") self.base_uri = self.accounts[self.active_account]["base_uri"] self.debug = self.settings.get('debug') self.proxies = {'https': self.accounts[self.active_account].get("https_proxy", None)} self.force_curl = self.accounts[self.active_account].get("force_curl", False) self.gistapi = GitHubApi(self.base_uri, self.github_token, debug=self.debug, proxies=self.proxies, force_curl=self.force_curl)
def __load_settings(self): default_date_format = '%Y-%m-%d %H:%M:%S' """Load the plugin settings from FileHistory.sublime-settings""" app_settings = sublime.load_settings(self.SETTINGS_FILE) settings_exist = app_settings.has('history_file') self.PRINT_DEBUG = self.__ensure_setting(app_settings, 'debug', True) self.GLOBAL_MAX_ENTRIES = self.__ensure_setting(app_settings, 'global_max_entries', 100) self.PROJECT_MAX_ENTRIES = self.__ensure_setting(app_settings, 'project_max_entries', 50) self.USE_SAVED_POSITION = self.__ensure_setting(app_settings, 'use_saved_position', True) self.NEW_TAB_POSITION = self.__ensure_setting(app_settings, 'new_tab_position', 'next') self.REMOVE_NON_EXISTENT_FILES = self.__ensure_setting(app_settings, 'remove_non_existent_files_on_preview', True) self.CLEANUP_ON_STARTUP = self.__ensure_setting(app_settings, 'cleanup_on_startup', True) history_path = self.__ensure_setting(app_settings, 'history_file', 'User/FileHistory.json') self.HISTORY_FILE = os.path.normpath(os.path.join(sublime.packages_path(), history_path)) self.USE_MONOSPACE = self.__ensure_setting(app_settings, 'monospace_font', False) self.DISPLAY_TIMESTAMPS = self.__ensure_setting(app_settings, 'display_timestamps', True) self.TIMESTAMP_FORMAT = self.__ensure_setting(app_settings, 'timestamp_format', default_date_format) self.TIMESTAMP_MODE = self.__ensure_setting(app_settings, 'timestamp_mode', 'history_access') self.PRETTIFY_HISTORY = self.__ensure_setting(app_settings, 'prettify_history', False) self.INDENT_SIZE = 4 try: self.get_timestamp() except Exception: self.TIMESTAMP_FORMAT = default_date_format # Ignore the file preview setting for ST2 self.SHOW_FILE_PREVIEW = False if is_ST2 else self.__ensure_setting(app_settings, 'show_file_preview', True) if not settings_exist: print('[FileHistory] Unable to find the settings file "%s". A default settings file has been created for you.' % (self.SETTINGS_FILE)) sublime.save_settings(self.SETTINGS_FILE)
def on_done_password(self, value): "Callback for the password show_input_panel" self.github_password = value try: api = GitHubApi(self.base_uri, debug=self.debug) self.github_token = api.get_token(self.github_user, self.github_password, self.github_one_time_password) self.github_password = self.github_one_time_password = None # don't keep these around self.accounts[self.active_account]["github_token"] = self.github_token self.settings.set("accounts", self.accounts) sublime.save_settings("GitHub.sublime-settings") self.gistapi = GitHubApi(self.base_uri, self.github_token, debug=self.debug) try: if self.callback: sublime.error_message(self.MSG_TOKEN_SUCCESS) callback = self.callback self.callback = None sublime.set_timeout(callback, 50) except AttributeError: pass except GitHubApi.OTPNeededException: sublime.set_timeout(self.get_one_time_password, 50) except GitHubApi.UnauthorizedException: sublime.error_message(self.ERR_UNAUTHORIZED) sublime.set_timeout(self.get_username, 50) except GitHubApi.UnknownException as e: sublime.error_message(e.message)
def on_done(self, nickname): saved_layouts = self.settings.get('saved_layouts') layout_names = [l['nickname'] for l in saved_layouts] layout_data = self.get_layout() if nickname in layout_names: dialog_str = ('You already have a layout stored as "{0}".\n\n' 'Do you want to continue and overwrite that ' 'layout?'.format(nickname)) dialog_btn = 'Overwrite layout' if sublime.ok_cancel_dialog(dialog_str, dialog_btn): def get_index(seq, attr, value): return next(i for (i, d) in enumerate(seq) if d[attr] == value) layout = saved_layouts[get_index(saved_layouts, 'nickname', nickname)] layout['rows'] = layout_data[0] layout['cols'] = layout_data[1] layout['cells'] = layout_data[2] else: self.window.run_command("save_layout") return else: layout = {} layout['nickname'] = nickname layout['rows'] = layout_data[0] layout['cols'] = layout_data[1] layout['cells'] = layout_data[2] saved_layouts.append(layout) self.settings.set('saved_layouts', saved_layouts) sublime.save_settings('Origami.sublime-settings')
def ondone(mstr): settings = sublime.load_settings("luadbg.sublime-settings") global searchpaths if searchpaths.count(mstr) == 0: searchpaths.append(mstr) settings.set("searchpaths",searchpaths) sublime.save_settings("luadbg.sublime-settings")
def save_config(self, value=None, type=None): self.settings.set('font_size', self.size) self.settings.set('font_face', self.face) self.update_options() sublime.save_settings(self.settings_id) if type: sublime.status_message("Fontafeelya: %s set to %s" % (type,value))
def on_panel_close(i): if i == 1 or i == 2: view = win.open_file(changelog_fn) if i == 1: run_go_get(view) settings.set('tracking_rev', new_rev) sublime.save_settings(settings_fn)
def handle_thread(thread, timeout): if thread.is_alive(): sublime.set_timeout(lambda: handle_thread(thread, timeout), timeout) return elif api.result == None: sublime.status_message(message.TOOLING_API_CONNECTING_FAILED) return # If succeed, something may happen, # for example, user password is expired if "status_code" in api.result and api.result["status_code"] > 399: util.sublime_error_message(api.result) return # Load COMPONENT_METADATA_SETTINGS Settings and put all result into it # Every org has one local repository component_metadata = api.result component_metadta = sublime.load_settings(COMPONENT_METADATA_SETTINGS) component_metadta.set(toolingapi_settings["username"], component_metadata) sublime.save_settings(COMPONENT_METADATA_SETTINGS) print (message.SEPRATE.format('All code are Downloaded.')) sublime.status_message(message.DOWNLOAD_ALL_SUCCESSFULLY) # After Refresh all succeed, start initiate sobject completions handle_initiate_sobjects_completions(120)
def restore_pkg_list(self, backup_path): if backup_path is not None: try: tools.log("PackageSync: Restoring package list from %s" % backup_path) with open(backup_path, "r") as f: _installed_packages = json.load(f)["installed_packages"] _package_control_settings = sublime.load_settings( "Package Control.sublime-settings") _package_control_settings.set("installed_packages", _installed_packages) sublime.save_settings("Package Control.sublime-settings") tools.install_new_packages() except Exception as e: tools.log( "PackageSync: Error while restoring packages from package list", force=True) tools.log("PackageSync: Error message: %s" % str(e), force=True) else: tools.packagesync_cancelled()
def on_done_filename(self, value): self.filename = value # get selected text, or the whole file if nothing selected if all([region.empty() for region in self.view.sel()]): text = self.view.substr(sublime.Region(0, self.view.size())) else: text = "\n".join([self.view.substr(region) for region in self.view.sel()]) try: gist = self.gistapi.create_gist(description=self.description, filename=self.filename, content=text, public=self.public) self.view.settings().set('gist', gist) sublime.set_clipboard(gist["html_url"]) sublime.status_message(self.MSG_SUCCESS) except GitHubApi.UnauthorizedException: # clear out the bad token so we can reset it self.settings.set("github_token", "") sublime.save_settings("GitHub.sublime-settings") sublime.error_message(self.ERR_UNAUTHORIZED_TOKEN) sublime.set_timeout(self.get_username, 50) except GitHubApi.UnknownException, e: sublime.error_message(e.message)
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", "highlight_all", "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
def run(self, edit): self.settings = sublime.load_settings("GitHub.sublime-settings") self.github_user = None self.accounts = self.settings.get("accounts") self.active_account = self.settings.get("active_account") if not self.active_account: self.active_account = self.accounts.keys()[0] self.github_token = self.accounts[self.active_account]["github_token"] if not self.github_token: self.github_token = self.settings.get("github_token") if self.github_token: # migrate to new structure self.settings.set("accounts", {"GitHub": {"base_uri": "https://api.github.com", "github_token": self.github_token}}) self.settings.set("active_account", "GitHub") self.active_account = self.settings.get("active_account") self.settings.erase("github_token") sublime.save_settings("GitHub.sublime-settings") self.base_uri = self.accounts[self.active_account]["base_uri"] self.debug = self.settings.get('debug') self.proxies = {'https': self.accounts[self.active_account].get("https_proxy", None)} self.force_curl = self.accounts[self.active_account].get("force_curl", False) self.gistapi = GitHubApi(self.base_uri, self.github_token, debug=self.debug, proxies=self.proxies, force_curl=self.force_curl)
def on_done(self, nickname): saved_layouts = self.settings().get('saved_layouts') layout_names = [l['nickname'] for l in saved_layouts] layout_data = self.get_layout() if nickname in layout_names: dialog_str = ('You already have a layout stored as "{0}".\n\n' 'Do you want to continue and overwrite that ' 'layout?'.format(nickname)) dialog_btn = 'Overwrite layout' if sublime.ok_cancel_dialog(dialog_str, dialog_btn): def get_index(seq, attr, value): return next(i for (i, d) in enumerate(seq) if d[attr] == value) layout = saved_layouts[get_index(saved_layouts, 'nickname', nickname)] layout['rows'] = layout_data[0] layout['cols'] = layout_data[1] layout['cells'] = layout_data[2] else: self.window.run_command("save_layout") return else: layout = { 'nickname': nickname, 'rows': layout_data[0], 'cols': layout_data[1], 'cells': layout_data[2], } saved_layouts.append(layout) self.settings().set('saved_layouts', saved_layouts) sublime.save_settings('Origami.sublime-settings')
def _save_view_data(view, clean_existing_versions): file_name = view.file_name() if file_name == None: return # Skip saving data if the file size is larger than `max_buffer_size`. settings = _load_storage_settings(save_on_reset=False) if view.size() > settings.get("max_buffer_size", MAX_BUFFER_SIZE_DEFAULT): return def _save_region_data(data_key, regions): all_data = settings.get(data_key) if regions: if clean_existing_versions or not file_name in all_data: all_data[file_name] = {} view_data = all_data.get(file_name) view_data[view_content_checksum] = regions else: all_data.pop(file_name, None) settings.set(data_key, all_data) view_content_checksum = _compute_view_content_checksum(view) # Save folds fold_regions = [(r.a, r.b) for r in view.folded_regions()] _save_region_data("folds", fold_regions) # Save selections if set if settings.get("save_selections") == True: selection_regions = [(r.a, r.b) for r in view.selection] _save_region_data("selections", selection_regions) # Save settings sublime.save_settings(__storage_file__)
def run(self): presentation_settings = sublime.load_settings( "PresentationMode.sublime-settings") s = sublime.load_settings("Preferences.sublime-settings") if presentation_settings.get("in_presentation_mode"): return for setting in settings: presentation_settings.set("bak_" + setting, s.get(setting)) if presentation_settings.has(setting): if DEBUG: print("====") print(setting) print(presentation_settings.get(setting)) print(presentation_settings.get("bak_" + setting)) print("====") s.set(setting, presentation_settings.get(setting)) presentation_settings.set("in_presentation_mode", True) sublime.save_settings("PresentationMode.sublime-settings") sublime.save_settings("Preferences.sublime-settings")
def run(self, edit): s = sublime.load_settings('SAS_Package.sublime-settings') err_regx = s.get( 'err-regx', "(^(error|warning:)|uninitialized|[^l]remerge|Invalid data for)(?! (the .{4,15} product with which|your system is scheduled|will be expiring soon, and|this upcoming expiration.|information on your warning period.))" ) s.set('err-regx', err_regx) sublime.save_settings('SAS_Package.sublime-settings') # err_regx = re.compile(err_regx, re.MULTILINE) # Get end of last current selection. curr_pos = 0 for region in self.view.sel(): curr_pos = region.end() # Find the next error next_error = self.view.find(err_regx, curr_pos, sublime.IGNORECASE) if next_error: # Clear out any previous selections. self.view.sel().clear() self.view.sel().add(next_error) self.view.show(next_error) sublime.status_message("Found error at " + str(next_error)) else: sublime.status_message("No more errors!")
def find_yapf(self): """Find the yapf executable.""" # default to what is in the settings file cmd = self.get_setting("yapf_command") cmd = os.path.expanduser(cmd) cmd = sublime.expand_variables( cmd, sublime.active_window().extract_variables()) save_settings = not cmd for maybe_cmd in ['yapf', 'yapf3', 'yapf.exe', 'yapf3.exe']: if not cmd: cmd = which(maybe_cmd) if cmd: self.debug('Found yapf: %s', cmd) break if cmd and save_settings: settings = sublime.load_settings(PLUGIN_SETTINGS_FILE) settings.set("yapf_command", cmd) sublime.save_settings(PLUGIN_SETTINGS_FILE) return cmd
def run(self, edit): """Parse the regex panel, and if okay, insert/replace entry in settings.""" obj = ConvertPythonSrc2Obj().convert(self.view.substr(sublime.Region(0, self.view.size())))[0] if obj is None: return if not obj.get('name'): error('A valid name must be provided!') elif obj.get('scope') is None and obj.get('find') is None: error('A valid find pattern or scope must be provided!') elif not self.is_existing_name(obj['name']): try: if obj.get('find') is not None: if obj.get('literal', False): flags = 0 pattern = re.escape(obj['find']) if obj.get('literal_ignorecase', False): flags = re.I re.compile(pattern, flags) else: extend = sublime.load_settings( 'reg_replace.sublime-settings' ).get('extended_back_references', False) if extend: bre.compile_search(obj['find']) else: re.compile(obj['find']) settings = sublime.load_settings('reg_replace_rules.sublime-settings') rules = settings.get('replacements', {}) rules[obj['name']] = obj settings.set('replacements', rules) sublime.save_settings('reg_replace_rules.sublime-settings') self.view.settings().set('regreplace.name', obj['name']) except Exception as e: error('Regex compile failed!\n\n%s' % str(e))
def run(self, edit, option): s = sublime.load_settings('phpfmt.sublime-settings') options = { "autocomplete": "autocomplete", "autoimport": "dependency autoimport", "cakephp_style": "CakePHP style", "enable_auto_align": "auto align", "format_on_save": "format on save", "indent_with_space": "indent with space", "laravel_style": "Laravel style", "psr1": "PSR1", "psr1_naming": "PSR1 Class and Method Naming", "psr2": "PSR2", "readini": "look for .php.tools.ini", "save_before_format_now": "save before 'format now'", "smart_linebreak_after_curly": "smart linebreak after curly", "space_around_exclamation_mark": "space around exclamation mark", "vet": "vet", "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(msg) sublime.status_message(msg) else: s.set(option, True) msg = "phpfmt: " + options[option] + " enabled" print(msg) sublime.status_message(msg) sublime.save_settings('phpfmt.sublime-settings')
def run(self, edit): try: settings = sublime.load_settings(SETTINGS_FILE) syntax_current_file = self.view.settings().get("syntax") enable_for_syntaxes = settings.get( ENABLE_FOR_SYNTAXES_LIST_SETTING, []) if syntax_current_file not in enable_for_syntaxes: enable_for_syntaxes.append(syntax_current_file) enable_for_syntaxes.sort() settings.set(ENABLE_FOR_SYNTAXES_LIST_SETTING, enable_for_syntaxes) sublime.save_settings(SETTINGS_FILE) msg = "Syntax added to the syntax list" sublime.status_message(msg) else: msg = "Syntax already in the syntax list" sublime.status_message(msg) except Exception: msg = "The SingleTrailingNewLine.sublime-settings file is invalid" sublime.status_message(msg)
def __init__(self): self.before = "" self.after = "" self.region_includes_beginning = False self.region_includes_end = False self.before_begin_location = 0 self.autocompleting = False self.choices = [] self.substitute_interval = 0, 0 self.actions_since_completion = 1 self.old_prefix = None self.popup_is_ours = False self.seen_changes = False self.no_hide_until = time.time() self.just_pressed_tab = False self.tab_only = False self.tab_index = 0 self.old_prefix = None self.expected_prefix = "" self.user_message = [] sublime.load_settings(PREFERENCES_PATH).set('auto_complete', False) sublime.save_settings(PREFERENCES_PATH)
def on_verifier(verifier): if verifier: token = oauth.Token(request_token['oauth_token'], request_token['oauth_token_secret']) token.set_verifier(verifier) client = oauth.Client(consumer, token) resp, content = client.request(token_request_uri, "POST") access_token = dict(urlparse.parse_qsl(content)) if access_token: settings.set("oauth_token", access_token['oauth_token']) settings.set("noteStoreUrl", access_token['edam_noteStoreUrl']) sublime.save_settings('SublimeEvernote.sublime-settings') sublime.status_message("authenticate ok") _connect(access_token['oauth_token']) else: raise Exception("authenticate failure") else: self.window.show_input_panel( "Paste the verifier string from from the URL here. Verifier (required):", "", on_verifier, None, None)
def run(self, edit, dest="front"): try: view = self.view file_name = view.file_name() if file_name is None: raise ZorgmodeFatalError("Cannot add file without name to zorg_agenda_list") file_name = os.path.abspath(file_name) settings = sublime.load_settings(ZORGMODE_SUBLIME_SETTINGS) zorg_agenda_files = settings.get(ZORG_AGENDA_FILES, []) new_zorg_agenda_files = [] if dest == "front": new_zorg_agenda_files.append(file_name) for f in zorg_agenda_files: if f != file_name: new_zorg_agenda_files.append(f) if dest == "end": new_zorg_agenda_files.append(file_name) settings.set(ZORG_AGENDA_FILES, new_zorg_agenda_files) sublime.save_settings(ZORGMODE_SUBLIME_SETTINGS) except ZorgmodeError as e: sublime.status_message(str(e)) except ZorgmodeFatalError as e: sublime.error_message(str(e))
def cycle(self): sublimeSettings = sublime.load_settings('Preferences.sublime-settings') if sublimeSettings is None: raise Exception('Preferences not loaded') config = getattr(self.settings, self.getDayOrNight()) sublimeSettingsChanged = False newColorScheme = config.get('color_scheme') if newColorScheme and newColorScheme != sublimeSettings.get('color_scheme'): logToConsole('Switching to color scheme {0}'.format(newColorScheme)) sublimeSettings.set('color_scheme', newColorScheme) sublimeSettingsChanged = True newTheme = config.get('theme') if newTheme and newTheme != sublimeSettings.get('theme'): logToConsole('Switching to theme {0}'.format(newTheme)) sublimeSettings.set('theme', newTheme) sublimeSettingsChanged = True if sublimeSettingsChanged: sublime.save_settings('Preferences.sublime-settings')
def plugin_loaded(): settings = sublime.load_settings("Preferences.sublime-settings") if not settings.has("better_whitespace_remove_whitespace_at_eol"): settings.set("better_whitespace_remove_whitespace_at_eol", True) sublime.save_settings("Preferences.sublime-settings") if not settings.has("better_whitespace_empty_line_at_eof"): settings.set("better_whitespace_empty_line_at_eof", True) sublime.save_settings("Preferences.sublime-settings") if not settings.has("better_whitespace_area_of_effect"): settings.set("better_whitespace_area_of_effect", "full") sublime.save_settings("Preferences.sublime-settings")
def setColorSchemes(self, newColorScheme): self.mysettings = sublime.load_settings('OrgExtended.sublime-settings') self.mysettings.set("color_scheme", newColorScheme) sublime.save_settings('OrgExtended.sublime-settings') self.mysettings = sublime.load_settings( 'orgdatepicker.sublime-settings') self.mysettings.set("color_scheme", newColorScheme) sublime.save_settings('orgdatepicker.sublime-settings') self.mysettings = sublime.load_settings('orgagenda.sublime-settings') self.mysettings.set("color_scheme", newColorScheme) sublime.save_settings('orgagenda.sublime-settings')
def __init__(self): super(SerialMonitorCommand, self).__init__() self.default_settings = SerialSettings(None) try: self.last_settings = sublime.load_settings( serial_constants.LAST_USED_SETTINGS) except: self.last_settings = sublime.save_settings( serial_constants.LAST_USED_SETTINGS) # Map for the run command args and the functions to handle the command self.arg_map = { "connect": self._select_port_wrapper(self.connect, self.PortListType.AVAILABLE), "disconnect": self._select_port_wrapper(self.disconnect, self.PortListType.OPEN), "reconfigure_port": self._select_port_wrapper(self.reconfigure_port, self.PortListType.OPEN), "write_line": self._select_port_wrapper(self.write_line, self.PortListType.OPEN), "write_file": self._select_port_wrapper(self.write_file, self.PortListType.OPEN), "new_buffer": self._select_port_wrapper(self.new_buffer, self.PortListType.OPEN), "clear_buffer": self._select_port_wrapper(self.clear_buffer, self.PortListType.OPEN), "timestamp_logging": self._select_port_wrapper(self.timestamp_logging, self.PortListType.OPEN), "line_endings": self._select_port_wrapper(self.line_endings, self.PortListType.OPEN), "local_echo": self._select_port_wrapper(self.local_echo, self.PortListType.OPEN), "filter": self._select_port_wrapper(self.filter, self.PortListType.OPEN), "_port_closed": self.disconnected } self.open_ports = {}
def create_user_custom_theme(self): if self.awaiting_feedback: return self.awaiting_feedback = True if not self.tags: self.awaiting_feedback = False return self.sublime_pref = sublime.load_settings(sublime_settings) color_scheme = self.sublime_pref.get("color_scheme") if self.regenerate and self.settings.get("old_color_scheme", "") != "": color_scheme = self.settings.get("old_color_scheme", "") self.settings.set("old_color_scheme", color_scheme) sublime.save_settings("colored_comments.sublime-settings") cs_base = os.path.basename(color_scheme) if cs_base[0:16] != "Colored Comments": cs_base = "{}{}".format("Colored Comments-", cs_base) custom_color_base = self._create_custom_color_scheme_directory() new_cs_absolute = os.path.join(custom_color_base, cs_base) self.color_scheme = "{}{}{}{}".format("Packages/", self.new_color_scheme_path, "/", cs_base) print(self.color_scheme) updates, loaded_scheme, is_json = self.load_color_scheme(color_scheme) if self.regenerate or updates or color_scheme != self.color_scheme: try: os.remove(new_cs_absolute) except OSError as ex: self.log.debug(str(ex)) pass if is_json: with open(new_cs_absolute, "w") as outfile: json.dump(loaded_scheme, outfile, indent=4) else: with open(new_cs_absolute, "wb") as outfile: outfile.write(plistlib.dumps(loaded_scheme)) if color_scheme != self.color_scheme: if sublime.ok_cancel_dialog( MSG.substitute(scheme=self.color_scheme), "Confirm"): self.sublime_pref.set("color_scheme", self.color_scheme) sublime.save_settings("Preferences.sublime-settings") self.settings.set("prompt_new_color_scheme", False) sublime.save_settings("colored_comments.sublime-settings") self.update_preferences = False self.awaiting_feedback = False
def on_done(self, index): if (index < 0): return newColorScheme = self.files[index] self.mysettings = sublime.load_settings('OrgExtended.sublime-settings') self.mysettings.set("color_scheme", newColorScheme) sublime.save_settings('OrgExtended.sublime-settings') self.mysettings = sublime.load_settings( 'orgdatepicker.sublime-settings') self.mysettings.set("color_scheme", newColorScheme) sublime.save_settings('orgdatepicker.sublime-settings') self.mysettings = sublime.load_settings('orgagenda.sublime-settings') self.mysettings.set("color_scheme", newColorScheme) sublime.save_settings('orgagenda.sublime-settings')
def run(self, file, key, value): settings = sublime.load_settings(file) # Vim Specific code if file == "ActualVim.sublime-settings": if not settings.get("enabled") and value: settings.set(key, value) sublime.save_settings(file) elif settings.get("enabled") and not value: settings.set(key, value) sublime.save_settings(file) # Everything else else: settings.set(key, value) sublime.save_settings(file)
def on_quick_done(self, index): project = self.settings.get('current project') project_args = self.settings.get('project build args') default_args = self.settings.get('default build args') if not project: return False else: if not default_args: default_args = { 'engine': 'D:/__MODIFY-THIS-PATH__/Epic Games/UE_4.26', 'target': 'Editor', 'platform': 'Win64', 'state': 'Development', 'features': ['-waitmutex', '-NoHotReload'] } self.settings.set('default build args', default_args) sublime.save_settings( 'unreal_project_control.sublime-settings') self.window.open_file( sublime.packages_path() + '/User/unreal_project_control.sublime-settings') return if not project_args: default_args['target'] = project + default_args['target'] project_args = {project: default_args} self.settings.set('project build args', project_args) sublime.save_settings( 'unreal_project_control.sublime-settings') if not project in project_args: default_args['target'] = project + default_args['target'] project_args[project] = default_args self.settings.set('project build args', project_args) sublime.save_settings( 'unreal_project_control.sublime-settings') if index == 1: self.window.open_file( sublime.packages_path() + '/User/unreal_project_control.sublime-settings') elif index == 0: self.build() else: return
def on_done(self, picked): """ Quick panel user selection handler - deletes the selected package :param picked: An integer of the 0-based package name index from the presented list. -1 means the user cancelled. """ if picked == -1: return package = self.package_list[picked][0] settings = sublime.load_settings(preferences_filename()) # Change the color scheme before removing the package containing it if settings.get('color_scheme').find('Packages/' + package + '/') != -1: settings.set('color_scheme', 'Packages/Color Scheme - Default/Monokai.tmTheme') sublime.save_settings(preferences_filename()) # Change the theme before removing the package containing it if package_file_exists(package, settings.get('theme')): settings.set('theme', 'Default.sublime-theme') sublime.save_settings(preferences_filename()) ignored = settings.get('ignored_packages') if not ignored: ignored = [] # Don't disable Package Control so it does not get stuck disabled if package != 'Package Control': if not package in ignored: ignored.append(package) settings.set('ignored_packages', ignored) sublime.save_settings(preferences_filename()) ignored.remove(package) thread = RemovePackageThread(self.manager, package, ignored) thread.start() ThreadProgress(thread, 'Removing package %s' % package, 'Package %s successfully removed' % package)
def done(self, i): settings = sublime.load_settings(settings_file) settings.set("style", styles[i]) sublime.save_settings(settings_file)
def set_path(path): settings = sublime.load_settings(settings_file) settings.set('binary', path) sublime.save_settings(settings_file) # Make sure the globals are updated. load_settings()
def run(self): s = sublime.load_settings("Preferences.sublime-settings") s.erase("font_size") sublime.save_settings("Preferences.sublime-settings")
def on_choose_app(self, index): settings.set("web_app_id", self.web_apps_ids[index]) sublime.save_settings(SETTINGS_FILENAME) run_next_command()
def save_settings(key, value): s = sublime.load_settings("slideshow.sublime-settings") if s: s.set(key, value) sublime.save_settings("slideshow.sublime-settings")
def setSettings(key, value): global SETTINGS, SETTINGSBASE SETTINGS.set(key, value) sublime.save_settings(SETTINGSBASE)