]>
Commit | Line | Data |
---|---|---|
1 | " FILE: plugin/conque_term.vim {{{ | |
2 | " | |
3 | " AUTHOR: Nico Raffo <nicoraffo@gmail.com> | |
4 | " MODIFIED: 2010-05-27 | |
5 | " VERSION: 1.1, for Vim 7.0 | |
6 | " LICENSE: | |
7 | " Conque - pty interaction in Vim | |
8 | " Copyright (C) 2009-2010 Nico Raffo | |
9 | " | |
10 | " MIT License | |
11 | " | |
12 | " Permission is hereby granted, free of charge, to any person obtaining a copy | |
13 | " of this software and associated documentation files (the "Software"), to deal | |
14 | " in the Software without restriction, including without limitation the rights | |
15 | " to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
16 | " copies of the Software, and to permit persons to whom the Software is | |
17 | " furnished to do so, subject to the following conditions: | |
18 | " | |
19 | " The above copyright notice and this permission notice shall be included in | |
20 | " all copies or substantial portions of the Software. | |
21 | " | |
22 | " THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
23 | " IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
24 | " FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
25 | " AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
26 | " LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
27 | " OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
28 | " THE SOFTWARE. | |
29 | " }}} | |
30 | ||
31 | ||
32 | " ********************************************************************************************************** | |
33 | " **** VIM FUNCTIONS *************************************************************************************** | |
34 | " ********************************************************************************************************** | |
35 | ||
36 | " launch conque | |
37 | function! conque_term#open(...) "{{{ | |
38 | let command = get(a:000, 0, '') | |
39 | let hooks = get(a:000, 1, []) | |
40 | ||
41 | " bare minimum validation | |
42 | if has('python') != 1 | |
43 | echohl WarningMsg | echomsg "Conque requires the Python interface to be installed" | echohl None | |
44 | return 0 | |
45 | endif | |
46 | if empty(command) | |
47 | echohl WarningMsg | echomsg "No command found" | echohl None | |
48 | return 0 | |
49 | else | |
50 | let l:cargs = split(command, '\s') | |
51 | if !executable(l:cargs[0]) | |
52 | echohl WarningMsg | echomsg "Not an executable: " . l:cargs[0] | echohl None | |
53 | return 0 | |
54 | endif | |
55 | endif | |
56 | ||
57 | " set buffer window options | |
58 | let g:ConqueTerm_BufName = substitute(command, ' ', '\\ ', 'g') . "\\ -\\ " . g:ConqueTerm_Idx | |
59 | call conque_term#set_buffer_settings(command, hooks) | |
60 | let b:ConqueTerm_Var = 'ConqueTerm_' . g:ConqueTerm_Idx | |
61 | let g:ConqueTerm_Var = 'ConqueTerm_' . g:ConqueTerm_Idx | |
62 | let g:ConqueTerm_Idx += 1 | |
63 | ||
64 | " open command | |
65 | try | |
66 | let l:config = '{"color":' . string(g:ConqueTerm_Color) . ',"TERM":"' . g:ConqueTerm_TERM . '"}' | |
67 | execute 'python ' . b:ConqueTerm_Var . ' = Conque()' | |
68 | execute "python " . b:ConqueTerm_Var . ".open('" . conque_term#python_escape(command) . "', " . l:config . ")" | |
69 | catch | |
70 | echohl WarningMsg | echomsg "Unable to open command: " . command | echohl None | |
71 | return 0 | |
72 | endtry | |
73 | ||
74 | " set buffer mappings and auto commands | |
75 | call conque_term#set_mappings('start') | |
76 | ||
77 | startinsert! | |
78 | return 1 | |
79 | endfunction "}}} | |
80 | ||
81 | " set buffer options | |
82 | function! conque_term#set_buffer_settings(command, pre_hooks) "{{{ | |
83 | ||
84 | " optional hooks to execute, e.g. 'split' | |
85 | for h in a:pre_hooks | |
86 | sil exe h | |
87 | endfor | |
88 | sil exe "edit " . g:ConqueTerm_BufName | |
89 | ||
90 | " buffer settings | |
91 | setlocal nocompatible " conque won't work in compatible mode | |
92 | setlocal nopaste " conque won't work in paste mode | |
93 | setlocal buftype=nofile " this buffer is not a file, you can't save it | |
94 | setlocal nonumber " hide line numbers | |
95 | setlocal foldcolumn=0 " reasonable left margin | |
96 | setlocal nowrap " default to no wrap (esp with MySQL) | |
97 | setlocal noswapfile " don't bother creating a .swp file | |
98 | setlocal updatetime=50 " trigger cursorhold event after 50ms / XXX - global | |
99 | setlocal scrolloff=0 " don't use buffer lines. it makes the 'clear' command not work as expected | |
100 | setlocal sidescrolloff=0 " don't use buffer lines. it makes the 'clear' command not work as expected | |
101 | setlocal sidescroll=1 " don't use buffer lines. it makes the 'clear' command not work as expected | |
102 | setlocal foldmethod=manual " don't fold on {{{}}} and stuff | |
103 | setlocal bufhidden=hide " when buffer is no longer displayed, don't wipe it out | |
104 | setfiletype conque_term " useful | |
105 | sil exe "setlocal syntax=" . g:ConqueTerm_Syntax | |
106 | ||
107 | endfunction " }}} | |
108 | ||
109 | " set key mappings and auto commands | |
110 | function! conque_term#set_mappings(action) "{{{ | |
111 | ||
112 | " set action | |
113 | if a:action == 'toggle' | |
114 | if exists('b:conque_on') && b:conque_on == 1 | |
115 | let l:action = 'stop' | |
116 | echohl WarningMsg | echomsg "Terminal is paused" | echohl None | |
117 | else | |
118 | let l:action = 'start' | |
119 | echohl WarningMsg | echomsg "Terminal is resumed" | echohl None | |
120 | endif | |
121 | else | |
122 | let l:action = a:action | |
123 | endif | |
124 | ||
125 | " if mappings are being removed, add 'un' | |
126 | let map_modifier = 'nore' | |
127 | if l:action == 'stop' | |
128 | let map_modifier = 'un' | |
129 | endif | |
130 | ||
131 | " remove all auto commands | |
132 | if l:action == 'stop' | |
133 | execute 'autocmd! ' . b:ConqueTerm_Var | |
134 | ||
135 | else | |
136 | execute 'augroup ' . b:ConqueTerm_Var | |
137 | ||
138 | " handle unexpected closing of shell, passes HUP to parent and all child processes | |
139 | execute 'autocmd ' . b:ConqueTerm_Var . ' BufUnload <buffer> python ' . b:ConqueTerm_Var . '.proc.signal(1)' | |
140 | ||
141 | " check for resized/scrolled buffer when entering buffer | |
142 | execute 'autocmd ' . b:ConqueTerm_Var . ' BufEnter <buffer> python ' . b:ConqueTerm_Var . '.update_window_size()' | |
143 | execute 'autocmd ' . b:ConqueTerm_Var . ' VimResized python ' . b:ConqueTerm_Var . '.update_window_size()' | |
144 | ||
145 | " set/reset updatetime on entering/exiting buffer | |
146 | autocmd BufEnter <buffer> set updatetime=50 | |
147 | autocmd BufLeave <buffer> set updatetime=2000 | |
148 | ||
149 | " check for resized/scrolled buffer when entering insert mode | |
150 | " XXX - messed up since we enter insert mode at each updatetime | |
151 | "execute 'autocmd InsertEnter <buffer> python ' . b:ConqueTerm_Var . '.screen.align()' | |
152 | ||
153 | " read more output when this isn't the current buffer | |
154 | if g:ConqueTerm_ReadUnfocused == 1 | |
155 | execute 'autocmd ' . b:ConqueTerm_Var . ' CursorHold * call conque_term#read_all()' | |
156 | endif | |
157 | ||
158 | " poll for more output | |
159 | sil execute 'autocmd ' . b:ConqueTerm_Var . ' CursorHoldI <buffer> python ' . b:ConqueTerm_Var . '.auto_read()' | |
160 | endif | |
161 | ||
162 | " use F22 key to get more input | |
163 | if l:action == 'start' | |
164 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <expr> <F22> "\<left>\<right>"' | |
165 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <expr> <F23> "\<right>\<left>"' | |
166 | else | |
167 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <expr> <F22>' | |
168 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <expr> <F23>' | |
169 | endif | |
170 | ||
171 | " map ASCII 1-31 | |
172 | for c in range(1, 31) | |
173 | " <Esc> | |
174 | if c == 27 | |
175 | continue | |
176 | endif | |
177 | if l:action == 'start' | |
178 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <C-' . nr2char(64 + c) . '> <C-o>:python ' . b:ConqueTerm_Var . '.write(chr(' . c . '))<CR>' | |
179 | else | |
180 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <C-' . nr2char(64 + c) . '>' | |
181 | endif | |
182 | endfor | |
183 | if l:action == 'start' | |
184 | sil exe 'n' . map_modifier . 'map <silent> <buffer> <C-c> <C-o>:python ' . b:ConqueTerm_Var . '.write(chr(3))<CR>' | |
185 | else | |
186 | sil exe 'n' . map_modifier . 'map <silent> <buffer> <C-c>' | |
187 | endif | |
188 | ||
189 | " leave insert mode | |
190 | if !exists('g:ConqueTerm_EscKey') || g:ConqueTerm_EscKey == '<Esc>' | |
191 | " use <Esc><Esc> to send <Esc> to terminal | |
192 | if l:action == 'start' | |
193 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Esc><Esc> <C-o>:python ' . b:ConqueTerm_Var . '.write(chr(27))<CR>' | |
194 | else | |
195 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Esc><Esc>' | |
196 | endif | |
197 | else | |
198 | " use <Esc> to send <Esc> to terminal | |
199 | if l:action == 'start' | |
200 | sil exe 'i' . map_modifier . 'map <silent> <buffer> ' . g:ConqueTerm_EscKey . ' <Esc>' | |
201 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Esc> <C-o>:python ' . b:ConqueTerm_Var . '.write(chr(27))<CR>' | |
202 | else | |
203 | sil exe 'i' . map_modifier . 'map <silent> <buffer> ' . g:ConqueTerm_EscKey | |
204 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Esc>' | |
205 | endif | |
206 | endif | |
207 | ||
208 | " Map <C-w> in insert mode | |
209 | if exists('g:ConqueTerm_CWInsert') && g:ConqueTerm_CWInsert == 1 | |
210 | inoremap <silent> <buffer> <C-w>j <Esc><C-w>j | |
211 | inoremap <silent> <buffer> <C-w>k <Esc><C-w>k | |
212 | inoremap <silent> <buffer> <C-w>h <Esc><C-w>h | |
213 | inoremap <silent> <buffer> <C-w>l <Esc><C-w>l | |
214 | inoremap <silent> <buffer> <C-w>w <Esc><C-w>w | |
215 | endif | |
216 | ||
217 | " map ASCII 33-127 | |
218 | for i in range(33, 127) | |
219 | " <Bar> | |
220 | if i == 124 | |
221 | if l:action == 'start' | |
222 | sil exe "i" . map_modifier . "map <silent> <buffer> <Bar> <C-o>:python " . b:ConqueTerm_Var . ".write(chr(124))<CR>" | |
223 | else | |
224 | sil exe "i" . map_modifier . "map <silent> <buffer> <Bar>" | |
225 | endif | |
226 | continue | |
227 | endif | |
228 | if l:action == 'start' | |
229 | sil exe "i" . map_modifier . "map <silent> <buffer> " . nr2char(i) . " <C-o>:python " . b:ConqueTerm_Var . ".write(chr(" . i . "))<CR>" | |
230 | else | |
231 | sil exe "i" . map_modifier . "map <silent> <buffer> " . nr2char(i) | |
232 | endif | |
233 | endfor | |
234 | ||
235 | " map ASCII 128-255 | |
236 | for i in range(128, 255) | |
237 | if l:action == 'start' | |
238 | sil exe "i" . map_modifier . "map <silent> <buffer> " . nr2char(i) . " <C-o>:python " . b:ConqueTerm_Var . ".write('" . nr2char(i) . "')<CR>" | |
239 | else | |
240 | sil exe "i" . map_modifier . "map <silent> <buffer> " . nr2char(i) | |
241 | endif | |
242 | endfor | |
243 | ||
244 | " Special cases | |
245 | if l:action == 'start' | |
246 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <BS> <C-o>:python ' . b:ConqueTerm_Var . '.write(u"\u0008")<CR>' | |
247 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Space> <C-o>:python ' . b:ConqueTerm_Var . '.write(" ")<CR>' | |
248 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Up> <C-o>:python ' . b:ConqueTerm_Var . '.write(u"\u001b[A")<CR>' | |
249 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Down> <C-o>:python ' . b:ConqueTerm_Var . '.write(u"\u001b[B")<CR>' | |
250 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Right> <C-o>:python ' . b:ConqueTerm_Var . '.write(u"\u001b[C")<CR>' | |
251 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Left> <C-o>:python ' . b:ConqueTerm_Var . '.write(u"\u001b[D")<CR>' | |
252 | else | |
253 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <BS>' | |
254 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Space>' | |
255 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Up>' | |
256 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Down>' | |
257 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Right>' | |
258 | sil exe 'i' . map_modifier . 'map <silent> <buffer> <Left>' | |
259 | endif | |
260 | ||
261 | " send selected text into conque | |
262 | if l:action == 'start' | |
263 | sil exe 'v' . map_modifier . 'map <silent> <F9> :<C-u>call conque_term#send_selected(visualmode())<CR>' | |
264 | else | |
265 | sil exe 'v' . map_modifier . 'map <silent> <F9>' | |
266 | endif | |
267 | ||
268 | " remap paste keys | |
269 | if l:action == 'start' | |
270 | sil exe 'n' . map_modifier . 'map <silent> <buffer> p :python ' . b:ConqueTerm_Var . '.write(vim.eval("@@"))<CR>a' | |
271 | sil exe 'n' . map_modifier . 'map <silent> <buffer> P :python ' . b:ConqueTerm_Var . '.write(vim.eval("@@"))<CR>a' | |
272 | sil exe 'n' . map_modifier . 'map <silent> <buffer> ]p :python ' . b:ConqueTerm_Var . '.write(vim.eval("@@"))<CR>a' | |
273 | sil exe 'n' . map_modifier . 'map <silent> <buffer> [p :python ' . b:ConqueTerm_Var . '.write(vim.eval("@@"))<CR>a' | |
274 | else | |
275 | sil exe 'n' . map_modifier . 'map <silent> <buffer> p' | |
276 | sil exe 'n' . map_modifier . 'map <silent> <buffer> P' | |
277 | sil exe 'n' . map_modifier . 'map <silent> <buffer> ]p' | |
278 | sil exe 'n' . map_modifier . 'map <silent> <buffer> [p' | |
279 | endif | |
280 | if has('gui_running') | |
281 | if l:action == 'start' | |
282 | sil exe 'i' . map_modifier . 'map <buffer> <S-Insert> <Esc>:<C-u>python ' . b:ConqueTerm_Var . ".write(vim.eval('@+'))<CR>a" | |
283 | else | |
284 | sil exe 'i' . map_modifier . 'map <buffer> <S-Insert>' | |
285 | endif | |
286 | endif | |
287 | ||
288 | " disable other normal mode keys which insert text | |
289 | if l:action == 'start' | |
290 | sil exe 'n' . map_modifier . 'map <silent> <buffer> r :echo "Replace mode disabled in shell."<CR>' | |
291 | sil exe 'n' . map_modifier . 'map <silent> <buffer> R :echo "Replace mode disabled in shell."<CR>' | |
292 | sil exe 'n' . map_modifier . 'map <silent> <buffer> c :echo "Change mode disabled in shell."<CR>' | |
293 | sil exe 'n' . map_modifier . 'map <silent> <buffer> C :echo "Change mode disabled in shell."<CR>' | |
294 | sil exe 'n' . map_modifier . 'map <silent> <buffer> s :echo "Change mode disabled in shell."<CR>' | |
295 | sil exe 'n' . map_modifier . 'map <silent> <buffer> S :echo "Change mode disabled in shell."<CR>' | |
296 | else | |
297 | sil exe 'n' . map_modifier . 'map <silent> <buffer> r' | |
298 | sil exe 'n' . map_modifier . 'map <silent> <buffer> R' | |
299 | sil exe 'n' . map_modifier . 'map <silent> <buffer> c' | |
300 | sil exe 'n' . map_modifier . 'map <silent> <buffer> C' | |
301 | sil exe 'n' . map_modifier . 'map <silent> <buffer> s' | |
302 | sil exe 'n' . map_modifier . 'map <silent> <buffer> S' | |
303 | endif | |
304 | ||
305 | " set conque as on or off | |
306 | if l:action == 'start' | |
307 | let b:conque_on = 1 | |
308 | else | |
309 | let b:conque_on = 0 | |
310 | endif | |
311 | ||
312 | " map command to start stop the shell | |
313 | if a:action == 'start' | |
314 | nnoremap <F5> :<C-u>call conque_term#set_mappings('toggle')<CR> | |
315 | endif | |
316 | ||
317 | endfunction " }}} | |
318 | ||
319 | ||
320 | " send selected text from another buffer | |
321 | function! conque_term#send_selected(type) "{{{ | |
322 | let reg_save = @@ | |
323 | ||
324 | " save user's sb settings | |
325 | let sb_save = &switchbuf | |
326 | set switchbuf=usetab | |
327 | ||
328 | " yank current selection | |
329 | sil exe "normal! `<" . a:type . "`>y" | |
330 | ||
331 | " format yanked text | |
332 | let @@ = substitute(@@, '^[\r\n]*', '', '') | |
333 | let @@ = substitute(@@, '[\r\n]*$', '', '') | |
334 | ||
335 | " execute yanked text | |
336 | sil exe ":sb " . g:ConqueTerm_BufName | |
337 | sil exe 'python ' . g:ConqueTerm_Var . '.paste_selection()' | |
338 | ||
339 | " reset original values | |
340 | let @@ = reg_save | |
341 | sil exe 'set switchbuf=' . sb_save | |
342 | ||
343 | " scroll buffer left | |
344 | startinsert! | |
345 | normal 0zH | |
346 | endfunction "}}} | |
347 | ||
348 | " read from all known conque buffers | |
349 | function! conque_term#read_all() "{{{ | |
350 | " don't run this if we're in a conque buffer | |
351 | if exists('b:ConqueTerm_Var') | |
352 | return | |
353 | endif | |
354 | ||
355 | try | |
356 | for i in range(1, g:ConqueTerm_Idx - 1) | |
357 | execute 'python ConqueTerm_' . string(i) . '.read(1)' | |
358 | endfor | |
359 | catch | |
360 | " probably a deleted buffer | |
361 | endtry | |
362 | ||
363 | " restart updatetime | |
364 | call feedkeys("f\e") | |
365 | endfunction "}}} | |
366 | ||
367 | " util function to add enough \s to pass a string to python | |
368 | function! conque_term#python_escape(input) "{{{ | |
369 | let l:cleaned = a:input | |
370 | let l:cleaned = substitute(l:cleaned, '\\', '\\\\', 'g') | |
371 | let l:cleaned = substitute(l:cleaned, '\n', '\\n', 'g') | |
372 | let l:cleaned = substitute(l:cleaned, '\r', '\\r', 'g') | |
373 | let l:cleaned = substitute(l:cleaned, "'", "\\\\'", 'g') | |
374 | return l:cleaned | |
375 | endfunction "}}} | |
376 | ||
377 | " ********************************************************************************************************** | |
378 | " **** PYTHON ********************************************************************************************** | |
379 | " ********************************************************************************************************** | |
380 | ||
381 | if has('python') | |
382 | ||
383 | python << EOF | |
384 | ||
385 | import vim, re, time, math | |
386 | ||
387 | # CONFIG CONSTANTS {{{ | |
388 | ||
389 | CONQUE_CTL = { | |
390 | 7:'bel', # bell | |
391 | 8:'bs', # backspace | |
392 | 9:'tab', # tab | |
393 | 10:'nl', # new line | |
394 | 13:'cr' # carriage return | |
395 | } | |
396 | # 11 : 'vt', # vertical tab | |
397 | # 12 : 'ff', # form feed | |
398 | # 14 : 'so', # shift out | |
399 | # 15 : 'si' # shift in | |
400 | ||
401 | # Escape sequences | |
402 | CONQUE_ESCAPE = { | |
403 | 'm':'font', | |
404 | 'J':'clear_screen', | |
405 | 'K':'clear_line', | |
406 | '@':'add_spaces', | |
407 | 'A':'cursor_up', | |
408 | 'B':'cursor_down', | |
409 | 'C':'cursor_right', | |
410 | 'D':'cursor_left', | |
411 | 'G':'cursor_to_column', | |
412 | 'H':'cursor', | |
413 | 'P':'delete_chars', | |
414 | 'f':'cursor', | |
415 | 'g':'tab_clear', | |
416 | 'r':'set_coords', | |
417 | 'h':'set', | |
418 | 'l':'reset' | |
419 | } | |
420 | # 'L':'insert_lines', | |
421 | # 'M':'delete_lines', | |
422 | # 'd':'cusor_vpos', | |
423 | ||
424 | # Alternate escape sequences, no [ | |
425 | CONQUE_ESCAPE_PLAIN = { | |
426 | 'D':'scroll_up', | |
427 | 'E':'next_line', | |
428 | 'H':'set_tab', | |
429 | 'M':'scroll_down' | |
430 | } | |
431 | # 'N':'single_shift_2', | |
432 | # 'O':'single_shift_3', | |
433 | # '=':'alternate_keypad', | |
434 | # '>':'numeric_keypad', | |
435 | # '7':'save_cursor', | |
436 | # '8':'restore_cursor', | |
437 | ||
438 | # Uber alternate escape sequences, with # or ? | |
439 | CONQUE_ESCAPE_QUESTION = { | |
440 | '1h':'new_line_mode', | |
441 | '3h':'132_cols', | |
442 | '4h':'smooth_scrolling', | |
443 | '5h':'reverse_video', | |
444 | '6h':'relative_origin', | |
445 | '7h':'set_auto_wrap', | |
446 | '8h':'set_auto_repeat', | |
447 | '9h':'set_interlacing_mode', | |
448 | '1l':'set_cursor_key', | |
449 | '2l':'set_vt52', | |
450 | '3l':'80_cols', | |
451 | '4l':'set_jump_scrolling', | |
452 | '5l':'normal_video', | |
453 | '6l':'absolute_origin', | |
454 | '7l':'reset_auto_wrap', | |
455 | '8l':'reset_auto_repeat', | |
456 | '9l':'reset_interlacing_mode' | |
457 | } | |
458 | ||
459 | CONQUE_ESCAPE_HASH = { | |
460 | '8':'screen_alignment_test' | |
461 | } | |
462 | # '3':'double_height_top', | |
463 | # '4':'double_height_bottom', | |
464 | # '5':'single_height_single_width', | |
465 | # '6':'single_height_double_width', | |
466 | ||
467 | # Font codes {{{ | |
468 | CONQUE_FONT = { | |
469 | 0: {'description':'Normal (default)', 'attributes': {'cterm':'NONE','ctermfg':'NONE','ctermbg':'NONE','gui':'NONE','guifg':'NONE','guibg':'NONE'}, 'normal':True}, | |
470 | 1: {'description':'Bold', 'attributes': {'cterm':'BOLD','gui':'BOLD'}, 'normal':False}, | |
471 | 4: {'description':'Underlined', 'attributes': {'cterm':'UNDERLINE','gui':'UNDERLINE'}, 'normal':False}, | |
472 | 5: {'description':'Blink (appears as Bold)', 'attributes': {'cterm':'BOLD','gui':'BOLD'}, 'normal':False}, | |
473 | 7: {'description':'Inverse', 'attributes': {'cterm':'REVERSE','gui':'REVERSE'}, 'normal':False}, | |
474 | 8: {'description':'Invisible (hidden)', 'attributes': {'ctermfg':'0','ctermbg':'0','guifg':'#000000','guibg':'#000000'}, 'normal':False}, | |
475 | 22: {'description':'Normal (neither bold nor faint)', 'attributes': {'cterm':'NONE','gui':'NONE'}, 'normal':True}, | |
476 | 24: {'description':'Not underlined', 'attributes': {'cterm':'NONE','gui':'NONE'}, 'normal':True}, | |
477 | 25: {'description':'Steady (not blinking)', 'attributes': {'cterm':'NONE','gui':'NONE'}, 'normal':True}, | |
478 | 27: {'description':'Positive (not inverse)', 'attributes': {'cterm':'NONE','gui':'NONE'}, 'normal':True}, | |
479 | 28: {'description':'Visible (not hidden)', 'attributes': {'ctermfg':'NONE','ctermbg':'NONE','guifg':'NONE','guibg':'NONE'}, 'normal':True}, | |
480 | 30: {'description':'Set foreground color to Black', 'attributes': {'ctermfg':'16','guifg':'#000000'}, 'normal':False}, | |
481 | 31: {'description':'Set foreground color to Red', 'attributes': {'ctermfg':'1','guifg':'#ff0000'}, 'normal':False}, | |
482 | 32: {'description':'Set foreground color to Green', 'attributes': {'ctermfg':'2','guifg':'#00ff00'}, 'normal':False}, | |
483 | 33: {'description':'Set foreground color to Yellow', 'attributes': {'ctermfg':'3','guifg':'#ffff00'}, 'normal':False}, | |
484 | 34: {'description':'Set foreground color to Blue', 'attributes': {'ctermfg':'4','guifg':'#0000ff'}, 'normal':False}, | |
485 | 35: {'description':'Set foreground color to Magenta', 'attributes': {'ctermfg':'5','guifg':'#990099'}, 'normal':False}, | |
486 | 36: {'description':'Set foreground color to Cyan', 'attributes': {'ctermfg':'6','guifg':'#009999'}, 'normal':False}, | |
487 | 37: {'description':'Set foreground color to White', 'attributes': {'ctermfg':'7','guifg':'#ffffff'}, 'normal':False}, | |
488 | 39: {'description':'Set foreground color to default (original)', 'attributes': {'ctermfg':'NONE','guifg':'NONE'}, 'normal':True}, | |
489 | 40: {'description':'Set background color to Black', 'attributes': {'ctermbg':'16','guibg':'#000000'}, 'normal':False}, | |
490 | 41: {'description':'Set background color to Red', 'attributes': {'ctermbg':'1','guibg':'#ff0000'}, 'normal':False}, | |
491 | 42: {'description':'Set background color to Green', 'attributes': {'ctermbg':'2','guibg':'#00ff00'}, 'normal':False}, | |
492 | 43: {'description':'Set background color to Yellow', 'attributes': {'ctermbg':'3','guibg':'#ffff00'}, 'normal':False}, | |
493 | 44: {'description':'Set background color to Blue', 'attributes': {'ctermbg':'4','guibg':'#0000ff'}, 'normal':False}, | |
494 | 45: {'description':'Set background color to Magenta', 'attributes': {'ctermbg':'5','guibg':'#990099'}, 'normal':False}, | |
495 | 46: {'description':'Set background color to Cyan', 'attributes': {'ctermbg':'6','guibg':'#009999'}, 'normal':False}, | |
496 | 47: {'description':'Set background color to White', 'attributes': {'ctermbg':'7','guibg':'#ffffff'}, 'normal':False}, | |
497 | 49: {'description':'Set background color to default (original).', 'attributes': {'ctermbg':'NONE','guibg':'NONE'}, 'normal':True}, | |
498 | 90: {'description':'Set foreground color to Black', 'attributes': {'ctermfg':'8','guifg':'#000000'}, 'normal':False}, | |
499 | 91: {'description':'Set foreground color to Red', 'attributes': {'ctermfg':'9','guifg':'#ff0000'}, 'normal':False}, | |
500 | 92: {'description':'Set foreground color to Green', 'attributes': {'ctermfg':'10','guifg':'#00ff00'}, 'normal':False}, | |
501 | 93: {'description':'Set foreground color to Yellow', 'attributes': {'ctermfg':'11','guifg':'#ffff00'}, 'normal':False}, | |
502 | 94: {'description':'Set foreground color to Blue', 'attributes': {'ctermfg':'12','guifg':'#0000ff'}, 'normal':False}, | |
503 | 95: {'description':'Set foreground color to Magenta', 'attributes': {'ctermfg':'13','guifg':'#990099'}, 'normal':False}, | |
504 | 96: {'description':'Set foreground color to Cyan', 'attributes': {'ctermfg':'14','guifg':'#009999'}, 'normal':False}, | |
505 | 97: {'description':'Set foreground color to White', 'attributes': {'ctermfg':'15','guifg':'#ffffff'}, 'normal':False}, | |
506 | 100: {'description':'Set background color to Black', 'attributes': {'ctermbg':'8','guibg':'#000000'}, 'normal':False}, | |
507 | 101: {'description':'Set background color to Red', 'attributes': {'ctermbg':'9','guibg':'#ff0000'}, 'normal':False}, | |
508 | 102: {'description':'Set background color to Green', 'attributes': {'ctermbg':'10','guibg':'#00ff00'}, 'normal':False}, | |
509 | 103: {'description':'Set background color to Yellow', 'attributes': {'ctermbg':'11','guibg':'#ffff00'}, 'normal':False}, | |
510 | 104: {'description':'Set background color to Blue', 'attributes': {'ctermbg':'12','guibg':'#0000ff'}, 'normal':False}, | |
511 | 105: {'description':'Set background color to Magenta', 'attributes': {'ctermbg':'13','guibg':'#990099'}, 'normal':False}, | |
512 | 106: {'description':'Set background color to Cyan', 'attributes': {'ctermbg':'14','guibg':'#009999'}, 'normal':False}, | |
513 | 107: {'description':'Set background color to White', 'attributes': {'ctermbg':'15','guibg':'#ffffff'}, 'normal':False} | |
514 | } | |
515 | # }}} | |
516 | ||
517 | # regular expression matching (almost) all control sequences | |
518 | CONQUE_SEQ_REGEX = re.compile(ur"(\u001b\[?\??#?[0-9;]*[a-zA-Z@]|\u001b\][0-9];.*?\u0007|[\u0007-\u000f])", re.UNICODE) | |
519 | CONQUE_SEQ_REGEX_CTL = re.compile(ur"^[\u0007-\u000f]$", re.UNICODE) | |
520 | CONQUE_SEQ_REGEX_CSI = re.compile(ur"^\u001b\[", re.UNICODE) | |
521 | CONQUE_SEQ_REGEX_TITLE = re.compile(ur"^\u001b\]", re.UNICODE) | |
522 | CONQUE_SEQ_REGEX_HASH = re.compile(ur"^\u001b#", re.UNICODE) | |
523 | CONQUE_SEQ_REGEX_ESC = re.compile(ur"^\u001b", re.UNICODE) | |
524 | ||
525 | # match table output | |
526 | CONQUE_TABLE_OUTPUT = re.compile("^\s*\|\s.*\s\|\s*$|^\s*\+[=+-]+\+\s*$") | |
527 | ||
528 | # }}} | |
529 | ||
530 | ################################################################################################### | |
531 | class Conque: | |
532 | ||
533 | # CLASS PROPERTIES {{{ | |
534 | ||
535 | # screen object | |
536 | screen = None | |
537 | ||
538 | # subprocess object | |
539 | proc = None | |
540 | ||
541 | # terminal dimensions and scrolling region | |
542 | columns = 80 # same as $COLUMNS | |
543 | lines = 24 # same as $LINES | |
544 | working_columns = 80 # can be changed by CSI ? 3 l/h | |
545 | working_lines = 24 # can be changed by CSI r | |
546 | ||
547 | # top/bottom of the scroll region | |
548 | top = 1 # relative to top of screen | |
549 | bottom = 24 # relative to top of screen | |
550 | ||
551 | # cursor position | |
552 | l = 1 # current cursor line | |
553 | c = 1 # current cursor column | |
554 | ||
555 | # autowrap mode | |
556 | autowrap = True | |
557 | ||
558 | # absolute coordinate mode | |
559 | absolute_coords = True | |
560 | ||
561 | # tabstop positions | |
562 | tabstops = [] | |
563 | ||
564 | # enable colors | |
565 | enable_colors = True | |
566 | ||
567 | # color changes | |
568 | color_changes = {} | |
569 | ||
570 | # color history | |
571 | color_history = {} | |
572 | ||
573 | # don't wrap table output | |
574 | unwrap_tables = True | |
575 | ||
576 | # wrap CUF/CUB around line breaks | |
577 | wrap_cursor = False | |
578 | ||
579 | # }}} | |
580 | ||
581 | # constructor | |
582 | def __init__(self): # {{{ | |
583 | self.screen = ConqueScreen() | |
584 | # }}} | |
585 | ||
586 | # start program and initialize this instance | |
587 | def open(self, command, options): # {{{ | |
588 | ||
589 | # int vars | |
590 | self.columns = vim.current.window.width | |
591 | self.lines = vim.current.window.height | |
592 | self.working_columns = vim.current.window.width | |
593 | self.working_lines = vim.current.window.height | |
594 | self.bottom = vim.current.window.height | |
595 | ||
596 | # init color | |
597 | self.enable_colors = options['color'] | |
598 | ||
599 | # init tabstops | |
600 | self.init_tabstops() | |
601 | ||
602 | # open command | |
603 | self.proc = ConqueSubprocess() | |
604 | self.proc.open(command, { 'TERM' : options['TERM'], 'CONQUE' : '1', 'LINES' : str(self.lines), 'COLUMNS' : str(self.columns)}) | |
605 | # }}} | |
606 | ||
607 | # write to pty | |
608 | def write(self, input): # {{{ | |
609 | ||
610 | ||
611 | # check if window size has changed | |
612 | self.update_window_size() | |
613 | ||
614 | # write and read | |
615 | self.proc.write(input) | |
616 | self.read(1) | |
617 | # }}} | |
618 | ||
619 | # read from pty, and update buffer | |
620 | def read(self, timeout = 1): # {{{ | |
621 | # read from subprocess | |
622 | output = self.proc.read(timeout) | |
623 | # and strip null chars | |
624 | output = output.replace(chr(0), '') | |
625 | ||
626 | if output == '': | |
627 | return | |
628 | ||
629 | ||
630 | ||
631 | ||
632 | ||
633 | chunks = CONQUE_SEQ_REGEX.split(output) | |
634 | ||
635 | ||
636 | ||
637 | ||
638 | ||
639 | # don't go through all the csi regex if length is one (no matches) | |
640 | if len(chunks) == 1: | |
641 | ||
642 | self.plain_text(chunks[0]) | |
643 | ||
644 | else: | |
645 | for s in chunks: | |
646 | if s == '': | |
647 | continue | |
648 | ||
649 | ||
650 | ||
651 | ||
652 | ||
653 | ||
654 | # Check for control character match {{{ | |
655 | if CONQUE_SEQ_REGEX_CTL.match(s[0]): | |
656 | ||
657 | nr = ord(s[0]) | |
658 | if nr in CONQUE_CTL: | |
659 | getattr(self, 'ctl_' + CONQUE_CTL[nr])() | |
660 | else: | |
661 | ||
662 | pass | |
663 | # }}} | |
664 | ||
665 | # check for escape sequence match {{{ | |
666 | elif CONQUE_SEQ_REGEX_CSI.match(s): | |
667 | ||
668 | if s[-1] in CONQUE_ESCAPE: | |
669 | csi = self.parse_csi(s[2:]) | |
670 | ||
671 | getattr(self, 'csi_' + CONQUE_ESCAPE[s[-1]])(csi) | |
672 | else: | |
673 | ||
674 | pass | |
675 | # }}} | |
676 | ||
677 | # check for title match {{{ | |
678 | elif CONQUE_SEQ_REGEX_TITLE.match(s): | |
679 | ||
680 | self.change_title(s[2], s[4:-1]) | |
681 | # }}} | |
682 | ||
683 | # check for hash match {{{ | |
684 | elif CONQUE_SEQ_REGEX_HASH.match(s): | |
685 | ||
686 | if s[-1] in CONQUE_ESCAPE_HASH: | |
687 | getattr(self, 'hash_' + CONQUE_ESCAPE_HASH[s[-1]])() | |
688 | else: | |
689 | ||
690 | pass | |
691 | # }}} | |
692 | ||
693 | # check for other escape match {{{ | |
694 | elif CONQUE_SEQ_REGEX_ESC.match(s): | |
695 | ||
696 | if s[-1] in CONQUE_ESCAPE_PLAIN: | |
697 | getattr(self, 'esc_' + CONQUE_ESCAPE_PLAIN[s[-1]])() | |
698 | else: | |
699 | ||
700 | pass | |
701 | # }}} | |
702 | ||
703 | # else process plain text {{{ | |
704 | else: | |
705 | self.plain_text(s) | |
706 | # }}} | |
707 | ||
708 | # set cursor position | |
709 | self.screen.set_cursor(self.l, self.c) | |
710 | ||
711 | vim.command('redraw') | |
712 | ||
713 | ||
714 | # }}} | |
715 | ||
716 | # for polling | |
717 | def auto_read(self): # {{{ | |
718 | self.read(1) | |
719 | if self.c == 1: | |
720 | vim.command('call feedkeys("\<F23>", "t")') | |
721 | else: | |
722 | vim.command('call feedkeys("\<F22>", "t")') | |
723 | self.screen.set_cursor(self.l, self.c) | |
724 | # }}} | |
725 | ||
726 | ############################################################################################### | |
727 | # Plain text # {{{ | |
728 | ||
729 | def plain_text(self, input): | |
730 | ||
731 | current_line = self.screen[self.l] | |
732 | ||
733 | if len(current_line) < self.working_columns: | |
734 | current_line = current_line + ' ' * (self.c - len(current_line)) | |
735 | ||
736 | # if line is wider than screen | |
737 | if self.c + len(input) - 1 > self.working_columns: | |
738 | # Table formatting hack | |
739 | if self.unwrap_tables and CONQUE_TABLE_OUTPUT.match(input): | |
740 | self.screen[self.l] = current_line[ : self.c - 1] + input + current_line[ self.c + len(input) - 1 : ] | |
741 | self.apply_color(self.c, self.c + len(input)) | |
742 | self.c += len(input) | |
743 | return | |
744 | ||
745 | diff = self.c + len(input) - self.working_columns - 1 | |
746 | # if autowrap is enabled | |
747 | if self.autowrap: | |
748 | self.screen[self.l] = current_line[ : self.c - 1] + input[ : -1 * diff ] | |
749 | self.apply_color(self.c, self.working_columns) | |
750 | self.ctl_nl() | |
751 | self.ctl_cr() | |
752 | remaining = input[ -1 * diff : ] | |
753 | ||
754 | self.plain_text(remaining) | |
755 | else: | |
756 | self.screen[self.l] = current_line[ : self.c - 1] + input[ : -1 * diff - 1 ] + input[-1] | |
757 | self.apply_color(self.c, self.working_columns) | |
758 | self.c = self.working_columns | |
759 | ||
760 | # no autowrap | |
761 | else: | |
762 | self.screen[self.l] = current_line[ : self.c - 1] + input + current_line[ self.c + len(input) - 1 : ] | |
763 | self.apply_color(self.c, self.c + len(input)) | |
764 | self.c += len(input) | |
765 | ||
766 | def apply_color(self, start, end): | |
767 | ||
768 | ||
769 | # stop here if coloration is disabled | |
770 | if not self.enable_colors: | |
771 | return | |
772 | ||
773 | real_line = self.screen.get_real_line(self.l) | |
774 | ||
775 | # check for previous overlapping coloration | |
776 | ||
777 | to_del = [] | |
778 | if self.color_history.has_key(real_line): | |
779 | for i in range(len(self.color_history[real_line])): | |
780 | syn = self.color_history[real_line][i] | |
781 | ||
782 | if syn['start'] >= start and syn['start'] < end: | |
783 | ||
784 | vim.command('syn clear ' + syn['name']) | |
785 | to_del.append(i) | |
786 | # outside | |
787 | if syn['end'] > end: | |
788 | ||
789 | self.exec_highlight(real_line, end, syn['end'], syn['highlight']) | |
790 | elif syn['end'] > start and syn['end'] <= end: | |
791 | ||
792 | vim.command('syn clear ' + syn['name']) | |
793 | to_del.append(i) | |
794 | # outside | |
795 | if syn['start'] < start: | |
796 | ||
797 | self.exec_highlight(real_line, syn['start'], start, syn['highlight']) | |
798 | ||
799 | if len(to_del) > 0: | |
800 | to_del.reverse() | |
801 | for di in to_del: | |
802 | del self.color_history[real_line][di] | |
803 | ||
804 | # if there are no new colors | |
805 | if len(self.color_changes) == 0: | |
806 | return | |
807 | ||
808 | highlight = '' | |
809 | for attr in self.color_changes.keys(): | |
810 | highlight = highlight + ' ' + attr + '=' + self.color_changes[attr] | |
811 | ||
812 | # execute the highlight | |
813 | self.exec_highlight(real_line, start, end, highlight) | |
814 | ||
815 | def exec_highlight(self, real_line, start, end, highlight): | |
816 | unique_key = str(self.proc.pid) | |
817 | ||
818 | syntax_name = 'EscapeSequenceAt_' + unique_key + '_' + str(self.l) + '_' + str(start) + '_' + str(len(self.color_history) + 1) | |
819 | syntax_options = ' contains=ALLBUT,ConqueString,MySQLString,MySQLKeyword oneline' | |
820 | syntax_region = 'syntax match ' + syntax_name + ' /\%' + str(real_line) + 'l\%>' + str(start - 1) + 'c.*\%<' + str(end + 1) + 'c/' + syntax_options | |
821 | syntax_highlight = 'highlight ' + syntax_name + highlight | |
822 | ||
823 | vim.command(syntax_region) | |
824 | vim.command(syntax_highlight) | |
825 | ||
826 | # add syntax name to history | |
827 | if not self.color_history.has_key(real_line): | |
828 | self.color_history[real_line] = [] | |
829 | ||
830 | self.color_history[real_line].append({'name':syntax_name, 'start':start, 'end':end, 'highlight':highlight}) | |
831 | ||
832 | # }}} | |
833 | ||
834 | ############################################################################################### | |
835 | # Control functions {{{ | |
836 | ||
837 | def ctl_nl(self): | |
838 | # if we're in a scrolling region, scroll instead of moving cursor down | |
839 | if self.lines != self.working_lines and self.l == self.bottom: | |
840 | del self.screen[self.top] | |
841 | self.screen.insert(self.bottom, '') | |
842 | elif self.l == self.bottom: | |
843 | self.screen.append('') | |
844 | else: | |
845 | self.l += 1 | |
846 | ||
847 | self.color_changes = {} | |
848 | ||
849 | def ctl_cr(self): | |
850 | self.c = 1 | |
851 | ||
852 | self.color_changes = {} | |
853 | ||
854 | def ctl_bs(self): | |
855 | if self.c > 1: | |
856 | self.c += -1 | |
857 | ||
858 | def ctl_bel(self): | |
859 | print 'BELL' | |
860 | ||
861 | def ctl_tab(self): | |
862 | # default tabstop location | |
863 | ts = self.working_columns | |
864 | ||
865 | # check set tabstops | |
866 | for i in range(self.c, len(self.tabstops)): | |
867 | if self.tabstops[i]: | |
868 | ts = i + 1 | |
869 | break | |
870 | ||
871 | ||
872 | ||
873 | self.c = ts | |
874 | ||
875 | # }}} | |
876 | ||
877 | ############################################################################################### | |
878 | # CSI functions {{{ | |
879 | ||
880 | def csi_font(self, csi): # {{{ | |
881 | if not self.enable_colors: | |
882 | return | |
883 | ||
884 | # defaults to 0 | |
885 | if len(csi['vals']) == 0: | |
886 | csi['vals'] = [0] | |
887 | ||
888 | # 256 xterm color foreground | |
889 | if len(csi['vals']) == 3 and csi['vals'][0] == 38 and csi['vals'][1] == 5: | |
890 | self.color_changes['ctermfg'] = str(csi['vals'][2]) | |
891 | self.color_changes['guifg'] = '#' + self.xterm_to_rgb(csi['vals'][2]) | |
892 | ||
893 | # 256 xterm color background | |
894 | elif len(csi['vals']) == 3 and csi['vals'][0] == 48 and csi['vals'][1] == 5: | |
895 | self.color_changes['ctermbg'] = str(csi['vals'][2]) | |
896 | self.color_changes['guibg'] = '#' + self.xterm_to_rgb(csi['vals'][2]) | |
897 | ||
898 | # 16 colors | |
899 | else: | |
900 | for val in csi['vals']: | |
901 | if CONQUE_FONT.has_key(val): | |
902 | ||
903 | # ignore starting normal colors | |
904 | if CONQUE_FONT[val]['normal'] and len(self.color_changes) == 0: | |
905 | ||
906 | continue | |
907 | # clear color changes | |
908 | elif CONQUE_FONT[val]['normal']: | |
909 | ||
910 | self.color_changes = {} | |
911 | # save these color attributes for next plain_text() call | |
912 | else: | |
913 | ||
914 | for attr in CONQUE_FONT[val]['attributes'].keys(): | |
915 | if self.color_changes.has_key(attr) and (attr == 'cterm' or attr == 'gui'): | |
916 | self.color_changes[attr] += ',' + CONQUE_FONT[val]['attributes'][attr] | |
917 | else: | |
918 | self.color_changes[attr] = CONQUE_FONT[val]['attributes'][attr] | |
919 | # }}} | |
920 | ||
921 | def csi_clear_line(self, csi): # {{{ | |
922 | ||
923 | ||
924 | # this escape defaults to 0 | |
925 | if len(csi['vals']) == 0: | |
926 | csi['val'] = 0 | |
927 | ||
928 | ||
929 | ||
930 | ||
931 | # 0 means cursor right | |
932 | if csi['val'] == 0: | |
933 | self.screen[self.l] = self.screen[self.l][0 : self.c - 1] | |
934 | ||
935 | # 1 means cursor left | |
936 | elif csi['val'] == 1: | |
937 | self.screen[self.l] = ' ' * (self.c) + self.screen[self.l][self.c : ] | |
938 | ||
939 | # clear entire line | |
940 | elif csi['val'] == 2: | |
941 | self.screen[self.l] = '' | |
942 | ||
943 | # clear colors | |
944 | if csi['val'] == 2 or (csi['val'] == 0 and self.c == 1): | |
945 | real_line = self.screen.get_real_line(self.l) | |
946 | if self.color_history.has_key(real_line): | |
947 | for syn in self.color_history[real_line]: | |
948 | vim.command('syn clear ' + syn['name']) | |
949 | ||
950 | ||
951 | ||
952 | # }}} | |
953 | ||
954 | def csi_cursor_right(self, csi): # {{{ | |
955 | # we use 1 even if escape explicitly specifies 0 | |
956 | if csi['val'] == 0: | |
957 | csi['val'] = 1 | |
958 | ||
959 | ||
960 | ||
961 | ||
962 | if self.wrap_cursor and self.c + csi['val'] > self.working_columns: | |
963 | self.l += int(math.floor( (self.c + csi['val']) / self.working_columns )) | |
964 | self.c = (self.c + csi['val']) % self.working_columns | |
965 | return | |
966 | ||
967 | self.c = self.bound(self.c + csi['val'], 1, self.working_columns) | |
968 | # }}} | |
969 | ||
970 | def csi_cursor_left(self, csi): # {{{ | |
971 | # we use 1 even if escape explicitly specifies 0 | |
972 | if csi['val'] == 0: | |
973 | csi['val'] = 1 | |
974 | ||
975 | if self.wrap_cursor and csi['val'] >= self.c: | |
976 | self.l += int(math.floor( (self.c - csi['val']) / self.working_columns )) | |
977 | self.c = self.working_columns - (csi['val'] - self.c) % self.working_columns | |
978 | return | |
979 | ||
980 | self.c = self.bound(self.c - csi['val'], 1, self.working_columns) | |
981 | # }}} | |
982 | ||
983 | def csi_cursor_to_column(self, csi): # {{{ | |
984 | self.c = self.bound(csi['val'], 1, self.working_columns) | |
985 | # }}} | |
986 | ||
987 | def csi_cursor_up(self, csi): # {{{ | |
988 | self.l = self.bound(self.l - csi['val'], self.top, self.bottom) | |
989 | ||
990 | self.color_changes = {} | |
991 | # }}} | |
992 | ||
993 | def csi_cursor_down(self, csi): # {{{ | |
994 | self.l = self.bound(self.l + csi['val'], self.top, self.bottom) | |
995 | ||
996 | self.color_changes = {} | |
997 | # }}} | |
998 | ||
999 | def csi_clear_screen(self, csi): # {{{ | |
1000 | # default to 0 | |
1001 | if len(csi['vals']) == 0: | |
1002 | csi['val'] = 0 | |
1003 | ||
1004 | # 2 == clear entire screen | |
1005 | if csi['val'] == 2: | |
1006 | self.l = 1 | |
1007 | self.c = 1 | |
1008 | self.screen.clear() | |
1009 | ||
1010 | # 0 == clear down | |
1011 | elif csi['val'] == 0: | |
1012 | for l in range(self.bound(self.l + 1, 1, self.lines), self.lines + 1): | |
1013 | self.screen[l] = '' | |
1014 | ||
1015 | # clear end of current line | |
1016 | self.csi_clear_line(self.parse_csi('K')) | |
1017 | ||
1018 | # 1 == clear up | |
1019 | elif csi['val'] == 1: | |
1020 | for l in range(1, self.bound(self.l, 1, self.lines + 1)): | |
1021 | self.screen[l] = '' | |
1022 | ||
1023 | # clear beginning of current line | |
1024 | self.csi_clear_line(self.parse_csi('1K')) | |
1025 | ||
1026 | # clear coloration | |
1027 | if csi['val'] == 2 or csi['val'] == 0: | |
1028 | real_line = self.screen.get_real_line(self.l) | |
1029 | for line in self.color_history.keys(): | |
1030 | if line >= real_line: | |
1031 | for syn in self.color_history[line]: | |
1032 | vim.command('syn clear ' + syn['name']) | |
1033 | ||
1034 | self.color_changes = {} | |
1035 | # }}} | |
1036 | ||
1037 | def csi_delete_chars(self, csi): # {{{ | |
1038 | self.screen[self.l] = self.screen[self.l][ : self.c ] + self.screen[self.l][ self.c + csi['val'] : ] | |
1039 | # }}} | |
1040 | ||
1041 | def csi_add_spaces(self, csi): # {{{ | |
1042 | self.screen[self.l] = self.screen[self.l][ : self.c - 1] + ' ' * csi['val'] + self.screen[self.l][self.c : ] | |
1043 | # }}} | |
1044 | ||
1045 | def csi_cursor(self, csi): # {{{ | |
1046 | if len(csi['vals']) == 2: | |
1047 | new_line = csi['vals'][0] | |
1048 | new_col = csi['vals'][1] | |
1049 | else: | |
1050 | new_line = 1 | |
1051 | new_col = 1 | |
1052 | ||
1053 | if self.absolute_coords: | |
1054 | self.l = self.bound(new_line, 1, self.lines) | |
1055 | else: | |
1056 | self.l = self.bound(self.top + new_line - 1, self.top, self.bottom) | |
1057 | ||
1058 | self.c = self.bound(new_col, 1, self.working_columns) | |
1059 | if self.c > len(self.screen[self.l]): | |
1060 | self.screen[self.l] = self.screen[self.l] + ' ' * (self.c - len(self.screen[self.l])) | |
1061 | ||
1062 | # }}} | |
1063 | ||
1064 | def csi_set_coords(self, csi): # {{{ | |
1065 | if len(csi['vals']) == 2: | |
1066 | new_start = csi['vals'][0] | |
1067 | new_end = csi['vals'][1] | |
1068 | else: | |
1069 | new_start = 1 | |
1070 | new_end = vim.current.window.height | |
1071 | ||
1072 | self.top = new_start | |
1073 | self.bottom = new_end | |
1074 | self.working_lines = new_end - new_start + 1 | |
1075 | ||
1076 | # if cursor is outside scrolling region, reset it | |
1077 | if self.l < self.top: | |
1078 | self.l = self.top | |
1079 | elif self.l > self.bottom: | |
1080 | self.l = self.bottom | |
1081 | ||
1082 | self.color_changes = {} | |
1083 | # }}} | |
1084 | ||
1085 | def csi_tab_clear(self, csi): # {{{ | |
1086 | # this escape defaults to 0 | |
1087 | if len(csi['vals']) == 0: | |
1088 | csi['val'] = 0 | |
1089 | ||
1090 | ||
1091 | ||
1092 | if csi['val'] == 0: | |
1093 | self.tabstops[self.c - 1] = False | |
1094 | elif csi['val'] == 3: | |
1095 | for i in range(0, self.columns + 1): | |
1096 | self.tabstops[i] = False | |
1097 | # }}} | |
1098 | ||
1099 | def csi_set(self, csi): # {{{ | |
1100 | # 132 cols | |
1101 | if csi['val'] == 3: | |
1102 | self.csi_clear_screen(self.parse_csi('2J')) | |
1103 | self.working_columns = 132 | |
1104 | ||
1105 | # relative_origin | |
1106 | elif csi['val'] == 6: | |
1107 | self.absolute_coords = False | |
1108 | ||
1109 | # set auto wrap | |
1110 | elif csi['val'] == 7: | |
1111 | self.autowrap = True | |
1112 | ||
1113 | ||
1114 | self.color_changes = {} | |
1115 | # }}} | |
1116 | ||
1117 | def csi_reset(self, csi): # {{{ | |
1118 | # 80 cols | |
1119 | if csi['val'] == 3: | |
1120 | self.csi_clear_screen(self.parse_csi('2J')) | |
1121 | self.working_columns = 80 | |
1122 | ||
1123 | # absolute origin | |
1124 | elif csi['val'] == 6: | |
1125 | self.absolute_coords = True | |
1126 | ||
1127 | # reset auto wrap | |
1128 | elif csi['val'] == 7: | |
1129 | self.autowrap = False | |
1130 | ||
1131 | ||
1132 | self.color_changes = {} | |
1133 | # }}} | |
1134 | ||
1135 | # }}} | |
1136 | ||
1137 | ############################################################################################### | |
1138 | # ESC functions {{{ | |
1139 | ||
1140 | def esc_scroll_up(self): # {{{ | |
1141 | self.ctl_nl() | |
1142 | ||
1143 | self.color_changes = {} | |
1144 | # }}} | |
1145 | ||
1146 | def esc_next_line(self): # {{{ | |
1147 | self.ctl_nl() | |
1148 | self.c = 1 | |
1149 | # }}} | |
1150 | ||
1151 | def esc_set_tab(self): # {{{ | |
1152 | ||
1153 | if self.c <= len(self.tabstops): | |
1154 | self.tabstops[self.c - 1] = True | |
1155 | # }}} | |
1156 | ||
1157 | def esc_scroll_down(self): # {{{ | |
1158 | if self.l == self.top: | |
1159 | del self.screen[self.bottom] | |
1160 | self.screen.insert(self.top, '') | |
1161 | else: | |
1162 | self.l += -1 | |
1163 | ||
1164 | self.color_changes = {} | |
1165 | # }}} | |
1166 | ||
1167 | # }}} | |
1168 | ||
1169 | ############################################################################################### | |
1170 | # HASH functions {{{ | |
1171 | ||
1172 | def hash_screen_alignment_test(self): # {{{ | |
1173 | self.csi_clear_screen(self.parse_csi('2J')) | |
1174 | self.working_lines = self.lines | |
1175 | for l in range(1, self.lines + 1): | |
1176 | self.screen[l] = 'E' * self.working_columns | |
1177 | # }}} | |
1178 | ||
1179 | # }}} | |
1180 | ||
1181 | ############################################################################################### | |
1182 | # Random stuff {{{ | |
1183 | ||
1184 | def change_title(self, key, val): | |
1185 | ||
1186 | ||
1187 | if key == '0' or key == '2': | |
1188 | ||
1189 | vim.command('setlocal statusline=' + re.escape(val)) | |
1190 | ||
1191 | def paste(self): | |
1192 | self.write(vim.eval('@@')) | |
1193 | self.read(50) | |
1194 | ||
1195 | def paste_selection(self): | |
1196 | self.write(vim.eval('@@')) | |
1197 | ||
1198 | def update_window_size(self): | |
1199 | # resize if needed | |
1200 | if vim.current.window.width != self.columns or vim.current.window.height != self.lines: | |
1201 | ||
1202 | # reset all window size attributes to default | |
1203 | self.columns = vim.current.window.width | |
1204 | self.lines = vim.current.window.height | |
1205 | self.working_columns = vim.current.window.width | |
1206 | self.working_lines = vim.current.window.height | |
1207 | self.bottom = vim.current.window.height | |
1208 | ||
1209 | # reset screen object attributes | |
1210 | self.l = self.screen.reset_size(self.l) | |
1211 | ||
1212 | # reset tabstops | |
1213 | self.init_tabstops() | |
1214 | ||
1215 | ||
1216 | ||
1217 | # signal process that screen size has changed | |
1218 | self.proc.window_resize(self.lines, self.columns) | |
1219 | ||
1220 | def init_tabstops(self): | |
1221 | for i in range(0, self.columns + 1): | |
1222 | if i % 8 == 0: | |
1223 | self.tabstops.append(True) | |
1224 | else: | |
1225 | self.tabstops.append(False) | |
1226 | ||
1227 | # }}} | |
1228 | ||
1229 | ############################################################################################### | |
1230 | # Utility {{{ | |
1231 | ||
1232 | def parse_csi(self, s): # {{{ | |
1233 | attr = { 'key' : s[-1], 'flag' : '', 'val' : 1, 'vals' : [] } | |
1234 | ||
1235 | if len(s) == 1: | |
1236 | return attr | |
1237 | ||
1238 | full = s[0:-1] | |
1239 | ||
1240 | if full[0] == '?': | |
1241 | full = full[1:] | |
1242 | attr['flag'] = '?' | |
1243 | ||
1244 | if full != '': | |
1245 | vals = full.split(';') | |
1246 | for val in vals: | |
1247 | ||
1248 | val = re.sub("\D", "", val) | |
1249 | ||
1250 | if val != '': | |
1251 | attr['vals'].append(int(val)) | |
1252 | ||
1253 | if len(attr['vals']) == 1: | |
1254 | attr['val'] = int(attr['vals'][0]) | |
1255 | ||
1256 | return attr | |
1257 | # }}} | |
1258 | ||
1259 | def bound(self, val, min, max): # {{{ | |
1260 | if val > max: | |
1261 | return max | |
1262 | ||
1263 | if val < min: | |
1264 | return min | |
1265 | ||
1266 | return val | |
1267 | # }}} | |
1268 | ||
1269 | def xterm_to_rgb(self, color_code): # {{{ | |
1270 | if color_code < 16: | |
1271 | ascii_colors = ['000000', 'CD0000', '00CD00', 'CDCD00', '0000EE', 'CD00CD', '00CDCD', 'E5E5E5', | |
1272 | '7F7F7F', 'FF0000', '00FF00', 'FFFF00', '5C5CFF', 'FF00FF', '00FFFF', 'FFFFFF'] | |
1273 | return ascii_colors[color_code] | |
1274 | ||
1275 | elif color_code < 232: | |
1276 | cc = int(color_code) - 16 | |
1277 | ||
1278 | p1 = "%02x" % (math.floor(cc / 36) * (255/5)) | |
1279 | p2 = "%02x" % (math.floor((cc % 36) / 6) * (255/5)) | |
1280 | p3 = "%02x" % (math.floor(cc % 6) * (255/5)) | |
1281 | ||
1282 | return p1 + p2 + p3 | |
1283 | else: | |
1284 | grey_tone = "%02x" % math.floor((255/24) * (color_code - 232)) | |
1285 | return grey_tone + grey_tone + grey_tone | |
1286 | # }}} | |
1287 | ||
1288 | # }}} | |
1289 | ||
1290 | ||
1291 | import os, signal, pty, tty, select, fcntl, termios, struct | |
1292 | ||
1293 | ################################################################################################### | |
1294 | class ConqueSubprocess: | |
1295 | ||
1296 | # process id | |
1297 | pid = 0 | |
1298 | ||
1299 | # stdout+stderr file descriptor | |
1300 | fd = None | |
1301 | ||
1302 | # constructor | |
1303 | def __init__(self): # {{{ | |
1304 | self.pid = 0 | |
1305 | # }}} | |
1306 | ||
1307 | # create the pty or whatever (whatever == windows) | |
1308 | def open(self, command, env = {}): # {{{ | |
1309 | command_arr = command.split() | |
1310 | executable = command_arr[0] | |
1311 | args = command_arr | |
1312 | ||
1313 | try: | |
1314 | self.pid, self.fd = pty.fork() | |
1315 | ||
1316 | except: | |
1317 | pass | |
1318 | ||
1319 | ||
1320 | # child proc, replace with command after altering terminal attributes | |
1321 | if self.pid == 0: | |
1322 | ||
1323 | # set requested environment variables | |
1324 | for k in env.keys(): | |
1325 | os.environ[k] = env[k] | |
1326 | ||
1327 | # set some attributes | |
1328 | try: | |
1329 | attrs = tty.tcgetattr(1) | |
1330 | attrs[0] = attrs[0] ^ tty.IGNBRK | |
1331 | attrs[0] = attrs[0] | tty.BRKINT | tty.IXANY | tty.IMAXBEL | |
1332 | attrs[2] = attrs[2] | tty.HUPCL | |
1333 | attrs[3] = attrs[3] | tty.ICANON | tty.ECHO | tty.ISIG | tty.ECHOKE | |
1334 | attrs[6][tty.VMIN] = 1 | |
1335 | attrs[6][tty.VTIME] = 0 | |
1336 | tty.tcsetattr(1, tty.TCSANOW, attrs) | |
1337 | except: | |
1338 | pass | |
1339 | ||
1340 | os.execvp(executable, args) | |
1341 | ||
1342 | # else master, do nothing | |
1343 | else: | |
1344 | pass | |
1345 | ||
1346 | # }}} | |
1347 | ||
1348 | # read from pty | |
1349 | # XXX - select.poll() doesn't work in OS X!!!!!!! | |
1350 | def read(self, timeout = 1): # {{{ | |
1351 | ||
1352 | output = '' | |
1353 | read_timeout = float(timeout) / 1000 | |
1354 | ||
1355 | try: | |
1356 | # what, no do/while? | |
1357 | while 1: | |
1358 | s_read, s_write, s_error = select.select( [ self.fd ], [], [], read_timeout) | |
1359 | ||
1360 | lines = '' | |
1361 | for s_fd in s_read: | |
1362 | try: | |
1363 | lines = os.read( self.fd, 32 ) | |
1364 | except: | |
1365 | pass | |
1366 | output = output + lines | |
1367 | ||
1368 | if lines == '': | |
1369 | break | |
1370 | except: | |
1371 | pass | |
1372 | ||
1373 | return output | |
1374 | # }}} | |
1375 | ||
1376 | # I guess this one's not bad | |
1377 | def write(self, input): # {{{ | |
1378 | try: | |
1379 | os.write(self.fd, input) | |
1380 | except: | |
1381 | pass | |
1382 | # }}} | |
1383 | ||
1384 | # signal process | |
1385 | def signal(self, signum): # {{{ | |
1386 | try: | |
1387 | os.kill(self.pid, signum) | |
1388 | except: | |
1389 | pass | |
1390 | # }}} | |
1391 | ||
1392 | # get process status | |
1393 | def get_status(self): #{{{ | |
1394 | ||
1395 | p_status = True | |
1396 | ||
1397 | try: | |
1398 | if os.waitpid( self.pid, os.WNOHANG )[0]: | |
1399 | p_status = False | |
1400 | except: | |
1401 | p_status = False | |
1402 | ||
1403 | return p_status | |
1404 | ||
1405 | # }}} | |
1406 | ||
1407 | # update window size in kernel, then send SIGWINCH to fg process | |
1408 | def window_resize(self, lines, columns): # {{{ | |
1409 | try: | |
1410 | fcntl.ioctl(self.fd, termios.TIOCSWINSZ, struct.pack("HHHH", lines, columns, 0, 0)) | |
1411 | os.kill(self.pid, signal.SIGWINCH) | |
1412 | except: | |
1413 | pass | |
1414 | ||
1415 | # }}} | |
1416 | ||
1417 | ||
1418 | ################################################################################################### | |
1419 | # ConqueScreen is an extention of the vim.current.buffer object | |
1420 | # It restricts the working indices of the buffer object to the scroll region which pty is expecting | |
1421 | # It also uses 1-based indexes, to match escape sequence commands | |
1422 | # | |
1423 | # E.g.: | |
1424 | # s = ConqueScreen() | |
1425 | # ... | |
1426 | # s[5] = 'Set 5th line in terminal to this line' | |
1427 | # s.append('Add new line to terminal') | |
1428 | # s[5] = 'Since previous append() command scrolled the terminal down, this is a different line than first cb[5] call' | |
1429 | # | |
1430 | ||
1431 | import vim | |
1432 | ||
1433 | class ConqueScreen(object): | |
1434 | ||
1435 | # CLASS PROPERTIES {{{ | |
1436 | ||
1437 | # the buffer | |
1438 | buffer = None | |
1439 | ||
1440 | # screen and scrolling regions | |
1441 | screen_top = 1 | |
1442 | ||
1443 | # screen width | |
1444 | screen_width = 80 | |
1445 | screen_height = 80 | |
1446 | ||
1447 | # }}} | |
1448 | ||
1449 | def __init__(self): # {{{ | |
1450 | self.buffer = vim.current.buffer | |
1451 | ||
1452 | self.screen_top = 1 | |
1453 | self.screen_width = vim.current.window.width | |
1454 | self.screen_height = vim.current.window.height | |
1455 | # }}} | |
1456 | ||
1457 | ############################################################################################### | |
1458 | # List overload {{{ | |
1459 | def __len__(self): # {{{ | |
1460 | return len(self.buffer) | |
1461 | # }}} | |
1462 | ||
1463 | def __getitem__(self, key): # {{{ | |
1464 | real_line = self.get_real_idx(key) | |
1465 | ||
1466 | # if line is past buffer end, add lines to buffer | |
1467 | if real_line >= len(self.buffer): | |
1468 | for i in range(len(self.buffer), real_line + 1): | |
1469 | self.append(' ' * self.screen_width) | |
1470 | ||
1471 | return self.buffer[ real_line ] | |
1472 | # }}} | |
1473 | ||
1474 | def __setitem__(self, key, value): # {{{ | |
1475 | real_line = self.get_real_idx(key) | |
1476 | ||
1477 | # if line is past end of screen, append | |
1478 | if real_line == len(self.buffer): | |
1479 | self.buffer.append(value) | |
1480 | else: | |
1481 | self.buffer[ real_line ] = value | |
1482 | # }}} | |
1483 | ||
1484 | def __delitem__(self, key): # {{{ | |
1485 | del self.buffer[ self.screen_top + key - 2 ] | |
1486 | # }}} | |
1487 | ||
1488 | def append(self, value): # {{{ | |
1489 | if len(self.buffer) > self.screen_top + self.screen_height - 1: | |
1490 | self.buffer[len(self.buffer) - 1] = value | |
1491 | else: | |
1492 | self.buffer.append(value) | |
1493 | ||
1494 | if len(self.buffer) > self.screen_top + self.screen_height - 1: | |
1495 | self.screen_top += 1 | |
1496 | if vim.current.buffer.number == self.buffer.number: | |
1497 | vim.command('normal G') | |
1498 | # }}} | |
1499 | ||
1500 | def insert(self, line, value): # {{{ | |
1501 | ||
1502 | l = self.screen_top + line - 2 | |
1503 | self.buffer[l:l] = [ value ] | |
1504 | ||
1505 | # }}} | |
1506 | # }}} | |
1507 | ||
1508 | ############################################################################################### | |
1509 | # Util {{{ | |
1510 | def get_top(self): # {{{ | |
1511 | return self.screen_top | |
1512 | # }}} | |
1513 | ||
1514 | def get_real_idx(self, line): # {{{ | |
1515 | return (self.screen_top + line - 2) | |
1516 | # }}} | |
1517 | ||
1518 | def get_real_line(self, line): # {{{ | |
1519 | return (self.screen_top + line - 1) | |
1520 | # }}} | |
1521 | ||
1522 | def set_screen_width(self, width): # {{{ | |
1523 | self.screen_width = width | |
1524 | # }}} | |
1525 | ||
1526 | # }}} | |
1527 | ||
1528 | ############################################################################################### | |
1529 | def clear(self): # {{{ | |
1530 | self.buffer.append(' ') | |
1531 | vim.command('normal Gzt') | |
1532 | self.screen_top = len(self.buffer) | |
1533 | # }}} | |
1534 | ||
1535 | def set_cursor(self, line, column): # {{{ | |
1536 | # figure out line | |
1537 | real_line = self.screen_top + line - 1 | |
1538 | if real_line > len(self.buffer): | |
1539 | for l in range(len(self.buffer) - 1, real_line): | |
1540 | self.buffer.append('') | |
1541 | ||
1542 | # figure out column | |
1543 | real_column = column | |
1544 | if len(self.buffer[real_line - 1]) < real_column: | |
1545 | self.buffer[real_line - 1] = self.buffer[real_line - 1] + ' ' * (real_column - len(self.buffer[real_line - 1])) | |
1546 | ||
1547 | # python version is occasionally grumpy | |
1548 | try: | |
1549 | vim.current.window.cursor = (real_line, real_column - 1) | |
1550 | except: | |
1551 | vim.command('call cursor(' + str(real_line) + ', ' + str(real_column) + ')') | |
1552 | # }}} | |
1553 | ||
1554 | def reset_size(self, line): # {{{ | |
1555 | ||
1556 | ||
1557 | ||
1558 | ||
1559 | # save cursor line number | |
1560 | real_line = self.screen_top + line | |
1561 | ||
1562 | # reset screen size | |
1563 | self.screen_width = vim.current.window.width | |
1564 | self.screen_height = vim.current.window.height | |
1565 | self.screen_top = len(self.buffer) - vim.current.window.height + 1 | |
1566 | if self.screen_top < 1: | |
1567 | self.screen_top = 1 | |
1568 | ||
1569 | ||
1570 | # align bottom of buffer to bottom of screen | |
1571 | vim.command('normal ' + str(self.screen_height) + 'kG') | |
1572 | ||
1573 | # return new relative line number | |
1574 | return (real_line - self.screen_top) | |
1575 | # }}} | |
1576 | ||
1577 | def scroll_to_bottom(self): # {{{ | |
1578 | vim.current.window.cursor = (len(self.buffer) - 1, 1) | |
1579 | # }}} | |
1580 | ||
1581 | def align(self): # {{{ | |
1582 | # align bottom of buffer to bottom of screen | |
1583 | vim.command('normal ' + str(self.screen_height) + 'kG') | |
1584 | # }}} | |
1585 | ||
1586 | ||
1587 | EOF | |
1588 | ||
1589 | endif | |
1590 |