def blink(times=4, delay=55):
prefs = load_settings('Preferences.sublime-settings')
if prefs.get('vintageous_visualbell') is False:
return
v = active_window().active_view()
settings = v.settings()
# Ensure we leave the setting as we found it.
times = times if (times % 2) == 0 else times + 1
def do_blink():
nonlocal times
if times > 0:
settings.set('highlight_line', not settings.get('highlight_line'))
times -= 1
set_timeout(do_blink, delay)
do_blink()
python类load_settings()的实例源码
def get_vhdl_setting(cmd_obj, key):
'''
Borrowing an idea from OdatNurd from ST forum, creating a method
that will return the value of a key and also check to see if
it's been overridden in project files. Defaults are handled by
the supplied sublime-settings file.
This will actually work on the regular Preferences as well I think
though might do bad things if the key doesn't exist.
'''
# Load the defaults, or user overridden defaults.
vhdl_settings = sublime.load_settings('vhdl_mode.sublime-settings')
default = vhdl_settings.get(key, None)
# Load the view's settings
view_settings = cmd_obj.view.settings()
return view_settings.get(key, default)
#----------------------------------------------------------------------------
def run(self, edit):
'''
Standard TextCommand Run Method
'''
print('Preference Settings')
print('vhdl-mode: {}: {}'.format('tab_size', util.get_vhdl_setting(self, 'tab_size')))
print('vhdl-mode: {}: {}'.format('translate_tabs_to_spaces', util.get_vhdl_setting(self, 'translate_tabs_to_spaces')))
vhdl_settings = sublime.load_settings('vhdl_mode.sublime-settings')
keys = ['vhdl-user',
'vhdl-company',
'vhdl-project-name',
'vhdl-platform',
'vhdl-standard',
'vhdl-modified-time-string',
'vhdl-use-copyright-block',
'vhdl-use-revision-block',
'vhdl-copyright-block',
'vhdl-revision-block']
print('Package Settings')
for key in keys:
print('vhdl-mode: {}: "{}"'.format(key, vhdl_settings.get(key)))
print('View Settings')
for key in keys:
print('vhdl-mode: {}: {}'.format(key, util.get_vhdl_setting(self, key)))
def fix_scheme_in_settings(settings_file,current_scheme, new_scheme, regenerate=False):
"""Change the color scheme in the given Settings to a background-corrected one"""
from os.path import join, normpath, isfile
settings = load_settings(settings_file)
settings_scheme = settings.get("color_scheme")
if current_scheme == settings_scheme:
new_scheme_path = join(packages_path(), normpath(new_scheme[len("Packages/"):]))
if isfile(new_scheme_path) and not regenerate:
settings.set("color_scheme", new_scheme)
else:
generate_scheme_fix(current_scheme, new_scheme_path)
settings.set("color_scheme", new_scheme)
save_settings(settings_file)
return True
return False
def get_font_scale(self):
"""Get font scale."""
scale = 1.0
try:
pref_scale = float(sublime.load_settings('Preferences.sublime-settings').get('mdpopups.font_scale', 0.0))
except Exception:
pref_scale = 0.0
if sublime.platform() == 'windows' and pref_scale <= 0.0:
try:
import ctypes
logpixelsy = 90
dc = ctypes.windll.user32.GetDC(0)
height = ctypes.windll.gdi32.GetDeviceCaps(dc, logpixelsy)
scale = float(height) / 96.0
ctypes.windll.user32.ReleaseDC(0, dc)
except Exception:
pass
elif pref_scale > 0.0:
scale = pref_scale
return scale
def plugin_loaded():
global import_js_environment
import_js_environment = dict(os.environ).copy()
import_js_environment.update({
'LC_ALL': 'en_US.UTF-8',
'LC_CTYPE': 'UTF-8',
'LANG': 'en_US.UTF-8',
})
path_env_variable = extract_path()
settings = sublime.load_settings('ImportJS.sublime-settings')
setting_paths = settings.get('paths')
if setting_paths:
path_env_variable = ':'.join(setting_paths) + ':' + path_env_variable
import_js_environment.update({
'PATH': path_env_variable,
})
print('ImportJS loaded with environment:')
print(import_js_environment)
def get_font_scale(self):
"""Get font scale."""
scale = 1.0
try:
pref_scale = float(sublime.load_settings('Preferences.sublime-settings').get('mdpopups.font_scale', 0.0))
except Exception:
pref_scale = 0.0
if sublime.platform() == 'windows' and pref_scale <= 0.0:
try:
import ctypes
logpixelsy = 90
dc = ctypes.windll.user32.GetDC(0)
height = ctypes.windll.gdi32.GetDeviceCaps(dc, logpixelsy)
scale = float(height) / 96.0
ctypes.windll.user32.ReleaseDC(0, dc)
except Exception:
pass
elif pref_scale > 0.0:
scale = pref_scale
return scale
def run(self, edit):
import cson, json
# read data from view
input = self.view.substr(sublime.Region(0, self.view.size()))
data = Atom.read_cson(input)
if data is False:
return
output = SublimeText.write_json(data)
sort_keys = sublime.load_settings('Atomizr.sublime-settings').get("json_sort_keys") or True
indent = sublime.load_settings('Atomizr.sublime-settings').get("json_indentation") or 2
selection = sublime.Region(0, self.view.size())
self.view.replace(edit, selection, json.dumps(output, sort_keys=sort_keys, indent=indent, separators=(',', ': ')))
# set syntax to JSON
Helpers.set_json(self)
Helpers.rename_file(self, "sublime-completions")
# Reset selection
Helpers.reset_selection(self)
# Converts Atom snippets (CSON into JSON)
def run(self, edit):
import json
# read data from view
input = self.view.substr(sublime.Region(0, self.view.size()))
data = VsCode.read_json(input)
if data is False:
return
output = SublimeText.write_json(data)
sort_keys = sublime.load_settings('Atomizr.sublime-settings').get("json_sort_keys") or True
indent = sublime.load_settings('Atomizr.sublime-settings').get("json_indentation") or 2
# write converted data to view
selection = sublime.Region(0, self.view.size())
self.view.replace(edit, selection, json.dumps(output, sort_keys=sort_keys, indent=indent))
# set syntax to JSON
Helpers.set_json(self)
Helpers.rename_file(self, "sublime-completions")
Helpers.select_scope(self, "sublime", None)
def rename_file(self, extension):
if sublime.load_settings('Atomizr.sublime-settings').get("rename_files") != True:
return
import os
inputFile = self.view.window().active_view().file_name()
parentDir = os.path.dirname(inputFile)
baseName = os.path.splitext(os.path.basename(inputFile))[0]
fileName = baseName + "." + extension
outputFile = os.path.join(parentDir, fileName)
os.rename(inputFile, outputFile)
self.view.set_name(fileName)
self.view.retarget(outputFile)
self.view.window().run_command("save")
def load_history(rev=True, as_dict=False):
"""Returns list of past requests. Raises exception if history file doesn't
exist.
"""
history_file = sublime.load_settings('Requester.sublime-settings').get('history_file', None)
if not history_file:
raise KeyError
history_path = os.path.join(sublime.packages_path(), 'User', history_file)
with open(history_path, 'r') as f:
rh = json.loads(f.read() or '{}', object_pairs_hook=OrderedDict)
if as_dict:
return rh
requests = list(rh.items())
if rev:
requests.reverse()
return requests
def run_initial_request(self, req, filename):
requests_method = getattr(requests, req.method.lower())
try:
res = requests_method(*req.args, stream=True, **req.kwargs)
except Exception as e:
sublime.error_message('Download Error: {}'.format(e))
return
response = Response(req, res, None)
self.handle_response(response)
self.handle_responses([response])
self.persist_requests([response]) # persist initial request before starting download
if res.status_code != 200:
sublime.error_message(
'Download Error: response status code is not 200\n\n{}'.format(truncate(res.text, 500))
)
if sublime.load_settings('Requester.sublime-settings').get('only_download_for_200', True):
return
self.download_file(res, filename)
def sf_oauth2():
from .libs import auth
settings = setting.load()
default_project_value = settings["default_project_value"]
is_sandbox = default_project_value["is_sandbox"]
if refresh_token():
return
server_info = sublime.load_settings("sfdc.server.sublime-settings")
client_id = server_info.get("client_id")
client_secret = server_info.get("client_secret")
redirect_uri = server_info.get("redirect_uri")
oauth = auth.SalesforceOAuth2(client_id, client_secret, redirect_uri, is_sandbox)
authorize_url = oauth.authorize_url()
print('authorize_url-->')
print(authorize_url)
start_server()
open_in_default_browser(authorize_url)
def plugin_loaded():
global currentSettings, language, currentView
currentSettings = sublime.load_settings(setting_file)
language = currentSettings.get('language')
currentView = sublime.active_window().active_view()
docphpPath = getDocphpPath()
if not os.path.isdir(docphpPath + 'language'):
os.makedirs(docphpPath + 'language')
if not callable(sublime_symbol.symbol_at_point) or not callable(sublime_symbol.navigate_to_symbol):
sublime.error_message('Cannot find symbol_at_point from Default.sublime-package\n\nPlease restore the file which usually replaced by outdated localizations')
from package_control import events
if events.install(package_name) or not language:
currentView.run_command('docphp_checkout_language', {"is_init": True, "set_fallback": True})
def load_settings(self, project_dir):
project_setting_file = RemoteGDBSettings.project_setting_file(project_dir)
if not os.path.exists(project_setting_file):
return False
try:
with open(project_setting_file) as data_file:
json_str = ""
for line in data_file.readlines():
line = line.strip()
if len(line) == 0:
continue
if line.startswith("//"):
continue
json_str += line
json_str += "\n"
self.data = json.loads(json_str)
except Exception as err:
print(err)
# sublime.error_message("some errors exist in project setting file!")
return False
return True
def get(self, key, default_value=None):
keys = key.split(".")
try:
res = self.data
for item in keys:
if item in res.keys():
res = res[item]
else:
raise
if not res:
return default_value
return res
except Exception:
return sublime.load_settings("SublimeRemoteGDB.sublime-settings").get(key, default_value)
return sublime.load_settings("SublimeRemoteGDB.sublime-settings").get(key, default_value)
def get_setting(key, default=None, view=None):
return gdb_settings.get(key, default)
try:
if view is None:
view = sublime.active_window().active_view()
s = view.settings()
# Try executable specific settings first
if exec_settings and key in exec_settings:
return exec_settings[key]
# Then try user settings
if s.has("sublimegdb_%s" % key):
return s.get("sublimegdb_%s" % key)
except:
pass
# Default settings
return sublime.load_settings("SublimeGDB.sublime-settings").get(key, default)
def set_proper_scheme(view):
'''
this is callback, it is not meant to be called directly
view.settings().add_on_change('color_scheme', lambda: set_proper_scheme(view))
set once, right after view is created
_note_, color_scheme must not be set directly, but in a setting file
'''
# Since we cannot create file with syntax, there is moment when view has no settings,
# but it is activated, so some plugins (e.g. Color Highlighter) set wrong color scheme
if view.settings().get('outline_rename_mode', False):
outline_settings = sublime.load_settings('outline-rename-mode.sublime-settings')
else:
outline_settings = sublime.load_settings('outline.sublime-settings')
if view.settings().get('color_scheme') == outline_settings.get('color_scheme'):
return
view.settings().set('color_scheme', outline_settings.get('color_scheme'))
def refresh(self):
self.settings = sublime.load_settings('github_issue.sublime-settings')
for flag in ("token", "username", "password", "debug", "syntax", "git_path", "issue_title_completion",
"user_completion", "label_completion", "commit_completion","split_line_width",
"commit_completion_trigger", "disable_local_repositories", "wrap_width", "draw_centered", "disable_vintageous"):
self.setting_dictionary[flag] = self.settings.get(flag)
##
# @brief get corresponding parameters from Setting Object
##
# @param self The object
# @param flag configuration parameters
# @param default The default value of flag
##
# @return return setting_dictionary[flag] if it is valid otherwise return the default value.
##
def get_settings():
return sublime.load_settings('LuaFormat.sublime-settings')
def _set_generic_view_setting(view, name, value, opt, globally=False):
if opt.scope == _SCOPE_VI_VIEW:
name = 'vintageous_' + name
if opt.parser:
value = opt.parser(value)
if not globally or (opt.scope not in (_SCOPE_VI_VIEW, _SCOPE_VI_WINDOW)):
view.settings().set(name, value)
else:
prefs = load_settings('Preferences.sublime-settings')
prefs.set(name, value)
save_settings('Preferences.sublime-settings')
def outline_target(self):
prefs = sublime.load_settings('Preferences.sublime-settings')
if prefs.get('vintageous_visualyank') is False:
return
sels = list(self._view.sel())
sublime.set_timeout(lambda: self._view.erase_regions('vi_yy_target'), 350)
self._view.add_regions('vi_yy_target', sels, 'comment', '', sublime.DRAW_NO_FILL)
def _update_ignored_packages():
# Updates the list of ignored packages with packages that are redundant,
# obsolete, or cause problems due to conflicts e.g. Vintage, Vintageous,
# etc.
settings = sublime.load_settings('Preferences.sublime-settings')
ignored_packages = settings.get('ignored_packages', [])
conflict_packages = [x for x in ['Six', 'Vintage', 'Vintageous'] if x not in ignored_packages]
if conflict_packages:
print('NeoVintageous: update ignored packages with conflicts {}'.format(conflict_packages))
ignored_packages = sorted(ignored_packages + conflict_packages)
settings.set('ignored_packages', ignored_packages)
sublime.save_settings('Preferences.sublime-settings')
def get_setting(name):
config = sublime.load_settings(CONFIG_NAME)
setting = config.get(name, None)
return setting
def restore_setting(name, value):
config = sublime.load_settings(CONFIG_NAME)
config.set(name, value)
sublime.save_settings(CONFIG_NAME)
def get_pref(key):
global_settings = sublime.load_settings(SETTINGS_FILE)
value = global_settings.get(key)
# Load active project settings
project_settings = sublime.active_window().active_view().settings()
# Overwrite global config value if it's defined
if project_settings.has(PROJECT_NAME):
value = project_settings.get(PROJECT_NAME).get(key, value)
return value
def settings(self):
return sublime.load_settings('PlotGraph.sublime-settings')
def __init__(self):
self.settings = sublime.load_settings("ElixirTest.sublime-settings")
def load_config(self):
s = sublime.load_settings("ElixirTest.sublime-settings")
global MIX_TEST_FOLDER; MIX_TEST_FOLDER = s.get("mix_test_folder")
global IGNORED_DIRECTORIES; IGNORED_DIRECTORIES = s.get("ignored_directories")
global HIDE_PANEL; HIDE_PANEL = s.get("hide_panel")
global BEFORE_CALLBACK; BEFORE_CALLBACK = s.get("before_callback")
global AFTER_CALLBACK; AFTER_CALLBACK = s.get("after_callback")
global COMMAND_PREFIX; COMMAND_PREFIX = False
global SAVE_ON_RUN; SAVE_ON_RUN = s.get("save_on_run")
global SYNTAX; SYNTAX = s.get('syntax')
global THEME; THEME = s.get('theme')
global TERMINAL_ENCODING; TERMINAL_ENCODING = s.get('terminal_encoding')
mix = s.get("check_for_mix") #does nothing yet
def save_test_run(self, command, working_dir):
s = sublime.load_settings("ElixirTest.last-run")
s.set("last_test_run", command)
s.set("last_test_working_dir", working_dir)
sublime.save_settings("ElixirTest.last-run")
