Sublime_plugin源代码免费分享！

Mozilla

sublime_text3组件Sublime_plugin源代码免费分享！请不要翻译此页！
" a0 Q. A, X# W5 S( E" f

1. import imp
   
2. import importlib
   
3. import os
   7 p/ r  s6 }9 g! I
4. import sys
   
5. import threading
   2 }( Y& O) a5 _* e; a7 K
6. import time
   
7. import traceback
     k- `4 z  [& S% Z
8. import zipfile
   0 W8 O! R# b. l" r7 |' S/ C
9. 
   ; G: e: V; a1 o4 C3 y
10. import sublime
    0 H* [% R' g1 [9 h% Y( e
11. import sublime_api
    % J( K2 P0 V3 Y) ~
12. 
    
13. 
    
14. api_ready = False
    
15. 
    % O  ?& c  P. f/ K6 J; ?7 {5 N
16. application_command_classes = []
    
17. window_command_classes = []
    1 N) Z; [5 [* q) E' y; A' p
18. text_command_classes = []
    
19. 
    ( ?) D9 B3 D3 m
20. view_event_listener_classes = []
    
21. view_event_listeners = {}
    9 H; c" W+ S: Y9 o' N7 S- T  ^1 ~0 x
22. 
    # P: p& x. p& ~# ?# O0 G# g: X" D
23. all_command_classes = [
    9 U% F. `' H  f8 h2 }' s* ^2 O
24.     application_command_classes,
    
25.     window_command_classes,
    * N, o% Q& i2 z" F/ ]4 t
26.     text_command_classes]
    8 V8 m0 d6 }; X& U2 i
27. 
    
28. all_callbacks = {
    
29.     'on_new': [],
    
30.     'on_clone': [],
    + s; {& n* c% D( z" W0 ~
31.     'on_load': [],
    
32.     'on_pre_close': [],
    9 ?/ P" f( Y% Q1 L7 R
33.     'on_close': [],
    5 R, ?" Z. D( X1 ?$ G! v( ~. ]& E% W
34.     'on_pre_save': [],
    
35.     'on_post_save': [],
    & P2 m( k' ?7 I6 Y
36.     'on_modified': [],
    , T0 P& K# f$ t5 \+ E- i1 S9 D  B" j
37.     'on_selection_modified': [],
    / K; ^2 K) k, Y* y' z
38.     'on_activated': [],
    
39.     'on_deactivated': [],
    ' D) a1 n4 w' P1 ~& M6 I
40.     'on_query_context': [],
    
41.     'on_query_completions': [],
    
42.     'on_hover': [],
    6 e& k6 D  J# t' w. }6 @# S
43.     'on_text_command': [],
    
44.     'on_window_command': [],
    4 J2 O* Q6 w; e4 H+ S
45.     'on_post_text_command': [],
    
46.     'on_post_window_command': [],
    $ h( A, X# X9 q9 }% p8 s. v7 ?
47.     'on_modified_async': [],
    8 C' O; {: b& J5 B0 h
48.     'on_selection_modified_async': [],
    
49.     'on_pre_save_async': [],
    
50.     'on_post_save_async': [],
    
51.     'on_activated_async': [],
    
52.     'on_deactivated_async': [],
    " Z# C9 _; B# w6 H
53.     'on_new_async': [],
    ! b% P. f- v" u8 @  H
54.     'on_load_async': [],
    , T/ A3 Y, G" @4 e* {5 W4 z8 `
55.     'on_clone_async': []}
    
56. 
    3 `% d' ?2 E8 s0 T
57. pending_on_activated_async_lock = threading.Lock()
    + `3 }- l" S& T1 r/ M
58. 
    9 `: r2 N/ z2 ?) j1 x: z
59. pending_on_activated_async_callbacks = {
    
60.     'EventListener': [],
    
61.     'ViewEventListener': []}
    
62. 
    6 S7 G/ a( o+ U. e0 C) z5 Q. L
63. profile = {}
    - C; r6 o5 s4 Q" d
64. 
    
65. 
    
66. def unload_module(module):
    
67.     if "plugin_unloaded" in module.__dict__:
    
68.         module.plugin_unloaded()
    
69.     # Check unload_handler too, for backwards compat
    
70.     if "unload_handler" in module.__dict__:
    ( g2 k% z) `4 e6 }1 B% R6 {
71.         module.unload_handler()
    * E+ n( [4 y7 F, l- w' s
72. 
    , P' H9 M# Y" w
73.     # Unload the old plugins
    
74.     if "__plugins__" in module.__dict__:
    " s9 ^0 n: T/ e: x
75.         for view_id, listener_instances in view_event_listeners.items():
    3 H9 T% A4 |) Y$ ]  K: C% V
76.             for vel in listener_instances[:]:
    ) j. O- C. L' A6 t+ j* n7 u
77.                 if vel.__class__ in module.__plugins__:
    . y, r! a  a& X$ e6 l: h& n4 \5 e* s
78.                     listener_instances.remove(vel)
    ) D$ q" i7 Y( i2 d5 t
79. 
    + {! l: O; l! p  N# ]
80.         for p in module.__plugins__:
    
81.             for cmd_cls_list in all_command_classes:
    1 L( W( B: q/ z6 X
82.                 try:
    ! @0 o8 j6 u3 I! c/ E
83.                     cmd_cls_list.remove(p)
    
84.                 except ValueError:
    
85.                     pass
    % Y/ p, `7 S. Q2 b% I9 V/ o3 P: ]
86.             for c in all_callbacks.values():
    1 q4 u: p% W/ E: J- g7 T0 T8 R& S
87.                 try:
    3 J7 ]3 R8 R+ d7 c0 _: P
88.                     c.remove(p)
    
89.                 except ValueError:
    % q7 r2 y7 R: Q- b) f. B
90.                     pass
    ( u9 y& s7 C4 C, @# T6 ?
91. 
    
92.             try:
    - l6 g$ Q$ m  W+ [3 ~
93.                 view_event_listener_classes.remove(p)
    ! Q+ d3 q3 d1 G0 ~* Q+ e  `( j$ y
94.             except ValueError:
    * ^/ x1 I0 k0 Y9 q
95.                 pass
    0 Z( n# C4 c* V3 B/ `' A7 Z
96. 
    
97. 
    7 y6 F+ Z7 Q7 A3 J7 [5 K, D: J
98. def unload_plugin(modulename):
    - [  i& J' b1 W; u8 y6 E/ _
99.     print("unloading plugin", modulename)
    
100. 
     
101.     was_loaded = modulename in sys.modules
     $ m* P2 d6 j0 p& ?; P2 V) z. e* [
102.     if was_loaded:
     
103.         m = sys.modules[modulename]
     
104.         unload_module(m)
     
105.         del sys.modules[modulename]
     6 _0 D, U% |- w* o% r
106. 
     4 R& L. K  e& x5 `
107. 
     # s0 \: W" @" X7 i, n$ a
108. def reload_plugin(modulename):
     
109.     print("reloading plugin", modulename)
     
110. 
     
111.     if modulename in sys.modules:
     ( A$ F# D6 M: m1 o3 j" O" |
112.         m = sys.modules[modulename]
     ( D0 B2 l5 L8 |9 a; |% y* n
113.         unload_module(m)
     
114.         m = imp.reload(m)
     
115.     else:
     
116.         m = importlib.import_module(modulename)
     
117. 
       @6 L0 X. m* X& e8 m7 M' v7 a1 e
118.     module_plugins = []
     
119.     on_activated_targets = []
     
120.     vel_on_activated_classes = []
     
121.     el_on_activated_async_targets = []
     
122.     vel_on_activated_async_targets = []
     
123.     module_view_event_listener_classes = []
     # D" s$ g/ i+ E: `. A
124.     for type_name in dir(m):
     
125.         try:
     
126.             t = m.__dict__[type_name]
     
127.             if t.__bases__:
     
128.                 is_plugin = False
     5 y% d& g$ I5 ~/ f6 ^, q2 K
129.                 if issubclass(t, ApplicationCommand):
     , v4 ]- N, C! D' e% F6 B, m
130.                     application_command_classes.append(t)
     " [9 b7 t8 n' ], N  x0 K4 U
131.                     is_plugin = True
     
132.                 if issubclass(t, WindowCommand):
     
133.                     window_command_classes.append(t)
     2 b. P5 {5 v3 K: f+ N+ ~1 D, |4 }
134.                     is_plugin = True
     # m3 L0 Y7 \4 T3 p2 b( Z$ {* ~
135.                 if issubclass(t, TextCommand):
     
136.                     text_command_classes.append(t)
     
137.                     is_plugin = True
     9 @- m7 X0 G+ N1 g1 S( E& J
138. 
     1 M0 c2 W& r3 I) Z, ^& u
139.                 if is_plugin:
     
140.                     module_plugins.append(t)
     ' I1 G& q8 H8 N! b3 b3 x
141. 
     
142.                 if issubclass(t, EventListener):
     
143.                     obj = t()
     3 b( K7 H/ z. d0 y) b' {
144.                     for p in all_callbacks.items():
     % ^# M* @7 n, L, _
145.                         if p[0] in dir(obj):
     
146.                             p[1].append(obj)
     
147. 
     
148.                     if "on_activated" in dir(obj):
     $ B# H; A3 {# h* m  x! x4 M( D& r
149.                         on_activated_targets.append(obj)
     
150. 
     
151.                     if "on_activated_async" in dir(obj):
     
152.                         el_on_activated_async_targets.append(obj)
     2 v9 d% s* {3 r( R/ s0 k9 ~+ E% P
153. 
     % L8 J5 a; }/ ^& E( @! K( i
154.                     module_plugins.append(obj)
     
155. 
     ) P5 K% s6 U  E$ ?! j7 d( X
156.                 if issubclass(t, ViewEventListener):
     & `* X0 Z# N1 t- b
157.                     view_event_listener_classes.append(t)
     0 g* J! X  k, q4 A, s
158.                     module_view_event_listener_classes.append(t)
     , M" t. j! W$ g" U: o0 `+ W
159.                     if "on_activated" in dir(t):
     
160.                         vel_on_activated_classes.append(t)
     
161.                     if "on_activated_async" in dir(t):
     6 H/ M  m5 x3 n& Y8 ?5 w! |
162.                         vel_on_activated_async_targets.append(t)
     
163.                     module_plugins.append(t)
     ; `. H. b+ x0 G! `
164. 
     
165.         except AttributeError:
     
166.             pass
     
167. 
     
168.     if el_on_activated_async_targets or vel_on_activated_async_targets:
     ; L& `) ^# l$ y
169.         with pending_on_activated_async_lock:
     3 C# J5 Q+ i. K4 E6 X
170.             pending_on_activated_async_callbacks['EventListener'].extend(
     ! O1 `3 Q! x3 A. [3 X4 o5 D+ r
171.                 el_on_activated_async_targets
     
172.             )
     
173.             pending_on_activated_async_callbacks['ViewEventListener'].extend(
     ; [* b/ E) t4 L
174.                 vel_on_activated_async_targets
     3 {- u4 {& ?; [3 y& S, V8 \+ h
175.             )
     
176. 
     
177.     if len(module_plugins) > 0:
     
178.         m.__plugins__ = module_plugins
     
179. 
       ^3 N* S! W/ J' T/ z& l
180.     if api_ready:
     7 Y- Y/ K3 |  I. ?4 q6 a+ a
181.         if "plugin_loaded" in m.__dict__:
     1 M6 X7 F! V5 T2 ]% A$ d
182.             try:
     
183.                 m.plugin_loaded()
     , {8 a" L; z( {  Z7 v
184.             except:
     - Z# u7 J" d( Y/ _2 W) F7 e$ H
185.                 traceback.print_exc()
     4 L( O! i9 `" Q5 F
186. 
     
187.         # Create any require ViewEventListener objects
     
188.         if len(module_view_event_listener_classes) > 0:
     
189.             for w in sublime.windows():
       B8 o' n4 g2 Q; C5 a* y  ]6 Q
190.                 for v in w.views():
     2 ?3 C8 z; A0 a2 `
191.                     create_view_event_listeners(
     
192.                         module_view_event_listener_classes, v)
     
193. 
     - ?2 x% l9 X' i
194.         # Synthesize any required on_activated calls
     8 Z; G) n. D5 N* {# {8 R! P
195.         w = sublime.active_window()
     1 W7 _" h7 [: a# W9 b
196.         if w:
     2 D, }  ]. J/ d9 r( [% c
197.             v = w.active_view()
     ; E5 C: G2 Z) K) J5 Q" m
198.             if v:
     . m7 z6 r/ p; R( F
199.                 for el in on_activated_targets:
     2 i2 X, V9 M5 S  b7 c0 b) o* I1 j: `
200.                     try:
       p; L, V1 I* O# p  }/ e6 t2 J
201.                         el.on_activated(v)
     + M/ j8 M: J1 D) P6 O; ~4 c$ H5 n
202.                     except:
     7 A1 h/ Q: ^7 C: u
203.                         traceback.print_exc()
     
204. 
     5 ]+ R0 J- E; k5 h
205.                 for vel_cls in vel_on_activated_classes:
     5 _. Z: C" U+ j! U; a# R
206.                     vel = find_view_event_listener(v, vel_cls)
     / }% y$ y' H4 R9 s! O
207.                     if not vel:
     
208.                         continue
     
209.                     try:
     
210.                         vel.on_activated()
     
211.                     except:
     
212.                         traceback.print_exc()
     2 v' N- I) a" G
213. 
     
214. 
     
215. def synthesize_on_activated_async():
     
216.     if not api_ready:
     
217.         return
     
218. 
     4 s7 t* `) `/ J1 D( O
219.     with pending_on_activated_async_lock:
       {3 _: [6 [5 }1 c" D) {" s* _
220.         els = pending_on_activated_async_callbacks['EventListener']
     
221.         vels = pending_on_activated_async_callbacks['ViewEventListener']
     
222.         pending_on_activated_async_callbacks['EventListener'] = []
     
223.         pending_on_activated_async_callbacks['ViewEventListener'] = []
     & F7 r1 V8 t% f4 U
224. 
     
225.     for el in els:
     
226.         w = sublime.active_window()
     ( D" I, J+ I* X, W* ~2 h8 d) v0 E
227.         if not w:
     
228.             continue
     - U9 y! g$ N) s" i/ M* w6 p5 [
229.         v = w.active_view()
     , ]* s/ ]/ U) N5 y
230.         if not v:
     
231.             continue
     + E1 c8 j, z4 o: O+ a  r3 ?
232.         try:
     
233.             el.on_activated_async(v)
     ( U, E+ d2 w/ h4 M
234.         except:
     
235.             traceback.print_exc()
     
236. 
     
237.     for vel_cls in vels:
     
238.         w = sublime.active_window()
     
239.         if not w:
     
240.             continue
     
241.         v = w.active_view()
       r/ Y- C6 z! D; N8 h& u
242.         if not v:
     : L( M* c0 h: ~) D7 ?
243.             continue
     
244.         vel = find_view_event_listener(v, vel_cls)
     5 \, ~$ H# Z$ P4 o" ]3 g. e) \
245.         if not vel:
     ' l' g$ \8 I5 D2 z$ \
246.             continue
     
247.         try:
     9 H6 f+ u. H2 }: c) T
248.             vel.on_activated_async()
     9 i  y7 m5 S4 y' [) u% A9 h
249.         except:
     ) ]& E6 j# R! J" A% F5 g7 h
250.             traceback.print_exc()
     
251. 
     ' k$ j) @. r8 ]1 z0 V
252. 
     - U3 \) q) J! r0 k' k5 z6 o  o
253. def create_application_commands():
     
254.     cmds = []
     3 h: \2 F1 e  T9 D/ t! X
255.     for class_ in application_command_classes:
     / T: D/ e% v' w; o1 k, I, g
256.         cmds.append(class_())
     , V# k; f  F! K: ?6 a+ Y! q: @
257.     sublime_api.notify_application_commands(cmds)
     
258. 
     4 `, i2 W0 G2 t3 D5 ?
259. 
     9 z4 ]0 B, G( v
260. def create_window_commands(window_id):
     ; `$ C3 S2 M; b' Q/ V
261.     window = sublime.Window(window_id)
     
262.     cmds = []
     
263.     for class_ in window_command_classes:
     ' d0 @& o9 I$ c) h+ m
264.         cmds.append(class_(window))
     
265.     return cmds
     
266. 
     0 h/ g( \6 Y! }# M. ~$ @  q. B  z
267. 
     
268. def create_text_commands(view_id):
     ' g" f- q1 Z! ]) C
269.     view = sublime.View(view_id)
     
270.     cmds = []
     
271.     for class_ in text_command_classes:
     
272.         cmds.append(class_(view))
     
273.     return cmds
     . d6 a) G3 d. C' W$ z* c( o3 Z
274. 
     
275. 
     + q$ |& N. C; s' g) [
276. def on_api_ready():
     % l+ {6 Y- w3 R2 t; o1 z% e- b- ]
277.     global api_ready
     8 P" a' I  X' ^" Y5 d* b) z8 H
278.     api_ready = True
     ) c6 O0 E: _6 o6 p& w2 e+ t. |
279. 
     1 k4 a, F; j: p: }) V
280.     for m in list(sys.modules.values()):
     
281.         if "plugin_loaded" in m.__dict__:
     # I/ T- R) p' a" }8 |$ q
282.             try:
     " H" i9 Y' G  J) `% X# f9 ^( `! D
283.                 m.plugin_loaded()
     
284.             except:
     
285.                 traceback.print_exc()
     
286. 
     
287.     # Create ViewEventListener instances
     
288.     if len(view_event_listener_classes) > 0:
     9 `4 b* v$ z7 h2 U
289.         for w in sublime.windows():
     
290.             for v in w.views():
     $ B! T! @+ X- ]7 U* K# h" e, i: w
291.                 attach_view(v)
     5 c6 B$ V2 |+ \  y
292. 
     
293.     # Synthesize an on_activated call
     
294.     w = sublime.active_window()
     
295.     if w:
     
296.         view_id = sublime_api.window_active_view(w.window_id)
     
297.         if view_id != 0:
     
298.             try:
     " _  b- w: d- w1 S6 s; n( G
299.                 on_activated(view_id)
     
300.             except:
     
301.                 traceback.print_exc()
     ! Q+ v) w' {: h. |1 ~
302. 
     
303. 
     
304. def is_view_event_listener_applicable(cls, view):
     
305.     if not cls.is_applicable(view.settings()):
     
306.         return False
     / A! X; e3 f3 K' C# G
307. 
     ' F8 Q4 {, p3 h4 }5 A% V1 S
308.     if cls.applies_to_primary_view_only() and not view.is_primary():
     
309.         return False
     
310. 
     7 Z/ J; ?. N3 ]5 a. N5 Y
311.     return True
     ( o: l+ n* W' f1 q) s! F
312. 
     
313. 
     
314. def create_view_event_listeners(classes, view):
     
315.     if len(classes) > 0:
     8 d) o3 x/ k1 c
316.         if view.view_id not in view_event_listeners:
     
317.             view_event_listeners[view.view_id] = []
     * g: G4 F  t' R$ t
318. 
     
319.         for c in classes:
     ; U# O+ C1 X* Z
320.             if is_view_event_listener_applicable(c, view):
     ( `7 H/ A( z, [& W% U0 j3 r
321.                 view_event_listeners[view.view_id].append(c(view))
     & [) q8 @' e) N* ~
322. 
     
323. 
     
324. def check_view_event_listeners(view):
     
325.     if len(view_event_listener_classes) > 0:
     
326.         if view.view_id not in view_event_listeners:
     ! w/ F1 Q1 j0 j1 I% \  ]
327.             view_event_listeners[view.view_id] = []
     9 u1 N4 h1 _7 t8 d4 S. `
328. 
     ) {6 R* U% D/ u. N  n* j& a
329.         listeners = view_event_listeners[view.view_id]
     
330. 
       C4 w. R6 _  e% O7 J
331.         for cls in view_event_listener_classes:
       U# ]% x* ]* p1 X( E
332.             found = False
     * J" O( `  C) D4 F- W
333.             instance = None
     , f, n( X  }) R7 i7 b# x* g
334.             for l in listeners:
     9 T- e3 T& e9 ]2 N0 n# z
335.                 if l.__class__ == cls:
     
336.                     found = True
     * X3 A9 C! N, [/ F+ b
337.                     instance = l
     + F; Q8 ]# m4 F; u: M5 [" F
338.                     break
     
339. 
     $ M& E" A3 b5 K% r" z+ s( ^
340.             want = is_view_event_listener_applicable(cls, view)
     
341. 
     
342.             if want and not found:
     
343.                 listeners.append(cls(view))
     
344.             elif found and not want:
     4 K( k4 h& e! S1 ~9 b1 w) C4 k
345.                 listeners.remove(instance)
     
346. 
     
347. 
     * w+ N- n; c2 X5 A1 p0 q( Y
348. def attach_view(view):
     
349.     check_view_event_listeners(view)
     3 [, W/ W) p$ \% j
350. 
     + Q& k" m" D8 \  C' C
351.     view.settings().add_on_change(
     $ w5 h0 k) Z0 C9 v
352.         "check_view_event_listeners",
     + S5 K, }% K" P9 [# Q
353.         lambda: check_view_event_listeners(view))
     
354. 
     
355. 
     
356. check_all_view_event_listeners_scheduled = False
     7 T1 T" `. L$ C, Z, l, z9 A
357. 
     / I5 p/ G  H* R7 e  y
358. 
     % }6 t+ ]7 X3 ~: X: ?2 j( m! H6 H
359. def check_all_view_event_listeners():
     
360.     global check_all_view_event_listeners_scheduled
     3 x) u. E5 E1 I  u+ j
361.     check_all_view_event_listeners_scheduled = False
     
362.     for w in sublime.windows():
     
363.         for v in w.views():
     5 U" f- I$ t/ S* K3 k; {
364.             check_view_event_listeners(v)
     # |) t$ O' T) d( k
365. 
     
366. 
     ' P1 j# w' f; \4 C8 u
367. def detach_view(view):
     
368.     if view.view_id in view_event_listeners:
     
369.         del view_event_listeners[view.view_id]
     
370. 
     
371.     # A view has closed, which implies 'is_primary' may have changed, so see if
     $ t4 M1 C- C& a# U) M
372.     # any of the ViewEventListener classes need to be created.
     1 M9 ~8 ]5 H) X" d. Y# l& c9 N+ W
373.     # Call this in a timeout, as 'view' will still be reporting itself as a
     " a* O5 U% ]' C7 F
374.     # primary at this stage
     , ^7 E2 k7 ?2 u3 a- J
375.     global check_all_view_event_listeners_scheduled
     % x# a& g4 p+ q, p! T9 L+ M$ C
376.     if not check_all_view_event_listeners_scheduled:
     8 K% w# _7 k- ~8 C
377.         check_all_view_event_listeners_scheduled = True
     
378.         sublime.set_timeout(check_all_view_event_listeners)
     
379. 
     
380. 
     
381. def event_listeners_for_view(view):
     
382.     if view.view_id in view_event_listeners:
       z+ g8 t, X9 p7 z8 j
383.         return view_event_listeners[view.view_id]
     " h& P! [9 l6 U. c" l
384.     else:
     % c5 I+ g; U; N% y( u. x' ?! X" Q
385.         return []
     
386. 
     
387. 
     % [9 p6 k; P+ _$ \2 J  @2 \# I
388. def find_view_event_listener(view, cls):
     / E9 n$ t3 {" E* ]
389.     if view.view_id in view_event_listeners:
     
390.         for vel in view_event_listeners[view.view_id]:
     
391.             if vel.__class__ == cls:
     
392.                 return vel
     4 I, j7 I: l) y& O
393.     return None
     & e2 o$ ?  j# m3 \* o8 E
394. 
     
395. 
     
396. def on_new(view_id):
     
397.     v = sublime.View(view_id)
     
398. 
     , i3 x( j0 D, ~7 ~3 ]; `
399.     attach_view(v)
     6 @6 \3 \4 D6 R9 f8 P1 ~2 X
400. 
     + \" e# l, A7 l* W
401.     for callback in all_callbacks['on_new']:
     
402.         try:
     
403.             callback.on_new(v)
     . G" X3 v2 _$ d" J6 Y! O: ?5 N
404.         except:
     / G( @) m1 w0 q# F5 ?! D( ~
405.             traceback.print_exc()
     
406. 
     
407. 
     " q; \5 p1 U$ ?8 H
408. def on_new_async(view_id):
     
409.     v = sublime.View(view_id)
     , B$ Q: ]. U8 z7 o, F
410.     for callback in all_callbacks['on_new_async']:
     
411.         try:
     
412.             callback.on_new_async(v)
     
413.         except:
     6 q5 b( ^3 H7 o4 d% T* _
414.             traceback.print_exc()
     % a9 m5 w" _1 A* J
415. 
     
416. 
     " l  A/ l; Y$ `/ g1 z
417. def on_clone(view_id):
     
418.     v = sublime.View(view_id)
     
419. 
     ! K5 F$ C! C7 ^0 n& t' m* @
420.     attach_view(v)
     
421. 
     
422.     for callback in all_callbacks['on_clone']:
     
423.         try:
     5 o* K9 R' ^7 h8 J8 f
424.             callback.on_clone(v)
     
425.         except:
     6 l, U# B+ b4 y+ A  H2 u! P
426.             traceback.print_exc()
     
427. 
     
428. 
     ) I- Z5 ^% Y7 P! ]# j0 p
429. def on_clone_async(view_id):
     7 D2 C; z8 h- b  u9 d: z
430.     v = sublime.View(view_id)
       b- u+ d: T6 |+ Z# j% ~: B! k# D
431.     for callback in all_callbacks['on_clone_async']:
     ! `: l7 X6 @! \  ^. U# G
432.         try:
     3 q) L: _+ K7 x5 }
433.             callback.on_clone_async(v)
       ^( N; r7 Y. ^& P! x8 v3 j
434.         except:
     
435.             traceback.print_exc()
     
436. 
     9 ?5 t2 H* f# T$ |2 y7 \  w" p
437. 
     , D- }+ E4 M* U/ R) N$ ]- L
438. class Summary(object):
     
439.     def __init__(self):
     6 T6 I+ h2 b/ O/ v
440.         self.max = 0.0
     ! }- a3 M! H8 k0 g. u- R
441.         self.sum = 0.0
     ( M; G. ?* Q, S7 W8 y
442.         self.count = 0
     
443. 
     
444.     def record(self, x):
     4 a" F2 Z% w8 v; L
445.         self.count += 1
     
446.         self.sum += x
       C* q+ r/ s  i% N6 y
447.         self.max = max(self.max, x)
     
448. 
     
449.     def __str__(self):
     
450.         if self.count > 1:
     4 c9 m; b  U  H9 i
451.             return "{0:.3f}s total, mean: {1:.3f}s, max: {2:.3f}s".format(self.sum, self.sum / self.count, self.max)
     
452.         elif self.count == 1:
     
453.             return "{0:.3f}s total".format(self.sum)
     
454.         else:
     , J, X/ L1 c8 z* ]1 e
455.             return "0s total"
     
456. 
     
457. 
     4 d! p* e9 y! n/ e* K, s& R" O  z
458. def run_callback(event, callback, expr):
     
459.     t0 = time.time()
     
460. 
     
461.     try:
     
462.         expr()
     
463.     except:
     . A6 @% O2 g4 f. b! ^# t
464.         traceback.print_exc()
     
465. 
     
466.     elapsed = time.time() - t0
     
467. 
     : c- m9 l: I* o. u  k
468.     if event not in profile:
     - W9 \) W2 ?$ [
469.         profile[event] = {}
     ; Y, a4 `9 _0 ]
470. 
     ( c( B0 b9 X! z2 s! Y- E' h, A
471.     p = profile[event]
     
472. 
     1 o% H8 `+ A( L6 ]6 U; D, ]
473.     name = callback.__module__
     
474.     if name not in p:
     
475.         p[name] = Summary()
     
476. 
     
477.     p[name].record(elapsed)
     # R3 R5 T* V- H8 ^" j7 s8 r
478. 
     
479. 
     3 h) H3 O& w" _9 ^- f
480. def run_view_listener_callback(view, name):
     $ p$ u/ ]% z/ W# _2 {6 d6 }7 z
481.     for vel in event_listeners_for_view(view):
     : O) I& Z$ t2 Y: h$ y
482.         if name in vel.__class__.__dict__:
     
483.             run_callback(name, vel, lambda: vel.__class__.__dict__[name](vel))
     
484. 
     
485. 
     
486. def run_async_view_listener_callback(view, name):
     
487.     for vel in event_listeners_for_view(view):
     
488.         if name in vel.__class__.__dict__:
     0 e- `0 v- g3 S# c5 M& S) g
489.             try:
     0 h% F6 r' M6 H6 \
490.                 vel.__class__.__dict__[name](vel)
     
491.             except:
     9 ~" a5 ?( L  Y  N0 F: z) a( c  B) ^
492.                 traceback.print_exc()
     
493. 
     
494. 
     
495. def on_load(view_id):
     7 b8 U: s8 N& y* Z; L
496.     v = sublime.View(view_id)
     
497. 
     
498.     attach_view(v)
     
499. 
     
500.     for callback in all_callbacks['on_load']:
     8 e( w6 s$ a& T' c
501.         run_callback('on_load', callback, lambda: callback.on_load(v))
     8 l# n% N+ X  ~+ n0 F8 B+ t
502.     run_view_listener_callback(v, 'on_load')
     
503. 
     8 e+ C% L! s! S1 g- c
504. 
     + ?" R( z6 j; E: @5 X
505. def on_load_async(view_id):
     . [" l+ G; Q$ l9 t! V
506.     v = sublime.View(view_id)
     
507.     for callback in all_callbacks['on_load_async']:
     ' I- ?" w: H! O2 c! z& R
508.         try:
     5 k( h+ V7 @" b+ V  N
509.             callback.on_load_async(v)
     
510.         except:
     ( n9 Z/ o$ H( T. C# Y- b, O
511.             traceback.print_exc()
     ' _1 ?* Q, g4 F
512.     run_async_view_listener_callback(v, 'on_load_async')
     
513. 
     
514. 
     
515. def on_pre_close(view_id):
     2 F8 P& L. T' |! R
516.     v = sublime.View(view_id)
       i/ k. g# Y# g$ n( N
517.     for callback in all_callbacks['on_pre_close']:
     
518.         run_callback('on_pre_close', callback, lambda: callback.on_pre_close(v))
     
519.     run_view_listener_callback(v, 'on_pre_close')
     
520. 
     + \5 C$ b7 F, D9 T! a
521. 
     , j, M3 d2 M  N. q# X
522. def on_close(view_id):
     8 J2 `2 }; x0 I: b) M: V
523.     v = sublime.View(view_id)
     1 h  d5 `& l( Y  ~0 N
524. 
     ; C: m" d5 A- z5 _# j4 l
525.     run_view_listener_callback(v, 'on_close')
     
526.     detach_view(v)
     0 }2 c( Q1 v/ B3 ^# K: X
527. 
     
528.     for callback in all_callbacks['on_close']:
     5 K: C7 ?# l4 d( `( k8 p
529.         run_callback('on_close', callback, lambda: callback.on_close(v))
     
530. 
     ! @1 @8 s" G+ g8 j: R# y
531. 
     ( e0 j' S( T$ W7 t  L4 u
532. def on_pre_save(view_id):
     
533.     v = sublime.View(view_id)
     & h3 h8 K( }" `, g+ [( f0 c& }
534.     for callback in all_callbacks['on_pre_save']:
     
535.         run_callback('on_pre_save', callback, lambda: callback.on_pre_save(v))
     5 w( S& S9 b4 f
536.     run_view_listener_callback(v, 'on_pre_save')
       J7 c5 d, G& t8 L
537. 
     . `, H* d( w0 J
538. 
     
539. def on_pre_save_async(view_id):
     ( C$ t# @% M' V% P
540.     v = sublime.View(view_id)
     / h) u4 }2 [! U' X6 k4 w; u; b
541.     for callback in all_callbacks['on_pre_save_async']:
     
542.         try:
     5 L# L+ J6 Y5 c. l% \5 E& y
543.             callback.on_pre_save_async(v)
     
544.         except:
     0 P4 T  l6 w  t) Q1 H5 ]( m8 ?5 u
545.             traceback.print_exc()
     8 P: {) K1 A. x: l7 r& a6 U
546.     run_async_view_listener_callback(v, 'on_pre_save_async')
     - A& o3 J# J' N( f' a+ w& p
547. 
     $ B1 {! i3 n: f' ^
548. 
     5 Z1 }0 {3 t+ \# s2 S$ @2 K0 n8 |, a
549. def on_post_save(view_id):
     
550.     v = sublime.View(view_id)
     7 L, z/ [. m& M
551.     for callback in all_callbacks['on_post_save']:
     4 ?* j. a: p1 T8 ]/ S
552.         run_callback('on_post_save', callback, lambda: callback.on_post_save(v))
     
553.     run_view_listener_callback(v, 'on_post_save')
     ! Z% }6 X0 Y# o, p" k
554. 
     2 {6 @0 q; B  J- N8 i, ~, s4 T
555. 
     
556. def on_post_save_async(view_id):
     8 r7 _3 O- A. i* w
557.     v = sublime.View(view_id)
     
558.     for callback in all_callbacks['on_post_save_async']:
     
559.         try:
     
560.             callback.on_post_save_async(v)
     9 Z0 g- Q. e" v% u
561.         except:
     
562.             traceback.print_exc()
     
563.     run_async_view_listener_callback(v, 'on_post_save_async')
     
564. 
     
565. 
     ! H. Y/ B7 R: |* X& |5 A
566. def on_modified(view_id):
     
567.     v = sublime.View(view_id)
     * y0 u4 z. |. V8 I3 V' `& w; D4 w' Q
568.     for callback in all_callbacks['on_modified']:
     
569.         run_callback('on_modified', callback, lambda: callback.on_modified(v))
     
570.     run_view_listener_callback(v, 'on_modified')
     
571. 
     ! O  M* Q8 N- o+ ^
572. 
     
573. def on_modified_async(view_id):
     7 K3 J) B! R, m6 q: [" {
574.     v = sublime.View(view_id)
     - @" ?% {  k3 i' k, l% u. U' w) C
575.     for callback in all_callbacks['on_modified_async']:
     ' R- f  W2 _8 Q
576.         try:
     6 |+ t( L' \$ _3 ~
577.             callback.on_modified_async(v)
     & O# B0 [, D# G1 M
578.         except:
     
579.             traceback.print_exc()
     7 L6 ~: L8 ~1 O; n+ W. T8 ^% h
580.     run_async_view_listener_callback(v, 'on_modified_async')
     
581. 
     
582. 
     
583. def on_selection_modified(view_id):
     , O/ Z  [+ p# \5 E. t" J$ i7 U
584.     v = sublime.View(view_id)
     
585.     for callback in all_callbacks['on_selection_modified']:
     
586.         run_callback('on_selection_modified', callback, lambda: callback.on_selection_modified(v))
     
587.     run_view_listener_callback(v, 'on_selection_modified')
     % ?" e- e8 x9 p
588. 
     
589. 
     : w: A; K6 n5 q- }, Y" B0 E
590. def on_selection_modified_async(view_id):
     
591.     v = sublime.View(view_id)
     % k3 r- O/ i1 p# [5 _/ ~
592.     for callback in all_callbacks['on_selection_modified_async']:
     4 E7 a! ]$ y( i5 |6 l1 D
593.         try:
     5 `6 L4 J& a  A, T
594.             callback.on_selection_modified_async(v)
     8 }# w" F% m/ F9 d, i0 a! N8 s
595.         except:
     - t; K0 H" L9 I. c7 H* ?) t7 J9 B) m
596.             traceback.print_exc()
     / \% `. B0 U) K4 v6 l$ s
597.     run_async_view_listener_callback(v, 'on_selection_modified_async')
     
598. 
     & G) j' J. Z# k# H3 t
599. 
     
600. def on_activated(view_id):
     
601.     v = sublime.View(view_id)
     
602.     for callback in all_callbacks['on_activated']:
     
603.         run_callback('on_activated', callback, lambda: callback.on_activated(v))
     
604.     run_view_listener_callback(v, 'on_activated')
     
605. 
     * O+ u" b$ I2 S4 G
606. 
     
607. def on_activated_async(view_id):
     
608.     v = sublime.View(view_id)
     
609.     for callback in all_callbacks['on_activated_async']:
     
610.         try:
     , _' v2 ~$ T% w, U, u, m
611.             callback.on_activated_async(v)
     
612.         except:
     " W) |7 D/ o2 L' h* N+ a
613.             traceback.print_exc()
     6 ~; K. E# E8 Q4 z3 y
614.     run_async_view_listener_callback(v, 'on_activated_async')
     6 F" [- M' K/ g" a' Y" b
615. 
     
616. 
     
617. def on_deactivated(view_id):
     
618.     v = sublime.View(view_id)
     
619.     for callback in all_callbacks['on_deactivated']:
     
620.         run_callback('on_deactivated', callback, lambda: callback.on_deactivated(v))
     " U# s9 X, \( ]6 @/ D
621.     run_view_listener_callback(v, 'on_deactivated')
     , E- ?$ _/ t4 \# d6 F2 |
622. 
     
623. 
     
624. def on_deactivated_async(view_id):
     
625.     v = sublime.View(view_id)
     
626.     for callback in all_callbacks['on_deactivated_async']:
     
627.         try:
       _( I7 f4 K' \" Z5 w8 {
628.             callback.on_deactivated_async(v)
     
629.         except:
     5 _9 K9 M, W) C% s
630.             traceback.print_exc()
     ( q5 `* k: N. v% L# U, a- F+ p
631.     run_async_view_listener_callback(v, 'on_deactivated_async')
     - c+ Z, W! F; ?3 M7 i
632. 
     
633. 
     5 Z0 f# E5 `5 G
634. def on_query_context(view_id, key, operator, operand, match_all):
     8 E5 }& d' X# ?2 b: G3 E
635.     v = sublime.View(view_id)
     
636.     for callback in all_callbacks['on_query_context']:
     & X2 v; x4 y. H1 i6 c
637.         try:
     
638.             val = callback.on_query_context(v, key, operator, operand, match_all)
     . e5 b. f& v$ {) O' @" h; ~. R/ b7 `
639.             if val:
     / V4 s% H& C( G( \7 t' J4 h
640.                 return True
     
641.         except:
     6 P7 d  {' r% Y; L- e
642.             traceback.print_exc()
     $ J' f" j6 m& @/ x/ D& m
643. 
     
644.     for vel in event_listeners_for_view(v):
     " O5 Q( e* X6 v/ i8 z1 t
645.         if 'on_query_context' in vel.__class__.__dict__:
     
646.             try:
     0 b* x9 b2 x- U1 D% f8 o
647.                 val = vel.on_query_context(key, operator, operand, match_all)
     
648.                 if val:
     
649.                     return True
     
650.             except:
     & B4 {( b7 l! b/ n' W6 v. n
651.                 traceback.print_exc()
     & J0 n2 A1 F% c$ j- ]; y
652. 
     ; `& G/ o0 s' q5 y5 a$ V6 p' G
653.     return False
     
654. 
     
655. 
     ! D4 ], a) }- Q4 ~/ a. X
656. def normalise_completion(c):
     
657.     if len(c) == 1:
     8 F  `0 ?* t. n- r3 b/ g0 d- I
658.         return (c[0], "", "")
     + \* z+ ?; @# P# Y' n  M7 S% T2 g
659.     elif len(c) == 2:
     8 r: e, n0 a* A, h5 T
660.         return (c[0], "", c[1])
     * }: V5 B( [" Y  Q  d1 c
661.     else:
     
662.         return c
     ' K4 c% P6 Y( R( V
663. 
     ' c2 z4 N# g, s# Z" }' T
664. 
     & {. v. \. [5 h3 P
665. def on_query_completions(view_id, prefix, locations):
     
666.     v = sublime.View(view_id)
     6 |9 H1 k5 o) f, F7 z' a3 k1 d
667. 
     
668.     completions = []
     
669.     flags = 0
     
670.     for callback in all_callbacks['on_query_completions']:
     
671.         try:
     
672.             res = callback.on_query_completions(v, prefix, locations)
     # X. \2 J* D, z9 O8 [% d/ D; o1 M
673. 
     
674.             if isinstance(res, tuple):
     * ?8 t* U4 a) Z, U2 m! v
675.                 completions += [normalise_completion(c) for c in res[0]]
     
676.                 flags |= res[1]
     - V9 N  N" b: Q8 k! g) \) Y
677.             elif isinstance(res, list):
     
678.                 completions += [normalise_completion(c) for c in res]
     
679.         except:
     
680.             traceback.print_exc()
     
681. 
     
682.     for vel in event_listeners_for_view(v):
     ' O  g- t# r8 d- H2 x1 U
683.         if 'on_query_completions' in vel.__class__.__dict__:
     # K3 X+ k# b, V% q+ J" E! x$ N
684.             try:
     7 c* d& _% u( ~& ]5 ~7 x
685.                 res = vel.on_query_completions(prefix, locations)
     
686. 
     : }) B- O6 z% X6 W+ m
687.                 if isinstance(res, tuple):
     
688.                     completions += [normalise_completion(c) for c in res[0]]
     + Q7 u- d7 M2 R8 S, r2 R1 l: p- I
689.                     flags |= res[1]
     # A4 T0 u+ d1 S# m! Q
690.                 elif isinstance(res, list):
     9 p5 S# r3 J' _/ b& x7 H& y
691.                     completions += [normalise_completion(c) for c in res]
     
692.             except:
     $ N7 O) }. s7 b* N
693.                 traceback.print_exc()
     6 \$ t* F# ^  z  ?
694. 
     0 b4 \/ ^" k9 u/ t
695.     return (completions, flags)
     
696. 
     
697. 
     
698. def on_hover(view_id, point, hover_zone):
     
699.     v = sublime.View(view_id)
     
700.     for callback in all_callbacks['on_hover']:
     / z( t  d! ~* ?: D% C9 T8 y+ m5 Q
701.         run_callback('on_hover', callback, lambda: callback.on_hover(v, point, hover_zone))
     ; Z) I; _; Z! e( N
702. 
     
703.     for vel in event_listeners_for_view(v):
     9 N. n5 y2 w6 Y" w+ ?
704.         if 'on_hover' in vel.__class__.__dict__:
     
705.             try:
     
706.                 vel.on_hover(point, hover_zone)
     
707.             except:
     " |+ ?( Z& x" I% o0 L: H" L$ T
708.                 traceback.print_exc()
     
709. 
     
710. 
     ! ?$ g; P$ ^5 p# x* t7 M
711. def on_text_command(view_id, name, args):
     
712.     v = sublime.View(view_id)
     ! w2 ?& }. {! S& J
713. 
     , y! R& h& \0 b: r% b
714.     for vel in event_listeners_for_view(v):
     . l/ C8 A6 q0 C) N$ c
715.         if 'on_text_command' in vel.__class__.__dict__:
     / G% E; y2 D7 p
716.             try:
     ; r+ [$ r  R/ W) p: S8 b
717.                 res = vel.on_text_command(name, args)
     
718.                 if isinstance(res, tuple):
     ! f- V' s0 h$ ?% B( A$ x9 W/ \
719.                     return res
     
720.                 elif res:
     
721.                     return (res, None)
     0 C- F, @; [6 A* m2 s
722.             except:
     
723.                 traceback.print_exc()
     % J. H- W0 t- R0 ~
724. 
     $ q/ j/ w% {+ G& N
725.     for callback in all_callbacks['on_text_command']:
     
726.         try:
     
727.             res = callback.on_text_command(v, name, args)
     # d6 {0 x1 f) Y5 a; E$ X* }
728.             if isinstance(res, tuple):
     
729.                 return res
     
730.             elif res:
     # F- g* z* e; X  L8 z
731.                 return (res, None)
     ! V% D6 g3 j  a9 Y$ M% v6 Y
732.         except:
     
733.             traceback.print_exc()
     
734. 
     ; ?2 N' g: E1 c9 \; O# H2 {2 Q
735.     return ("", None)
     
736. 
     
737. 
     5 i7 F1 O2 r; [: I6 e5 V" d
738. def on_window_command(window_id, name, args):
     " ?. I: i1 B/ W( b- o  |# L
739.     window = sublime.Window(window_id)
     
740.     for callback in all_callbacks['on_window_command']:
     
741.         try:
     , _7 h$ h3 b# L
742.             res = callback.on_window_command(window, name, args)
     - n3 E) |* a/ r( G, j
743.             if isinstance(res, tuple):
     
744.                 return res
     
745.             elif res:
     ( ^) B, \9 \  M  ]
746.                 return (res, None)
     3 B" d# D" L. U: R1 X, t& l
747.         except:
     
748.             traceback.print_exc()
     % c) }/ M& W& R0 I* {; m; f
749. 
     
750.     return ("", None)
     ' [' q1 P/ P) _! {7 S7 ?
751. 
     
752. 
     * r0 k; Y- e, P
753. def on_post_text_command(view_id, name, args):
     3 ?: H% Y) o; {  v
754.     v = sublime.View(view_id)
     
755.     for callback in all_callbacks['on_post_text_command']:
     
756.         try:
     - O6 [# O( V# g) L3 a
757.             callback.on_post_text_command(v, name, args)
     ' I4 j7 m8 X5 f6 y# R0 Q  V9 n, e
758.         except:
     9 B+ ]1 p  g. c+ i( ^$ }) h
759.             traceback.print_exc()
     
760. 
     $ ^; Y  ?7 A* {% s2 l, C
761.     for vel in event_listeners_for_view(v):
     " A3 g' ]) H% `  w
762.         if 'on_post_text_command' in vel.__class__.__dict__:
     ) e# X3 b9 ~. U6 W
763.             try:
     
764.                 vel.on_post_text_command(name, args)
     
765.             except:
     ( O  [6 R' v" @3 [
766.                 traceback.print_exc()
     
767. 
     
768. 
     
769. def on_post_window_command(window_id, name, args):
     ; u7 e: H; [$ o0 H4 ~# S
770.     window = sublime.Window(window_id)
     , a8 F* x" Q: w- U
771.     for callback in all_callbacks['on_post_window_command']:
     2 @% @& u* l6 s
772.         try:
     . W% }- s# f& b. S. @
773.             callback.on_post_window_command(window, name, args)
     1 l' e3 s# Y" i4 E) |
774.         except:
     
775.             traceback.print_exc()
     
776. 
     
777. 
     * F3 Y+ H+ o9 k, m; H
778. class CommandInputHandler(object):
     
779.     def name(self):
     * B8 l' F7 H6 c2 H
780.         clsname = self.__class__.__name__
     
781.         name = clsname[0].lower()
     
782.         last_upper = False
     & W3 j) c4 k9 H8 k: B, y
783.         for c in clsname[1:]:
     ) t& z7 m+ n9 [2 i+ X& L
784.             if c.isupper() and not last_upper:
     
785.                 name += '_'
     2 ^6 ]. Q2 k1 n, W( x' O% N
786.                 name += c.lower()
     8 T: q; E; m% k! T0 d" S- F
787.             else:
     + K* X$ `. ^& e: v8 x
788.                 name += c
     % P+ \+ n  h( ?& N" h% o2 a4 S
789.             last_upper = c.isupper()
     
790.         if name.endswith("_input_handler"):
     ) h+ l5 h) C& g2 v  \
791.             name = name[0:-14]
     
792.         return name
     . ]  _3 g8 W7 d- k& `
793. 
     
794.     def next_input(self, args):
     
795.         return None
     
796. 
     , |' p4 E& {8 n. U
797.     def placeholder(self):
     9 j1 t! Z& t+ w8 I! a
798.         return ""
     . R5 x0 Q/ S/ \6 B) b7 b7 A
799. 
     
800.     def initial_text(self):
     " ^" K  r9 g+ v
801.         return ""
     ; o+ ]0 B6 Y+ q# [. c! F
802. 
     
803.     def preview(self, arg):
     7 B  S0 h: B5 y
804.         return ""
     
805. 
     2 E0 W" {0 v) W8 J8 x3 b  x
806.     def validate(self, arg):
     
807.         return True
     
808. 
     
809.     def cancel(self):
     
810.         pass
     
811. 
     $ V4 T* l* X5 ~3 W" Y& A
812.     def confirm(self, arg):
     ) O& m. `2 k4 ~2 D  e. S
813.         pass
     
814. 
     8 R) R: b. o5 j. D
815.     def create_input_handler_(self, args):
     0 D* ]( R$ K( M8 y1 o2 T; n1 k# M
816.         return self.next_input(args)
     
817. 
     1 u/ L9 w6 j, V
818.     def preview_(self, v):
     1 q% L1 o2 g- b& F9 ~
819.         ret = self.preview(v)
     1 `6 U6 H! |8 y0 h. g  p2 r* ~
820. 
     
821.         if ret is None:
     4 [1 H$ Q' a3 x$ z2 d* l
822.             return ("", 0)
     
823.         elif isinstance(ret, sublime.Html):
     
824.             return (ret.data, 1)
     
825.         else:
     ; ^' {( |# W8 w- j& ~$ ~
826.             return (ret, 0)
     
827. 
     % u3 d, i8 N3 w8 d" Z& T
828.     def validate_(self, v):
     5 W  Y6 a$ K5 ^2 h3 Z+ ~- k
829.         return self.validate(v)
     2 J4 L7 K3 k8 l
830. 
     1 R4 s# ^8 v+ T' c
831.     def cancel_(self):
     / `/ p5 a+ C4 B9 |; H( s
832.         self.cancel()
     
833. 
     
834.     def confirm_(self, v):
     
835.         self.confirm(v)
     ; \$ f3 }9 ?2 }2 i
836. 
     6 N3 S3 H! n9 n3 f+ \7 K% g1 H
837. 
     
838. class BackInputHandler(CommandInputHandler):
     
839.     def name(self):
     
840.         return "_Back"
     , ~4 K" A9 _7 W7 m
841. 
     
842. 
     
843. class TextInputHandler(CommandInputHandler):
     $ D; |  {2 e) q% s+ N  \
844.     def description(self, text):
     
845.         return text
     
846. 
     
847.     def setup_(self, args):
     ' P) m/ a" J. e
848.         props = {
     * w' o6 k2 x5 l6 l9 @5 M& E/ U
849.             "initial_text": self.initial_text(),
     
850.             "placeholder_text": self.placeholder(),
     4 t) Z5 S+ N- a, N9 {2 E( @
851.             "type": "text",
     
852.         }
     
853. 
     & p" v4 ?5 j% h& O% Z
854.         return ([], props)
     
855. 
     
856.     def description_(self, v, text):
     
857.         return self.description(text)
     
858. 
     
859. 
     8 R' I% z9 G7 g
860. class ListInputHandler(CommandInputHandler):
     0 h2 X: j! T( |2 W+ ^. l. {
861.     def list_items(self):
     ! ^7 Y* }$ ^8 H
862.         return []
     ( Z4 d+ e3 d9 q; @7 {1 j
863. 
     8 n( Y) p; y! W
864.     def description(self, v, text):
     + e9 A2 k* L2 Z. z+ g9 j4 S7 O, J
865.         return text
     * I' |0 J% L+ E3 R. R4 J5 h) b0 C4 Y
866. 
     8 I; I+ h7 T% y! X2 J  a/ _0 z
867.     def setup_(self, args):
     % U2 S$ X4 W! M) q  N. ^
868.         items = self.list_items()
     
869. 
     # S2 T2 E3 P( J5 @
870.         selected_item_index = -1
     + }4 x( C/ ~# t: A
871. 
     2 J7 P. g% I# ^
872.         if isinstance(items, tuple):
     
873.             items, selected_item_index = items
     
874. 
     
875.         for i in range(len(items)):
     2 e" c: O8 o% a: l( ^' }; R1 e
876.             it = items[i]
     ) h/ q/ [+ X7 i! y; C8 f
877.             if isinstance(it, str):
     
878.                 items[i] = (it, it)
     . k7 ]4 W; H! ]  Q' y5 D
879. 
     - V, O9 @8 b+ z/ ~3 [# S9 P& _2 t! R
880.         props = {
     ( M5 e2 i" ]1 V# _
881.             "initial_text": self.initial_text(),
     
882.             "placeholder_text": self.placeholder(),
     
883.             "selected": selected_item_index,
       u- }2 A. `0 [$ ^* l/ n
884.             "type": "list",
     ( n) a. O  o5 {/ s, Z% \# ?! l
885.         }
     , A0 v7 k, L# \2 ^
886. 
     
887.         return (items, props)
     
888. 
     
889.     def description_(self, v, text):
     
890.         return self.description(v, text)
     , f' |5 f. v% B& ?
891. 
     
892. 
     6 r2 W' T2 k( n6 y5 O
893. class Command(object):
     7 j' h' C" A+ f. r" I7 |
894.     def name(self):
     0 p. p# {: ^' q9 i1 x7 T$ L
895.         clsname = self.__class__.__name__
     
896.         name = clsname[0].lower()
     , P! \- z7 T5 t! |6 a
897.         last_upper = False
     
898.         for c in clsname[1:]:
     
899.             if c.isupper() and not last_upper:
     ( {' D9 p, p$ ]% d' y, O- v
900.                 name += '_'
     
901.                 name += c.lower()
     
902.             else:
     
903.                 name += c
     4 Z7 |7 G2 X& L, K* _
904.             last_upper = c.isupper()
     4 I# U( V5 @* s% J8 B# A
905.         if name.endswith("_command"):
     1 V+ e% K  B9 Q' U: [
906.             name = name[0:-8]
     * G7 X; |" G% G4 O# u8 o
907.         return name
     
908. 
     
909.     def is_enabled_(self, args):
     9 x" d0 `. m4 I2 t3 F, B4 x6 Q
910.         ret = None
     8 i6 d+ y  d7 P( ?/ ~
911.         try:
     
912.             args = self.filter_args(args)
     
913.             if args:
     3 f$ @( N& I' V* I
914.                 ret = self.is_enabled(**args)
     
915.             else:
     " |$ @9 I6 y, V6 @- ]2 w
916.                 ret = self.is_enabled()
     
917.         except TypeError:
     
918.             ret = self.is_enabled()
     
919. 
     
920.         if not isinstance(ret, bool):
     $ ?& q' G' V9 q! p7 a
921.             raise ValueError("is_enabled must return a bool", self)
     ; |1 I& i6 S% y- M+ P
922. 
     , F4 a- R& ^& T5 t  H% V
923.         return ret
     5 b9 K9 \) J. z* y+ _. h: Z
924. 
     $ A3 x( g/ O% I( ?$ O5 ~, J
925.     def is_enabled(self):
     
926.         return True
     
927. 
     # c  N3 }$ }$ ?: O
928.     def is_visible_(self, args):
     ! O4 q& X5 }' H5 h( _! s
929.         ret = None
     " E5 `# a. F" z$ @( G9 _! T! g/ a
930.         try:
     
931.             args = self.filter_args(args)
     
932.             if args:
     
933.                 ret = self.is_visible(**args)
     
934.             else:
     
935.                 ret = self.is_visible()
     
936.         except TypeError:
     ' b% w$ P. u, ~% R7 s1 ^2 S! _
937.             ret = self.is_visible()
     . T7 z/ `3 Z. N) v
938. 
     
939.         if not isinstance(ret, bool):
     ) M# V  f, O% u: C4 |( m5 ?
940.             raise ValueError("is_visible must return a bool", self)
     
941. 
     
942.         return ret
     / v% N  K! [9 b0 ?" G0 Y
943. 
     1 H) ^7 O2 j- q9 p6 p/ n6 u
944.     def is_visible(self):
     
945.         return True
     # n% D9 C( I* O" n$ a/ P
946. 
     % w# }/ ]/ s0 v  L- U" T# o* r4 Y4 ]
947.     def is_checked_(self, args):
     
948.         ret = None
     
949.         try:
     ' t% y2 G' d! k) m
950.             args = self.filter_args(args)
     8 S+ l) z2 K6 L8 L! ]6 k
951.             if args:
     & w  P9 H0 g  |# g# K& E9 [" C7 m
952.                 ret = self.is_checked(**args)
     
953.             else:
     6 |! g! O! V% A
954.                 ret = self.is_checked()
     
955.         except TypeError:
     
956.             ret = self.is_checked()
     
957. 
     , R% }$ [# K: s0 z8 D, ?! }
958.         if not isinstance(ret, bool):
     % ?8 V: ^5 G. j
959.             raise ValueError("is_checked must return a bool", self)
     
960. 
     2 E" I* j; A4 k) s% a2 x
961.         return ret
     & z  `* D5 Q' D, F1 f
962. 
     
963.     def is_checked(self):
     8 P7 \, s9 a& P5 @0 {9 j
964.         return False
     : O! ^% v; ~5 }# k' ]- b+ F
965. 
     / }* T! w, `( o) `# D
966.     def description_(self, args):
     8 {. R5 I4 j0 ?5 W
967.         try:
     
968.             args = self.filter_args(args)
     
969.             if args is not None:
     # y5 ?6 T4 |3 I
970.                 return self.description(**args)
     
971.             else:
     + X1 G4 \9 _5 f# f5 Y
972.                 return self.description()
     
973.         except TypeError:
     
974.             return ""
     3 c5 N5 W' v0 t! A# k0 C1 `
975. 
     
976.     def description(self):
     2 C: u' [/ p2 i- z! r
977.         return ""
     ' A. s" @; g* [* s: q$ _
978. 
     0 h; Z% W" `+ J2 j) D
979.     def filter_args(self, args):
     ; Q+ ?, I0 N* L
980.         if args:
     ' t  o/ O% Z: f6 @3 [
981.             if 'event' in args and not self.want_event():
     3 @$ z& Q5 N9 H+ n+ `- \8 Z
982.                 args = args.copy()
     0 ?' u* H9 E9 X& I* ]
983.                 del args['event']
     
984. 
     
985.         return args
     
986. 
     
987.     def want_event(self):
     
988.         return False
     2 ~& }$ z! o! U( ]/ R
989. 
     9 R2 j- J1 M( ?3 c
990.     def input(self, args):
     2 j3 ^- d9 O: V5 o% }! r
991.         return None
     8 }: P0 ?% G/ c  N0 o& v: c
992. 
     7 M6 x9 z4 w  h
993.     def input_description(self):
     ! E9 r6 g' y( ~' d" h5 d4 c! _$ M+ O4 A
994.         return ""
     
995. 
     # B/ f! |9 w8 H( `1 P6 L; Y) J
996.     def create_input_handler_(self, args):
     
997.         return self.input(args)
     & k' {- l& H/ x% u% b
998. 
     ' C3 F- d6 g; t! a) W( G7 G
999. 
     
1000. class ApplicationCommand(Command):
      
1001.     def run_(self, edit_token, args):
      
1002.         args = self.filter_args(args)
      ) p7 A7 |( t8 t, R% d) y9 V. m% m
1003.         try:
      5 f6 X' Z" D( M) R: S- ^9 w& C) _' s
1004.             if args:
      
1005.                 return self.run(**args)
      % a/ n* G3 D) L2 S+ W+ W
1006.             else:
      
1007.                 return self.run()
      , x5 Q. E: |  f& S/ X
1008.         except (TypeError) as e:
      1 M$ _6 W# u2 ~8 d/ Q6 ?+ p( V
1009.             if 'required positional argument' in str(e):
      3 {& v' g. Y6 i$ N& [! f7 k8 T; W1 @
1010.                 if sublime_api.can_accept_input(self.name(), args):
      
1011.                     sublime.active_window().run_command(
      
1012.                         'show_overlay',
      2 F- x9 _' }/ n& @  Z9 D
1013.                         {
      
1014.                             'overlay': 'command_palette',
      
1015.                             'command': self.name(),
      
1016.                             'args': args
      
1017.                         }
      
1018.                     )
      9 `! V: W4 Z  m
1019.                     return
      9 h  Q# z3 y7 I, V1 b4 _
1020.             raise
      
1021. 
      
1022.     def run(self):
      
1023.         pass
      
1024. 
      
1025. 
      
1026. class WindowCommand(Command):
      $ Q: ]% x0 l5 N0 j/ o2 z- G
1027.     def __init__(self, window):
      2 ?; S( e0 T" S* P" C8 T
1028.         self.window = window
      + U% f0 m! L( K6 o( s2 m: v
1029. 
      
1030.     def run_(self, edit_token, args):
      , r0 G( i& K: ?3 I. f- y
1031.         args = self.filter_args(args)
      
1032.         try:
      
1033.             if args:
      
1034.                 return self.run(**args)
      
1035.             else:
      
1036.                 return self.run()
      
1037.         except (TypeError) as e:
      & T9 M5 n  ^! j. a$ J% K
1038.             if 'required positional argument' in str(e):
      % L1 t6 x* C2 [0 [% x
1039.                 if sublime_api.window_can_accept_input(self.window.id(), self.name(), args):
      0 q- ~, z' }" X8 |
1040.                     sublime_api.window_run_command(
      ; \/ k+ G1 P6 `+ S' L' D: t& ?$ |
1041.                         self.window.id(),
      ) z- J' D: n# ~7 d, z9 C
1042.                         'show_overlay',
      
1043.                         {
      
1044.                             'overlay': 'command_palette',
      - T! {$ x$ S- I# P" |0 i
1045.                             'command': self.name(),
      
1046.                             'args': args
      
1047.                         }
      $ x  p+ U9 o/ ^2 x' Q& Q7 N
1048.                     )
      
1049.                     return
      
1050.             raise
      
1051. 
      + K, V$ H& r' Z$ S; ^
1052.     def run(self):
      ) [5 E2 |/ O* h6 b
1053.         pass
      ) Y) G3 ~; l9 ?/ Y+ ^+ T0 J
1054. 
      ( I/ L: a# `: ^
1055. 
      , Q) b% K3 Y; H; j8 _
1056. class TextCommand(Command):
      7 r% e) a4 x7 w; ?" o" H. x& E* c3 u
1057.     def __init__(self, view):
      7 l/ a) R+ t0 B
1058.         self.view = view
      
1059. 
      
1060.     def run_(self, edit_token, args):
      
1061.         args = self.filter_args(args)
      ! [$ u! }6 H' y) B" n
1062.         try:
      
1063.             if args:
      
1064.                 edit = self.view.begin_edit(edit_token, self.name(), args)
      , ?! o% j- F7 `5 Y3 y
1065.                 try:
      
1066.                     return self.run(edit, **args)
      
1067.                 finally:
      . |; b0 `( E2 W( i
1068.                     self.view.end_edit(edit)
      
1069.             else:
      
1070.                 edit = self.view.begin_edit(edit_token, self.name())
      
1071.                 try:
      
1072.                     return self.run(edit)
      7 Y6 q. f1 b- N' H: Z
1073.                 finally:
      ; m4 V( n) S) |  x3 ?7 t
1074.                     self.view.end_edit(edit)
      
1075.         except (TypeError) as e:
      
1076.             if 'required positional argument' in str(e):
      3 T, b! a; Q) x1 Y, k6 l: }1 {) R. K
1077.                 if sublime_api.view_can_accept_input(self.view.id(), self.name(), args):
      
1078.                     sublime_api.window_run_command(
      
1079.                         sublime_api.view_window(self.view.id()),
      3 Q4 ?2 ?" O/ l# h! F, [$ F' Z
1080.                         'show_overlay',
      : s+ a8 X& M' l/ f0 I
1081.                         {
      ' w% p! B) @$ `! t
1082.                             'overlay': 'command_palette',
      ; W4 l: {9 N# W* E/ I
1083.                             'command': self.name(),
      ! X, _$ |- C. J1 Z5 G+ @9 Y
1084.                             'args': args
        y9 `6 B- ^" j
1085.                         }
      
1086.                     )
      
1087.                     return
      
1088.             raise
      # X/ ]' V/ Q7 [. |* c( a( D! L
1089. 
      0 F3 X0 [1 l; p$ N3 Q
1090.     def run(self, edit):
      ! d' m8 Z  @3 Z2 c# L* V  o
1091.         pass
      + F) `% I- L' Y  h
1092. 
      
1093. 
      $ j3 T* g- U& `" O$ g
1094. class EventListener(object):
        J# @6 A& ?* f3 H5 P  j9 p
1095.     pass
      $ ?$ j- d9 j2 i( A% Q0 U3 h# b
1096. 
      : F) w3 M6 ]6 _5 L. g( {- s
1097. 
      
1098. class ViewEventListener(object):
      
1099.     @classmethod
      * m" L( Y7 B& c$ A9 B
1100.     def is_applicable(cls, settings):
      6 E8 S" y& _3 E5 \' O' \( `/ p$ u
1101.         return True
      6 a8 o0 {: v) U+ x4 y: J
1102. 
      
1103.     @classmethod
      ) g8 @7 A  _# k8 v  j4 a
1104.     def applies_to_primary_view_only(cls):
      
1105.         return True
      
1106. 
      
1107.     def __init__(self, view):
      
1108.         self.view = view
      
1109. 
      ! g" ?; @& M, M6 \- Z, E! |
1110. 
      ; Y# d1 i! ?/ P4 H. p' S+ o
1111. class MultizipImporter(object):
      
1112.     def __init__(self):
      
1113.         self.loaders = []
      
1114.         self.file_loaders = []
      
1115. 
      6 ?4 }. M4 o9 r; y: T: z
1116.     def find_module(self, fullname, path=None):
      1 R; \8 J/ s, j' S# Y
1117.         if not path:
      * _6 H4 _1 x1 k3 l' x
1118.             for l in self.loaders:
      
1119.                 if l.name == fullname:
      , N8 P1 V9 r# h1 H! m  P
1120.                     return l
      ( p' V! w0 I1 ?& w) K0 q$ Y
1121. 
      
1122.         for l in self.loaders:
      
1123.             if path == [l.zippath]:
      ; Z' I' ?$ P8 F7 G2 s
1124.                 if l.has(fullname):
      1 a8 d. G$ \- P0 d* C3 ~1 c% Y
1125.                     return l
      " `% H& R4 O) H( j. H
1126. 
      
1127.         return None
      
1128. 
      
1129. 
      
1130. class ZipLoader(object):
      3 m; T6 u1 a4 ~, M4 t" a0 G- ?
1131.     def __init__(self, zippath):
      
1132.         self.zippath = zippath
      ; J6 _6 p' a; v  W+ X3 W7 G% h
1133.         self.name = os.path.splitext(os.path.basename(zippath))[0]
      
1134.         self._scan_zip()
      3 P! Z3 q# n8 `  L  t* o# H7 U
1135. 
      
1136.     def has(self, fullname):
      
1137.         name, key = fullname.split('.', 1)
      
1138.         if name == self.name and key in self.contents:
      & A- Y& \+ j- n2 M# ]1 w. a: I. d' O
1139.             return True
      
1140. 
      
1141.         override_file = os.path.join(override_path, os.sep.join(fullname.split('.')) + '.py')
      
1142.         if os.path.isfile(override_file):
      
1143.             return True
        w  {( E5 O9 O; ]
1144. 
      
1145.         override_package = os.path.join(override_path, os.sep.join(fullname.split('.')))
      
1146.         if os.path.isdir(override_package):
      
1147.             return True
      
1148. 
      * h' ?; c4 X# Y7 ^
1149.         return False
      
1150. 
      : F, d: W1 u# o- g2 x6 e& G' S
1151.     def load_module(self, fullname):
      
1152.         # Only if a module is being reloaded and hasn't been scanned recently
      ) z! ^, ~( o) `9 E1 ^% r% C" }: b
1153.         # do we force a refresh of the contents of the .sublime-package. This
      
1154.         # allows proper code upgrades using Package Control.
      
1155.         if fullname in imp._RELOADING:
      : K9 o# B8 F. e
1156.             if self.refreshed < time.time() - 5:
      
1157.                 self._scan_zip()
      
1158. 
      " T, G' R, X7 t" C. o! ~
1159.         source, source_path, is_pkg = self._read_source(fullname)
      6 C% G! }2 w: O. V( x' x$ @
1160. 
      ! n. w5 M! {# v& Q4 @
1161.         if source is None:
      
1162.             raise ImportError("No module named '%s'" % fullname)
      " ]0 _6 z7 A8 X5 i
1163. 
      
1164.         is_new = False
      
1165.         if fullname in sys.modules:
      7 m0 N+ m( `, }) D: u. c& K0 c
1166.             mod = sys.modules[fullname]
      
1167.             old_mod_file = mod.__file__
      2 @4 i4 D  ^6 O( p- f+ ~( ~
1168.         else:
      
1169.             is_new = True
      , w" Z# Y/ @3 p& x
1170.             mod = sys.modules.setdefault(fullname, imp.new_module(fullname))
      " Q# y& s( x8 Z" E7 A5 Y1 M
1171.             mod.__name__ = fullname
      2 c2 a# z/ l! q1 k1 O5 F
1172.             mod.__path__ = [self.zippath]
        L. z# _9 e9 o+ |; G1 {
1173.             mod.__loader__ = self
      $ w/ w* X) J5 J2 T% Y% ?! J3 d
1174. 
      
1175.         mod.__file__ = source_path
      
1176. 
      " ]/ g; P" }9 e4 d. g; b  B, V1 B
1177.         if is_pkg:
      9 Y, Q  t( h' `
1178.             mod.__package__ = mod.__name__
      $ z, H  J' j) f! g4 i
1179.         else:
      * o/ H0 h: {9 p7 G" ~- i
1180.             mod.__package__ = fullname.rpartition('.')[0]
      ; j. Y2 q- t" l
1181. 
      / B8 L4 m; s7 s  p0 A( r
1182.         try:
      " l0 F7 @$ a, x
1183.             exec(compile(source, source_path, 'exec'), mod.__dict__)
      $ Y- u2 U9 f9 B, Q- E
1184.             return mod
      
1185. 
      & z) s, e; ~- ^  s; f4 Q3 M, w9 Q7 d
1186.         except:
      $ F( |8 T% M6 }* G8 N
1187.             if is_new:
      ' M- `* v, S: ~/ ]+ e' G& {
1188.                 del sys.modules[fullname]
      8 Y' c8 t" s: o' m/ J  Y
1189.             else:
      
1190.                 mod.__file__ = old_mod_file
      
1191.             raise
      
1192. 
      6 _& e: u2 m( A+ A( }$ o
1193.     def get_source(self, fullname):
      4 i& m0 y7 k4 m2 x, O2 d
1194.         name, key = fullname.split('.', 1)
      
1195.         if name != self.name:
      
1196.             return None
      
1197.         source, _, _ = self._read_source(fullname)
      
1198.         return source
      
1199. 
      
1200.     def _read_source(self, fullname):
      : {: V3 F2 x3 j: a5 N- v
1201.         name_parts = fullname.split('.')
      
1202.         override_basename = os.path.join(override_path, *name_parts)
      , M) Q& H) I. @0 o0 x7 ~# J
1203.         override_py = override_basename + '.py'
      3 j( y8 h/ ?9 l- I& W. }
1204.         override_init = os.path.join(override_basename, '__init__.py')
      
1205. 
      
1206.         if os.path.isfile(override_py):
      # J7 @0 j, [, {; y7 x
1207.             try:
      
1208.                 with open(override_py, 'r', encoding='utf-8') as f:
      
1209.                     return (f.read(), override_py, False)
      5 S  S2 a6 w6 F% \: q
1210.             except (Exception) as e:
      
1211.                 print(override_py, 'could not be read:', e)
      
1212. 
      
1213.         if os.path.isfile(override_init):
      8 _) Y% Z3 D# @( M
1214.             try:
      
1215.                 with open(override_init, 'r', encoding='utf-8') as f:
      + o$ s1 r2 k, |! ]
1216.                     return (f.read(), override_init, True)
      * Z/ ]8 V* U: x" ~
1217.             except (Exception) as e:
      
1218.                 print(override_init, 'could not be read:', e)
      ! P* n, [. ^& v
1219. 
      : U# t! z& N! Z
1220.         key = '.'.join(name_parts[1:])
      + V8 S& m! u6 C1 @$ v3 ~9 \0 M
1221.         if key in self.contents:
      
1222.             source = self.contents[key]
      - R" Z" N+ W5 e' w* e; ]/ J# ?7 _2 H
1223.             source_path = os.path.join(self.zippath, self.filenames[key]).rstrip(os.sep)
      
1224.             is_pkg = key in self.packages
      
1225.             return (source, source_path, is_pkg)
      2 V* a( a' z! I$ D/ a5 z- i* s& `
1226. 
      . U* T, ?, M3 F. h' t
1227.         # This allows .py overrides to exist in subfolders that:
      ( X1 Y+ f  y$ m5 r; L6 _  _) K
1228.         #  1. Do not exist in the .sublime-package file
      
1229.         #  2. Do not contain an __init__.py
      
1230.         if os.path.isdir(override_basename):
      
1231.             return ('', override_basename, True)
      4 ]0 U# H8 `( r' ?
1232. 
      / E' x4 }7 T. Y# k
1233.         return (None, None, False)
      
1234. 
      " h  Y7 P/ d2 y: B/ z. s" [3 X
1235.     def _scan_zip(self):
      - E: @0 |" @7 l  o, ^% O' Z
1236.         self.contents = {"": ""}
      ' |+ e* F4 h1 c: c: x& Q; E" d5 n; c
1237.         self.filenames = {"": ""}
      5 u' g  M! b# ?. ?+ G5 H. _5 ]
1238.         self.packages = {""}
      ( T0 p7 Y) a9 s: Z3 U
1239.         self.refreshed = time.time()
      
1240. 
      
1241.         try:
      1 N% {$ @, ]  [1 o, u  U
1242.             with zipfile.ZipFile(self.zippath, 'r') as z:
      
1243.                 files = [i.filename for i in z.infolist()]
      6 E: U- ^8 T0 q5 x  L' e( ^
1244. 
      9 {; h* i: k  m
1245.                 for f in files:
      ' I; s) K1 I% K, s" M9 B
1246.                     base, ext = os.path.splitext(f)
      # n# }4 m4 V% s9 ^8 Z
1247.                     if ext != ".py":
      ! s- A( n$ f1 e1 \  Z1 N0 r; ~* U
1248.                         continue
      
1249. 
      ' i$ [3 E( ]9 P% Q! E1 [4 S
1250.                     paths = base.split('/')
      
1251.                     if len(paths) > 0 and paths[len(paths) - 1] == "__init__":
      ( t1 p! R" P: t8 }* k
1252.                         paths.pop()
      
1253.                         self.packages.add('.'.join(paths))
      
1254. 
      ; c8 s. U  s- A5 u) m, Z0 P8 ~
1255.                     try:
      % D7 V0 v0 q( R
1256.                         pkg_path = '.'.join(paths)
      
1257.                         self.contents[pkg_path] = z.read(f).decode('utf-8')
      
1258.                         self.filenames[pkg_path] = f
      
1259.                     except UnicodeDecodeError:
      ( o. C) I0 |1 |5 S+ q6 \" {- I
1260.                         print(f, "in", self.zippath, "is not utf-8 encoded, unable to load plugin")
      ! n1 f9 a; |- ?+ P
1261.                         continue
      
1262. 
      
1263.                     while len(paths) > 1:
      
1264.                         paths.pop()
      0 k4 B  J* f  U( k
1265.                         parent = '.'.join(paths)
      8 V$ J2 Q5 ^$ p, c9 K0 I6 H4 W
1266.                         if parent not in self.contents:
      
1267.                             self.contents[parent] = ""
      
1268.                             self.filenames[parent] = parent
      
1269.                             self.packages.add(parent)
      * z3 y8 u  ^! S$ l, s/ I
1270.         except (Exception) as e:
      : ~. k# H4 U1 v! ]( A
1271.             print("Error loading %s:" % self.zippath, e)
      2 U2 {% F% s) o& \3 f( I6 T
1272. 
      
1273. 
      
1274. override_path = None
      $ t0 u) a& N' u8 U# ]
1275. multi_importer = MultizipImporter()
      ) l; s7 d! D( y! |4 T. H. ]
1276. sys.meta_path.insert(0, multi_importer)
      
1277. 
      
1278. 
      
1279. def update_compressed_packages(pkgs):
      
1280.     multi_importer.loaders = []
      " m4 a8 f+ M2 r% d0 O+ x
1281.     for p in pkgs:
      + |+ U' l' n6 U# s* n' K3 \
1282.         try:
      
1283.             multi_importer.loaders.append(ZipLoader(p))
      
1284.         except (FileNotFoundError, zipfile.BadZipFile) as e:
      
1285.             print("error loading " + p + ": " + str(e))
      
1286. 
      , s  [3 k+ D" ?, `; S5 o
1287. 
      6 A4 M4 A7 `* t- ?7 L3 f
1288. def set_override_path(path):
      ) K- @) [) v- B5 |+ S
1289.     global override_path
      , W# D. R, O4 }* f6 z* h; F/ p
1290.     override_path = path
      

复制代码

5 ^, A; P# [( W8 j

文外缪朴奂

可以哇，但我懒得看hhh
" E7 R6 _, R. O毕竟不是学这东西的

admin

文外缪朴奂 发表于 2020-5-3 15:34
可以哇，但我懒得看hhh
: B# Z/ @5 z2 z* u毕竟不是学这东西的

都
4 ]4 Q4 y/ k- n被
& S6 r% \4 h  x! P: M4 e你
0 i( x: t8 H/ ?帖
* @9 R$ ^% D# a9 k子
刷
# o0 n1 x* O$ S9 ?2 ?3 f1 I屏
了

文外缪朴奂

admin 发表于 2020-5-3 15:36
都
被
4 \9 ]2 I* s6 x# l7 w' r8 T1 K你

made，我才发两行

admin

文外缪朴奂 发表于 2020-5-3 15:38
0 h3 U. i" r* c* n+ L! Z' amade，我才发两行

啦
啦
啦
2 Y/ m/ M  L2 g4 @& S& Q啦
啦
5 @# [# b# k; i/ W& l& @% G啦
$ h9 R' u2 u  i6 h6 i2 j" v啦
噢
1 x. C9 \8 h9 r) o& m! Z% w耶
7 H: S) @5 `( c! H) e哈
哈
哈

文外缪朴奂

admin 发表于 2020-5-3 15:39
5 _6 N, I: _7 _, U/ {# D9 `啦
7 W8 R1 k& w5 K啦
啦

ernrnrnrnrnrnrnrnrn

admin

文外缪朴奂 发表于 2020-5-3 15:40
ernrnrnrnrnrnrnrnrn

  t; R0 [9 Q' w! r& s
. j7 w$ e2 ]+ P5 j5 K4 J! L叫我你从说的你重新金色的放假你手机发的那就哦端午节你肯定放假女粉丝
O(∩_∩)O