def __init__(self, view, selEvent=None):
""" load settings """
self.view = view
self.selEvent = selEvent;
self.location = None;
self.settings = sublime.load_settings('ToolTipHelper.sublime-settings')
self.files = self.settings.get("files")
self.style = self.get_css_style()
self.keyorder = self.get_keyorder()
self.set_timeout = self.get_timeout()
self.max_width = self.get_max_width()
self.has_timeout = self.has_timeout()
self.has_debug = self.has_debug()
self.results_arr = []
self.last_choosen_fun = ""
self.last_index = 0
self.word_point = ()
self.logger_msg = ""
# self.__str__()
python类set_timeout()的实例源码
def on_close(self, view):
"""Clean up the visualization.
"""
if 'text.sublundo.tree' not in view.scope_name(0):
return
w = sublime.active_window()
single = not w.views_in_group(0) or not w.views_in_group(1)
if w.num_groups() == 2 and single:
sublime.set_timeout(lambda: w.set_layout(
{
"cols": [0.0, 1.0],
"rows": [0.0, 1.0],
"cells": [[0, 0, 1, 1]]
}
), 300)
w.run_command('hide_panel', {'panel': 'output.sublundo'})
w.destroy_output_panel('output.sublundo')
for v in w.views():
v.erase_regions('sublundo')
def run(self):
if self.process != None:
self.kill( "stop" )
if len(self.queue) <= 0:
return
cmd = self.queue.pop(0)
self.console.log('>>> # ' + cmd.cmd + '\n')
if cmd.env and cmd.env.get("CWD"):
os.chdir(cmd.env.get("CWD"))
else:
os.chdir(cmd.dir)
self.process = exec.AsyncProcess(None, cmd.cmd, cmd.env or {}, self)
self.timestamp = self.process.start_time
if cmd.timeout:
timestamp = self.timestamp
sublime.set_timeout(lambda:self.kill('timeout', timestamp), float(cmd.timeout))
def run(self):
if not self.is_running():
self.set_status('')
return
i = self.counter
before = i % self.size
after = (self.size - 1) - before
self.set_status('%s [%s=%s]' % (self.message, ' ' * before, ' ' * after))
if not after:
self.addend = -1
if not before:
self.addend = 1
self.counter += self.addend
sublime.set_timeout(lambda: self.run(), self.heartbeat)
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 plugin_loaded():
"""Load and unzip the files."""
sublime.set_timeout(init, 200)
def detach_view(view):
if view.view_id in view_event_listeners:
del view_event_listeners[view.view_id]
# A view has closed, which implies 'is_primary' may have changed, so see if
# any of the ViewEventListener classes need to be created.
# Call this in a timeout, as 'view' will still be reporting itself as a
# primary at this stage
global check_all_view_event_listeners_scheduled
if not check_all_view_event_listeners_scheduled:
check_all_view_event_listeners_scheduled = True
sublime.set_timeout(check_all_view_event_listeners)
def poll_copy(self):
# FIXME HACK: Stop polling after one minute
if self.active_for < 60000:
self.active_for += 50
sublime.set_timeout(self.copy_stuff, 50)
def plugin_loaded():
# When the plugin gets loaded everything should be dead so wait a bit to
# make sure views are ready, then try to restart all sessions.
sublime.set_timeout(restart_all_terminal_view_sessions, 100)
def _insert(self, view, content):
if view is None:
return
if self.results_in_new_tab and view.is_loading():
self.set_timeout(lambda: self._insert(view, content), 15)
else:
view.set_read_only(False)
view.run_command("view_insert", { "size": view.size(), "content": content })
view.set_viewport_position((0, view.size()), True)
view.set_read_only(True)
def setOutputCloseOnTimeout(self):
timeout = self.settings.get("results_autoclose_timeout_in_milliseconds", False)
if timeout:
self.set_timeout(self.close_panel, timeout)
def defer_sync(self, fn):
self.set_timeout(fn, 0)
def set_timeout(self, fn, delay):
sublime.set_timeout(fn, delay)
def __init__(self, message, success_message=''):
self.message = message
self.success_message = success_message
self.stopped = False
self.addend = 1
self.size = 8
sublime.set_timeout(lambda: self.run(0), 100)
def asap(self, view):
Pref.view = view
Pref.elapsed_time = 0.4
sublime.set_timeout(lambda:WordCount().run(True), 0)
def run(self):
# print ('running:'+str(time.time()))
Pref.running = True
if self.syntax and self.syntax in Pref.strip:
for item in Pref.strip[self.syntax]:
for k in range(len(self.content)):
self.content[k] = re.sub(item, '', self.content[k])
self.content_line = re.sub(item, '', self.content_line)
self.word_count = sum([self.count(region) for region in self.content])
if Pref.enable_count_chars:
if Pref.char_ignore_whitespace:
self.char_count = sum([len(''.join(region.split())) for region in self.content])
else:
self.char_count = sum([len(region) for region in self.content])
if Pref.enable_line_word_count:
self.word_count_line = self.count(self.content_line)
if Pref.enable_line_char_count:
if Pref.char_ignore_whitespace:
self.chars_in_line = len(''.join(self.content_line.split()))
else:
self.chars_in_line = len(self.content_line)
if not self.on_selection:
vs = self.view.settings()
ws = vs.get('WordCount', wsd)
ws['count'] = self.word_count
vs.set('WordCount', ws)
sublime.set_timeout(lambda:self.on_done(), 0)
def word_count_loop():
word_count = WordCount().run
while True:
# sleep time is adaptive, if takes more than 0.4 to calculate the word count
# sleep_time becomes elapsed_time*3
if Pref.running == False:
sublime.set_timeout(lambda:word_count(), 0)
time.sleep((Pref.elapsed_time*3 if Pref.elapsed_time > 0.4 else 0.4))
def pfile_modified(pfile, view):
pfile.dirty = True
now = time.time()
if now - pfile.last_modified > .5:
pfile.last_modified = now
if is_st2:
sublime.set_timeout(lambda: maybe_save_pfile(pfile, view, now), 5000)
else:
sublime.set_timeout_async(lambda: maybe_save_pfile(pfile, view, now), 5000)
if pfile.cached_completions and sel_start(view.sel()[0]) < pfile.cached_completions[0]:
pfile.cached_completions = None
if pfile.cached_arguments and sel_start(view.sel()[0]) < pfile.cached_arguments[0]:
pfile.cached_arguments = None
def error(self, string):
callback = lambda : self.error_callback(string)
sublime.set_timeout(callback, 1)
def hide(self, thread = None):
hide = False
if hide == True:
hide_time = time.time() + float(hide)
self.hide_time = hide_time
sublime.set_timeout(lambda : self.hide_callback(hide_time, thread), int(hide * 300))
