/cmder_mini/vendor/SublimeText/sublime_plugin.py
Python | 371 lines | 287 code | 77 blank | 7 comment | 83 complexity | 063978da3fb756e8fddfba866a662218 MD5 | raw file
- import os
- import sys
- import time
- import sublime
- import imp
- application_command_classes = []
- window_command_classes = []
- text_command_classes = []
- all_command_classes = [application_command_classes, window_command_classes, text_command_classes]
- all_callbacks = {'on_new': [], 'on_clone': [], 'on_load': [], 'on_close': [],
- 'on_pre_save': [], 'on_post_save': [], 'on_modified': [],
- 'on_selection_modified': [],'on_activated': [], 'on_deactivated': [],
- 'on_project_load': [], 'on_project_close': [], 'on_query_context': [],
- 'on_query_completions': []}
- def unload_module(module):
- if "unload_handler" in module.__dict__:
- module.unload_handler()
- # Unload the old plugins
- if "plugins" in module.__dict__:
- for p in module.plugins:
- for cmd_cls_list in all_command_classes:
- try:
- cmd_cls_list.remove(p)
- except ValueError:
- pass
- for c in all_callbacks.values():
- try:
- c.remove(p)
- except ValueError:
- pass
- def unload_plugin(fname):
- print "Unloading plugin", fname
- modulename, ext = os.path.splitext(os.path.basename(fname))
- was_loaded = modulename in sys.modules
- if was_loaded:
- m = __import__(modulename)
- unload_module(m)
- def reload_plugin(fname):
- print "Reloading plugin", fname
- path = os.path.dirname(fname)
- # Change the current directory to that of the module. It's not safe to just
- # add the modules directory to sys.path, as that won't accept unicode paths
- # on Windows
- oldpath = os.getcwdu()
- os.chdir(path)
- modulename, ext = os.path.splitext(os.path.basename(fname))
- if modulename in sys.modules:
- unload_module(sys.modules[modulename])
- m_info = imp.find_module(modulename, ["."])
- m = imp.load_module(modulename, *m_info)
- # Restore the current directory
- os.chdir(oldpath)
- module_plugins = []
- for type_name in dir(m):
- try:
- t = m.__dict__[type_name]
- if t.__bases__:
- is_plugin = False
- if issubclass(t, ApplicationCommand):
- application_command_classes.append(t)
- is_plugin = True
- if issubclass(t, WindowCommand):
- window_command_classes.append(t)
- is_plugin = True
- if issubclass(t, TextCommand):
- text_command_classes.append(t)
- is_plugin = True
- if is_plugin:
- module_plugins.append(t)
- if issubclass(t, EventListener):
- obj = t()
- for p in all_callbacks.iteritems():
- if p[0] in dir(obj):
- p[1].append(obj)
- module_plugins.append(obj)
- except AttributeError:
- pass
- if len(module_plugins) > 0:
- m.plugins = module_plugins
- def create_application_commands():
- cmds = []
- for class_ in application_command_classes:
- cmds.append(class_())
- return cmds
- def create_window_commands(window):
- cmds = []
- for class_ in window_command_classes:
- cmds.append(class_(window))
- return cmds
- def create_text_commands(view):
- cmds = []
- for class_ in text_command_classes:
- cmds.append(class_(view))
- return cmds
- EVENT_TIMEOUT = 0.2
- FAST_EVENT_TIMEOUT = 1 / 60.0
- first_time_msgs = set()
- msgs = set()
- def show_timeout(plugin_name, elapsed, callback):
- global first_time_msgs
- global msgs
- key = plugin_name + callback
- msg = ("A plugin (%s) may be making Sublime Text unresponsive by taking too " +
- "long (%fs) in its %s callback.\n\nThis message can be disabled via the " +
- "detect_slow_plugins setting") % (plugin_name, elapsed, callback)
- # Give plugins one chance to respond slowly, to handle any initialisation issues etc.
- # This allowance may be removed in the future due to startup time concerns
- if not key in first_time_msgs:
- first_time_msgs.add(key)
- return
- if not key in msgs:
- msgs.add(key)
- if sublime.load_settings('Preferences.sublime-settings').get('detect_slow_plugins', True):
- sublime.error_message(msg)
- blocking_api_call_count = 0
- def on_blocking_api_call():
- global blocking_api_call_count
- blocking_api_call_count += 1
- def run_timed_function(f, name, event_name, timeout):
- global blocking_api_call_count
- t0 = time.time()
- blocking_count = blocking_api_call_count
- ret = f()
- elapsed = time.time() - t0
- if elapsed > timeout and blocking_api_call_count == blocking_count:
- show_timeout(name, elapsed, event_name)
- return ret
- def on_new(v):
- for callback in all_callbacks['on_new']:
- run_timed_function(lambda: callback.on_new(v),
- callback.__module__, "on_new", EVENT_TIMEOUT)
- def on_clone(v):
- for callback in all_callbacks['on_clone']:
- run_timed_function(lambda: callback.on_clone(v),
- callback.__module__, "on_clone", EVENT_TIMEOUT)
- def on_load(v):
- for callback in all_callbacks['on_load']:
- run_timed_function(lambda: callback.on_load(v),
- callback.__module__, "on_load", EVENT_TIMEOUT)
- def on_close(v):
- for callback in all_callbacks['on_close']:
- run_timed_function(lambda: callback.on_close(v),
- callback.__module__, "on_close", EVENT_TIMEOUT)
- def on_pre_save(v):
- for callback in all_callbacks['on_pre_save']:
- run_timed_function(lambda: callback.on_pre_save(v),
- callback.__module__, "on_pre_save", EVENT_TIMEOUT)
- def on_post_save(v):
- for callback in all_callbacks['on_post_save']:
- run_timed_function(lambda: callback.on_post_save(v),
- callback.__module__, "on_post_save", EVENT_TIMEOUT)
- def on_modified(v):
- for callback in all_callbacks['on_modified']:
- run_timed_function(lambda: callback.on_modified(v),
- callback.__module__, "on_modified", FAST_EVENT_TIMEOUT)
- def on_selection_modified(v):
- for callback in all_callbacks['on_selection_modified']:
- run_timed_function(lambda: callback.on_selection_modified(v),
- callback.__module__, "on_selection_modified", FAST_EVENT_TIMEOUT)
- def on_activated(v):
- for callback in all_callbacks['on_activated']:
- run_timed_function(lambda: callback.on_activated(v),
- callback.__module__, "on_activated", EVENT_TIMEOUT)
- def on_deactivated(v):
- for callback in all_callbacks['on_deactivated']:
- run_timed_function(lambda: callback.on_deactivated(v),
- callback.__module__, "on_deactivated", EVENT_TIMEOUT)
- def on_project_load(v):
- for callback in all_callbacks['on_project_load']:
- run_timed_function(lambda: callback.on_project_load(v),
- callback.__module__, "on_project_load", EVENT_TIMEOUT)
- def on_project_close(v):
- for callback in all_callbacks['on_project_close']:
- run_timed_function(lambda: callback.on_project_close(v),
- callback.__module__, "on_project_close", EVENT_TIMEOUT)
- def on_query_context(v, key, operator, operand, match_all):
- for callback in all_callbacks['on_query_context']:
- val = run_timed_function(lambda: callback.on_query_context(v, key, operator, operand, match_all),
- callback.__module__, "on_query_context", FAST_EVENT_TIMEOUT)
- if val:
- return True
- return False
- def on_query_completions(v, prefix, locations):
- completions = []
- flags = 0
- for callback in all_callbacks['on_query_completions']:
- res = callback.on_query_completions(v, prefix, locations)
- if isinstance(res, tuple):
- completions += res[0]
- flags |= res[1]
- elif isinstance(res, list):
- completions += res
- return (completions,flags)
- class Command(object):
- def name(self):
- clsname = self.__class__.__name__
- name = clsname[0].lower()
- last_upper = False
- for c in clsname[1:]:
- if c.isupper() and not last_upper:
- name += '_'
- name += c.lower()
- else:
- name += c
- last_upper = c.isupper()
- if name.endswith("_command"):
- name = name[0:-8]
- return name
- def is_enabled_(self, args):
- try:
- if args:
- if 'event' in args:
- del args['event']
- return self.is_enabled(**args)
- else:
- return self.is_enabled()
- except TypeError:
- return self.is_enabled()
- def is_enabled(self):
- return True
- def is_visible_(self, args):
- try:
- if args:
- return self.is_visible(**args)
- else:
- return self.is_visible()
- except TypeError:
- return self.is_visible()
- def is_visible(self):
- return True
- def is_checked_(self, args):
- try:
- if args:
- return self.is_checked(**args)
- else:
- return self.is_checked()
- except TypeError:
- return self.is_checked()
- def is_checked(self):
- return False
- def description_(self, args):
- try:
- if args:
- return self.description(**args)
- else:
- return self.description()
- except TypeError as e:
- return None
- def description(self):
- return None
- class ApplicationCommand(Command):
- def run_(self, args):
- if args:
- if 'event' in args:
- del args['event']
- return self.run(**args)
- else:
- return self.run()
- def run(self):
- pass
- class WindowCommand(Command):
- def __init__(self, window):
- self.window = window
- def run_(self, args):
- if args:
- if 'event' in args:
- del args['event']
- return self.run(**args)
- else:
- return self.run()
- def run(self):
- pass
- class TextCommand(Command):
- def __init__(self, view):
- self.view = view
- def run_(self, args):
- if args:
- if 'event' in args:
- del args['event']
- edit = self.view.begin_edit(self.name(), args)
- try:
- return self.run(edit, **args)
- finally:
- self.view.end_edit(edit)
- else:
- edit = self.view.begin_edit(self.name())
- try:
- return self.run(edit)
- finally:
- self.view.end_edit(edit)
- def run(self, edit):
- pass
- class EventListener(object):
- pass