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)
